services/service/user.go

package service

import (
	"errors"
	"spaceofcheng/services/models"
	"spaceofcheng/services/models/card"
	"spaceofcheng/services/models/cases"
	"spaceofcheng/services/models/coupon"
	"spaceofcheng/services/models/customer"
	"spaceofcheng/services/models/goods"
	"spaceofcheng/services/models/model"
	"spaceofcheng/services/models/system"
	"spaceofcheng/services/utils"

	"github.com/astaxie/beego"
	"github.com/yl10/kit/encrypt"
)

// UserServ 系统处理
type UserServ struct {
	ctx         *utils.Context
	dao         *system.UserDAO
	casedao     *cases.CaseDAO
	customerdao *customer.CustomerDAO
	carddao     *card.CardDAO
	coupondao   *coupon.CouponDAO
	ordersdao   *goods.GoodsDAO
}

// NewUserServ 初始化
func NewUserServ(ctx *utils.Context) *UserServ {
	return &UserServ{
		ctx:         ctx,
		dao:         system.NewUserDAO(ctx),
		casedao:     cases.NewCaseDAO(ctx),
		customerdao: customer.NewCustomerDAO(ctx),
		carddao:     card.NewCardDAO(ctx),
		coupondao:   coupon.NewCouponDAO(ctx),
		ordersdao:   goods.NewGoodsDAO(ctx),
	}
}

// GetUserList 获取用户列表
func (s *UserServ) GetUserList(username, typeid, caseids string, page int, pageSize int) (map[string]interface{}, error) {
	if pageSize == 0 {
		pageSize = PAGENUM
	}
	if page == 0 {
		page = 1
	}
	userList, err := s.dao.GetUserList(username, typeid, caseids, page, pageSize)
	if err != nil {
		beego.Error(err)
		return nil, err
	}
	total, err := s.dao.GetUserCount(username, typeid, caseids)
	if err != nil {
		beego.Error(err)
		return nil, err
	}

	return map[string]interface{}{
		"list":     userList,
		"pagesize": pageSize,
		"pagenum":  total,
		"page":     page,
	}, nil
}

// GetCurrentEnvVars 获取当前环境相关变量
func (s *UserServ) GetCurrentEnvVars() (map[string]interface{}, error) {
	// 当前用户信息
	userRaw := s.ctx.Get("user")
	if userRaw == nil {
		return nil, utils.LogError("无有效用户信息")
	}

	user := userRaw.(model.SysUser)
	user.Pwd = ""
	// 当前用户案场
	sessionCase := s.ctx.Get("cases").([]model.SysUserCase)
	// caseIDs := ""
	// for _, value := range sessionCase {
	// 	if caseIDs != "" {
	// 		caseIDs = caseIDs + ","
	// 	}
	// 	caseIDs = caseIDs + value.CaseId
	// }
	// cases, err := s.casedao.GetCaseByIDs(caseIDs)
	// if err != nil {
	// 	beego.Error(err)
	// 	return nil, err
	// }
	// 当前用户角色
	roles, err := s.dao.GetUserRole(user.UserId)
	if err != nil {
		return nil, utils.LogError(err)
	}
	// 当前用户菜单
	menus, err := s.dao.GetUserMenu(user.UserId)
	if err != nil {
		beego.Error(err)
		return nil, utils.LogError(err)
	}

	rtn := map[string]interface{}{
		"user":      user,
		"cases":     sessionCase,
		"roles":     roles,
		"menus":     menus,
		"clienturl": beego.AppConfig.String("clienturl"),
	}

	return rtn, nil
}

// GetUserByID 根据用户ID获取用户信息
func (s *UserServ) GetUserByID(userid string) (*system.UserInfo, error) {
	userinfo, err := s.dao.GetUserByID(userid)
	if err != nil {
		beego.Error(err)
		return nil, err
	}
	if userinfo != nil {
		userinfo.Pwd = ""
		usertype, err := s.dao.GetUserType(userid)
		if err != nil {
			beego.Error(err)
			return nil, err
		}
		userinfo.UserType = usertype

		usertag, err := s.dao.GetUserTag(userid)
		if err != nil {
			beego.Error(err)
			return nil, err
		}
		userinfo.UserTag = usertag

		usercase, err := s.dao.GetUserCase(userid)
		if err != nil {
			beego.Error(err)
			return nil, err
		}
		userinfo.UserCase = usercase
	}
	// userrole, err := s.dao.GetUserRole(userid)
	// if err != nil {
	// 	return nil, err
	// }
	// userinfo.UserRole = userrole

	// usermenu, err := s.dao.GetUserMenu(userid)
	// if err != nil {
	// 	return nil, err
	// }
	// userinfo.UserMenu = usermenu

	return userinfo, nil
}

// SaveUser 用户保存
func (s *UserServ) SaveUser(user system.SysUserForm) (*model.SysUser, error) {
	var userInfo model.SysUser
	userInfo.UserId = user.UserId
	userInfo.UserId = user.UserId

	userInfo.UserId = user.UserId
	userInfo.UserName = user.UserName
	userInfo.RealName = user.RealName
	userInfo.OrgId = user.OrgId
	userInfo.Sex = user.Sex
	userInfo.WorkNo = user.WorkNo
	userInfo.Email = user.Email
	userInfo.Phone = user.Phone
	userInfo.Headimgurl = user.Headimgurl
	var flag bool = true
	for i := 0; i < 4; i++ {
		code := s.dao.GenerateRecommendCode()
		i, err := s.dao.IsCodeExist(code)
		if err != nil {
			return nil, errors.New("生成推荐码失败！请重新点击保存。")
		}
		if i <= 0 {
			userInfo.RecommendCode = code
			flag = false
			break
		}
	}
	if flag {
		return nil, errors.New("生成推荐码失败！请重新点击保存。")
	}

	org := s.ctx.Get("org").(model.SysOrg)
	user.OrgId = org.OrgId
	userInfo.OrgId = user.OrgId
	var err error
	var newUSer *model.SysUser

	if user.UserName == "" {
		return nil, errors.New("用户名不允许为空！")
	}
	if user.RealName == "" {
		return nil, errors.New("用户真实姓名不允许为空！")
	}
	if user.Phone == "" {
		return nil, errors.New("用户手机号不能为空！")
	}
	// 手机号码与用户名校验
	var isok bool
	isok, err = s.dao.CheckUserName(user.UserId, user.UserName, user.OrgId)
	if err != nil {
		beego.Error(err)
		return nil, err
	}
	if !isok {
		return nil, errors.New("用户名重复！")
	}
	isok, err = s.dao.CheckUserPhone(user.UserId, user.Phone, user.OrgId)
	if err != nil {
		beego.Error(err)
		return nil, err
	}
	if !isok {
		return nil, errors.New("手机号码重复！")
	}
	if user.UserId != "" {
		err = s.dao.UpdateUser(userInfo)
		if err != nil {
			beego.Error(err)
			return nil, err
		}
		// 删除用户对应的标签、用户类型及所属案场
		err = s.dao.DelUserTag(user.UserId)
		if err != nil {
			beego.Error(err)
			return nil, err
		}
		err = s.dao.DelUserType(user.UserId)
		if err != nil {
			beego.Error(err)
			return nil, err
		}
		// err = s.dao.DelUserBelongCase(user.UserId)
		// if err != nil {
		// 	beego.Error(err)
		// 	return nil, err
		// }
		err = s.dao.DelUserCase(user.UserId)
		if err != nil {
			beego.Error(err)
			return nil, err
		}
		newUSer = &userInfo
	} else {
		l, err := s.dao.IsCodeExist(userInfo.RecommendCode)
		if err != nil {
			beego.Error(err)
			return nil, err
		}
		if l > 0 {
			return nil, errors.New("此推荐码已被使用！")
		}
		newUSer, err = s.dao.AddUser(userInfo)
		if err != nil {
			beego.Error(err)
			return nil, err
		}
	}

	// 保存用户的标签、用户类型及所属案场
	err = s.dao.SaveUserTag(newUSer.UserId, user.TagIds)
	if err != nil {
		beego.Error(err)
		return nil, err
	}
	err = s.dao.SaveUserType(newUSer.UserId, user.TypeId)
	if err != nil {
		beego.Error(err)
		return nil, err
	}
	caseInfo, err := s.casedao.GetCaseByID(user.BelongCaseId)
	if err != nil {
		beego.Error(err)
		return nil, err
	}
	if caseInfo == nil {
		return nil, errors.New("所属案场不存在！")
	}
	has, err := s.dao.GetUserCreatedCaseHas(newUSer.UserId, user.BelongCaseId)
	if err != nil {
		return nil, errors.New("获取用户所属案场失败！")
	}
	if has {
		err = s.dao.UpdateUserCaseBelong(newUSer.UserId, user.BelongCaseId)
		if err != nil {
			beego.Error(err)
			return nil, err
		}
	} else {
		var userCase model.SysUserCase
		userCase.CaseId = user.BelongCaseId
		userCase.CaseName = caseInfo.CaseName
		userCase.IsBelong = 1
		userCase.UserId = newUSer.UserId
		err = s.dao.SaveUserCase(userCase)
		if err != nil {
			beego.Error(err)
			return nil, err
		}
	}

	// 保存用户标签案场信息
	err = s.dao.SaveUserCaseByUserTag(newUSer.UserId, user.BelongCaseId)
	if err != nil {
		beego.Error(err)
		return nil, err
	}
	newUSer.Pwd = ""

	// 保存用户后判断用户是否在客户表中，如果存在，更新
	cust, err := s.customerdao.GetCustomerByPhone(newUSer.Phone)
	if err != nil {
		utils.LogError(err.Error())
		return nil, err
	}
	if cust != nil {
		cust.UserId = newUSer.UserId
		err = s.customerdao.UpdateCustomer(cust, []string{
			"user_id",
		})
		if err != nil {
			utils.LogError(err.Error())
			return nil, err
		}
		// 更新用户映射信息
		customerMap, err := s.customerdao.GetCustWithWXByID(cust.CustomerId)
		if err != nil {
			utils.LogError(err.Error())
			return nil, err
		}
		var userMap = model.TaUserMapping{
			UserId:    cust.CustomerId,
			MappingId: customerMap.MappingId,
		}
		if err := s.dao.UpdateUserMapping(&userMap, []string{"user_id"}); err != nil {
			utils.LogError("更新用户映射信息失败:" + err.Error())
			return nil, errors.New("映射用户信息失败")
		}
	}
	return newUSer, err
}

// UpdatePassword 密码修改
func (s *UserServ) UpdatePassword(oriPasswd, newPasswd string, user *model.SysUser) error {
	if !s.dao.ValidatePassword(user, oriPasswd) {
		return errors.New("密码错误！")
	}

	if err := s.dao.UpdatePassword(user.UserId, newPasswd); err != nil {
		return err
	}

	return nil
}

// ResetPassword 重设密码
func (s *UserServ) ResetPassword(userid string) error {
	newPasswd := encrypt.Md5("123456")
	if err := s.dao.UpdatePassword(userid, newPasswd); err != nil {
		return err
	}

	return nil
}

// UserMapping 用户隐射
func (s *UserServ) UserMapping(userMapping model.TaUserMapping) error {
	err := s.dao.SaveUserMapping(&userMapping)
	if err != nil {
		return err
	}
	// info := make(map[string]string)
	// err = json.Unmarshal([]byte(userMapping.AccountInfo), &info)
	// if err != nil {
	// 	beego.Error("Umarshal failed:", err)
	// 	return err
	// }
	// // 根据用户类型更新用户表中的数据
	// switch userMapping.UserType {
	// case USERTYPE_USER:
	// 	err = s.dao.UpdateUserHeadImg(userMapping.UserId, info["headimgurl"])
	// 	break
	// case USERTYPE_CUSTOMER:
	// 	err = s.dao.UpdateCustomerHeadImg(userMapping.UserId, info["nickname"], info["headimgurl"])
	// 	break
	// }
	return nil
}

// DelUser 删除用户
func (s *UserServ) DelUser(userid string) error {
	err := s.dao.DelUser(userid)
	if err != nil {
		return err
	}
	// 删除与前台客户的关联
	err = s.dao.UnleashCustomerUser(userid)
	return err
}

// GetUserTypes 获取用户类型
func (s *UserServ) GetUserTypes(orgid string) ([]model.TdUserType, error) {
	types, err := s.dao.GetUserTypes(orgid)
	return types, err
}

// GetUserRoles 获取用户角色
func (s *UserServ) GetUserRoles(userid string) ([]model.SysRole, error) {
	if userid == "" {
		return nil, utils.LogError("没有对应的用户信息！")
	}
	userroles, err := s.dao.GetUserRole(userid)
	return userroles, err
}

// SaveUserRole 保存用户对应角色
func (s *UserServ) SaveUserRole(userid, roleids string) error {
	if userid == "" {
		return utils.LogError("没有对应的用户信息！")
	}
	if roleids == "" {
		return utils.LogError("没有对应的角色信息！")
	}
	err := s.dao.DelUserRole(userid)
	if err != nil {
		return err
	}
	err = s.dao.SaveUserRole(userid, roleids)
	if err != nil {
		return err
	}
	err = s.dao.DelUserMenu(userid)
	if err != nil {
		return err
	}
	err = s.dao.SaveUserMenu(userid)
	return err
}

// GetUserCustomer 获取我的推荐客户
func (s *UserServ) GetUserCustomer(userid, isrecommend, key string, page int, pageSize int) ([]system.CustomerInfo, error) {
	if pageSize == 0 {
		pageSize = PAGENUM
	}
	if page == 0 {
		page = 1
	}
	customers, err := s.dao.GetUserCustomer(userid, isrecommend, key, page, pageSize)
	return customers, err
}

// CheckUserSignIn 校验用户登录
func (s *UserServ) CheckUserSignIn(userName, userPassword string) (*model.SysUser, error) {
	user, err := s.dao.GetUserByName(userName)
	if err != nil {
		beego.Error(err)
		return nil, err
	}

	if user == nil {
		return nil, errors.New("账户不存在")
	}

	if user.Status != models.STATUS_NORMAL {
		return nil, errors.New("用户账户异常")
	}

	if !s.dao.ValidatePassword(user, userPassword) {
		return nil, errors.New("用户密码不正确")
	}

	return user, nil
}

// GetUserByTel 根据电话获取用户信息
func (s *UserServ) GetUserByTel(tel string) (*model.SysUser, error) {
	user, err := s.dao.GetUserByPhone(tel)
	return user, err
}

// GetForbidUsers 获取所有禁止人员信息
func (s *UserServ) GetForbidUsers() ([]model.TaForbidUser, error) {
	customer := s.ctx.Get("customer").(model.TaCustomer)
	if customer.CustomerId == "" || customer.UserId == "" {
		return nil, errors.New("当前用户没有权限查看用户信息")
	}
	caseinfo, err := s.dao.GetUserBelongCase(customer.UserId)
	if err != nil {
		return nil, err
	}
	// if err := utils.NewAuthEngine(s.ctx).CheckCase(caseid); err != nil {
	// 	return nil, err
	// }
	users, err := s.dao.GetForbidUsers(caseinfo.CaseId)
	return users, err
}

// SaveForbidUser 保存禁止人员信息
func (s *UserServ) SaveForbidUser(userid string, forbidtype string) error {
	user, err := s.dao.GetUserByID(userid)
	if err != nil {
		return err
	}
	if user.Status != models.STATUS_NORMAL {
		return errors.New("设置的用户状态异常！不允许操作！")
	}

	usercase, err := s.dao.GetUserBelongCase(userid)
	if err != nil {
		return err
	}
	if usercase.CaseId == "" {
		return errors.New("用户不存在所属案场！不允许操作！")
	}
	if err := utils.NewAuthEngine(s.ctx).CheckCase(usercase.CaseId); err != nil {
		return err
	}
	fibUsers, err := s.dao.GetForbidUserByUserID(userid)
	if err != nil {
		return err
	}
	if fibUsers != nil && len(fibUsers) > 0 {
		for _, u := range fibUsers {
			if u.ForbidType == forbidtype && u.Status == models.STATUS_NORMAL {
				return errors.New("当前人员已经被禁止！不允许重复禁止")
			}
		}
	}

	var usertype = ""
	if len(user.UserType) > 0 {
		usertype = user.UserType[0].TypeId
	}

	var forbiduser = model.TaForbidUser{
		UserId:     user.UserId,
		UserType:   usertype,
		ForbidType: forbidtype,
		CaseId:     usercase.CaseId,
	}

	err = s.dao.SaveForbidUser(&forbiduser)
	if err != nil {
		return err
	}
	// 发送短信
	if forbidtype == models.FORBID_COUPON {
		utils.SendSMS("couponclose", user.Phone)
	} else {
		utils.SendSMS("goodsclose", user.Phone)
	}

	return nil
}

// OpenForbidUser 开启禁止人员
func (s *UserServ) OpenForbidUser(userid string, forbidtype string) error {
	user, err := s.dao.GetUserByID(userid)
	if err != nil {
		return err
	}
	if user.Status != models.STATUS_NORMAL {
		return errors.New("设置的用户状态异常！不允许操作！")
	}

	usercase, err := s.dao.GetUserBelongCase(userid)
	if err != nil {
		return err
	}
	if usercase.CaseId == "" {
		return errors.New("用户不存在所属案场！不允许操作！")
	}
	if err := utils.NewAuthEngine(s.ctx).CheckCase(usercase.CaseId); err != nil {
		return err
	}
	fibUsers, err := s.dao.GetForbidUserByUserID(userid)
	if err != nil {
		return err
	}
	var ishas = false
	var forbiduser = model.TaForbidUser{}
	if fibUsers != nil && len(fibUsers) > 0 {
		for _, u := range fibUsers {
			if u.ForbidType == forbidtype && u.Status == models.STATUS_NORMAL {
				ishas = true
				forbiduser = u
			}
		}
	}

	if !ishas {
		return errors.New("用户没有被关闭的功能！")
	}
	err = s.dao.OpenForbidUser(&forbiduser)
	return err
}

// GetCaseUserByType 根据用户类型获取人员信息
func (s *UserServ) GetCaseUserByType(usertype string) ([]system.UserWithCouponAndCard, error) {
	customer := s.ctx.Get("customer").(model.TaCustomer)
	if customer.CustomerId == "" || customer.UserId == "" {
		return nil, errors.New("当前用户没有权限查看用户信息")
	}
	caseinfo, err := s.dao.GetUserBelongCase(customer.UserId)
	if err != nil {
		utils.LogError("获取人员归属案场失败: " + err.Error())
		return nil, errors.New("获取人员信息失败")
	}

	users, err := s.dao.GetCaseUserByType(caseinfo.CaseId, usertype)
	if err != nil {
		utils.LogError("获取人员信息失败: " + err.Error())
		return nil, errors.New("获取人员信息失败")
	}

	for inx, user := range users {
		err := s.GetUserWithDetail(caseinfo.CaseId, &user)
		if err != nil {
			return nil, err
		}
		users[inx] = user
	}
	return users, nil
}

// GetCaseUserByUserID 根据用户id获取人员信息
func (s *UserServ) GetCaseUserByUserID(userid string) (*system.UserWithCouponAndCard, error) {
	customer := s.ctx.Get("customer").(model.TaCustomer)
	if customer.CustomerId == "" || customer.UserId == "" {
		return nil, errors.New("当前用户没有权限查看用户信息")
	}
	caseinfo, err := s.dao.GetUserBelongCase(customer.UserId)
	if err != nil {
		utils.LogError("获取人员归属案场失败: " + err.Error())
		return nil, errors.New("获取人员信息失败")
	}
	usercaseinfo, err := s.dao.GetUserBelongCase(userid)
	if err != nil {
		utils.LogError("获取人员归属案场失败: " + err.Error())
		return nil, errors.New("获取人员信息失败")
	}
	if usercaseinfo.CaseId != caseinfo.CaseId {
		return nil, errors.New("您没有权限查看此用户的数据！")
	}
	user, err := s.dao.GetUserDetailByID(userid)
	if err != nil {
		utils.LogError("获取人员信息失败: " + err.Error())
		return nil, errors.New("获取人员信息失败")
	}
	err = s.GetUserWithDetail(usercaseinfo.CaseId, user)
	if err != nil {
		return nil, err
	}
	return user, nil
}

// GetUserWithDetail 获取用户详情
func (s *UserServ) GetUserWithDetail(caseid string, user *system.UserWithCouponAndCard) error {
	cards, err := s.carddao.GetCustomerCardByUser(caseid, user.UserId)
	if err != nil {
		utils.LogError("获取发送卡信息失败: " + err.Error())
		return errors.New("获取人员信息失败")
	}
	user.CustomerCard = cards
	coupons, err := s.coupondao.GetCustomerCouponByUser(caseid, user.UserId)
	if err != nil {
		utils.LogError("获取发送券信息失败: " + err.Error())
		return errors.New("获取人员信息失败")
	}
	user.CustomerCoupon = coupons
	details, err := s.ordersdao.GetOrderDetailByUser(caseid, user.UserId)
	if err != nil {
		utils.LogError("获取用户点单信息失败: " + err.Error())
		return errors.New("获取人员信息失败")
	}
	user.OrdersDetail = details
	return nil
}