userProcess.go

package process

import (
“encoding/json”
“fmt”
“net”
//没有引入message包，和utils包与model包
)

type UserProcess struct {
//字段
Conn net.Conn
//增加一个字段，表示该Conn是哪个用户的
UserId int
}
//这里我们编写通知所有在线的用户的方法
//userId要通知其他的在线用户，我上线
func(this *UserProcess)NotifyothersOnlineUser(userId int){
//遍历onlineUsers，然后一个一个的发送NotifyotherStatusMes
for id,up:=range this.onlineUsers{
//过滤到自己
if id == userId{
continue
}
//开始通知[单独的写一个方法]
up.NotifyMeOnline(userId)
}
}
func(this *UserProcess)NotifyMeonline(userId int){
//组装我们的NotifyUserStatusMes
var mes message.Message
mes.Type=message.NotifyUserStatusMes
notifyUserStatusmes.UsersId=userId
notifyUserStatusMes.Status=message.UserOnline

//将notifyUserStatusMes序列化
data,err:=json.Marshal(message.NotifyUserStatusMes)
if err!=nil{
	fmt.Println("json.Marshal err=",err)
	return
}
//将序列化后的notifyUserStatusMes赋值给mes.Data
mes.Data=string(data)
//对mes再次序列化，准备发送，
data,err=json.Marshal(mes)
if err!=nil {
	fmt.Println("json.Marshal err=", err)
	return
}
//发送，创建我们Transfer实例，发送
tf:=&utis.Transfer{
	Conn:this.Conn,
}

err=tf.WritePkg(data)
if err!=nil{
	fmt.Println("NotifyMeOnline err=",err)
	return
}

}

func(this *UserProcess)serverProcessRegister(mes *message.Message)(err error){
//1.先从mes中取出mes.Data，并直接反序列化成registerMes
var registerMes message.RegisterMes
err=json.Unmarshal([]byte(mes.data),&registerMes)
if err!=nil{
fmt.Println(“json.Unmarshal fail err=”,err)
return
}
//1先声明一个resMes
var resMes message.Message
resMes.Type=message.RegisterResMesType
//2在声明一个LoginResMes,并完成赋值
var registerResMes message.RegisterResMes

//我们需要到redis数据库去完注册。
//1.使用model.MyUserDao 到redis去验证
err=model.MyuserDao.Register(&registerMes,User)

if err!=nil{
	if err==ERROR_USER_EXISTS {
		registerMes.Code = 505
		registerMes.Error = model.ERROR_USER_EXISTS.Error()
	}else {
		registerMes.Code=506
		registerMes.Error="注册发生未知错误...."

	}
}else {
	registerMes.Code=200
}
data,err:=json.Marshal(registerMes)
if err!=nil{
	fmt.Println("json.Marshal fail",err)
	return
}

//4.将data赋值给resMes
resMes.Data=string(data)
//5.对resMes进行序列化，准备发送
data,err=json.Marshal(resMes)
if err!=nil{
	fmt.Println("json.Marshal fail",err)
	return
}
//6.发送data 我们将其封装到write
//因为使用分层模式（mvc），我们先创建一个Transfer实例，然后读取
tf:=&utils.Transfer{
	conn:this.Conn,
}
err=tf.writePkg(data)
return

}

//编写一个函数ServerProcessLogin函数，专门处理登录请求
func (this UserProcess)serverProcessLogin(conn net.Conn,mesmessage.Message)(err error){
//核心代码
//1.先从mes中取出mes.Data，并直接反序列化成LoginMes
var loginMes Message.LoginMes
json.Unmarshal([]byte(mes.data),&loginMes)
if err!=nil{
fmt.Println(“json.Unmarshal fail err=”,err)
return
}

//我们需要到redis数据库去完成验证。
//1.使用model.MyUserDao 到redis去验证
user,err:=model.MyuserDao.Login(loginResMes.UserId,loginMes.UserPwd)
if err!=nil{
	if err==moder.ERROR_USER_NOTEXTSTS{
		loginResMes.Code=500
		loginResMes.Error=err.Error()
	}else if err ==model.ERROR_USER_PWD{
		loginResMes.Code=403
		loginResMes.Error=err.Error()
	}else {
		loginResMes.Code=505
		loginResMes.Error="服务器内部错误..."
     }
	//这里我们先测试成功！,然后我们在可以根据返回具体错误信息
}else {
	loginResMes.Code=200
	//这里，因为用户登陆成功，我们就把该登陆成功的用户放入到userMgr中
	//将登陆成功的用户的userId赋给this
	this.UserId=loginMes.UserId
	userMgr.AddOnlineUser(this)
	//通知其他的在线用户，我上线了。
	this.NotifyothersOnlineUser(loginMes.UserId)
	//将当前在线用户的id放入到loginResMes.UsersId
	//遍历userMgr.onlineUsers
	for id,_:=range userMgr.onlineUsers{
		loginMes.UsersId=append(loginResMes.UsersId,id)
	}


	fmt.Println(user,"登录成功")
}
//如果用户id=100，密码=123456，认为合法，否则不合法
//if loginMes.UserId==100&&loginMes.UserPwd=="123456"{
//
//	//合法
//	loginMes.Code=200
//
//}else{
//	//不合法
//	loginMes.Code=500//500状态码，表示该用户不存在
//	loginResMes.Error="该用户不存在，该注册再使用..."
//
//}
//3将 loginResMes序列化
data,err:=json.Marshal(loginResMes)
if err!=nil{
	fmt.Println("json.Marshal fail",err)
	return
}
//4.将data赋值给resMes
resMes.Data=string(data)
//5.对resMes进行序列化，准备发送
data,err=json.Marshal(resMes)
if err!=nil{
	fmt.Println("json.Marshal fail",err)
	return
}
//6.发送data 我们将其封装到write
//因为使用分层模式（mvc），我们先创建一个Transfer实例，然后读取
tf:=&utils.Transfer{
	conn:this.Conn,
}
err=tf.writePkg(data)
return

}
//编写一个ServerProcessMes函数
//功能：根据客户端发送消息种类不同，决定调用哪个函数来处理