eta_mini_crm/controllers/users.go

package controllers

import (
	"encoding/json"
	"eta/eta_mini_crm/models"
	"eta/eta_mini_crm/models/request"
	"eta/eta_mini_crm/models/response"
	"eta/eta_mini_crm/utils"
	"fmt"
	"github.com/rdlucklib/rdluck_tools/paging"
	"strconv"
	"strings"
	"time"
)

// UsersController 用户
type UsersController struct {
	BaseAuthController
}

// Add
// @Title 新增用户
// @Description 新增用户
// @Param	request	body request.UsersAddReq true "type json string"
// @Success 200 Ret=200 操作成功
// @router /add [post]
func (this *UsersController) Add() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req request.UsersAddReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常"
		br.ErrMsg = fmt.Sprintf("参数解析异常, %v", e)
		return
	}
	req.RealName = strings.TrimSpace(req.RealName)
	if req.RealName == "" {
		br.Msg = "请输入用户姓名"
		return
	}
	req.AreaCode = strings.TrimSpace(req.AreaCode)
	if req.AreaCode == "" {
		br.Msg = "请选择手机号区号"
		return
	}
	req.Mobile = strings.TrimSpace(req.Mobile)
	if req.Mobile == "" {
		br.Msg = "请输入手机号"
		return
	}
	if req.AreaCode == utils.AreaCodeMainland && !utils.ValidateMobileFormatat(req.Mobile) {
		br.Msg = "手机号格式有误"
		return
	}
	// 销售如果是空的那么创建人即为销售
	var (
		sellerId                int
		sellerName, companyName string
	)
	if req.SellerId > 0 {
		sellerId = req.SellerId
	}
	if req.CompanyId > 0 {
		companyOb := new(models.Company)
		companyItem, e := companyOb.GetItemById(req.CompanyId)
		if e != nil {
			if e.Error() == utils.ErrNoRow() {
				br.Msg = "所选机构不存在，请刷新页面"
				return
			}
			br.Msg = "操作失败"
			br.ErrMsg = fmt.Sprintf("获取机构失败, %v", e)
			return
		}
		companyName = companyItem.CompanyName
		// 未传销售ID那么取机构销售
		if sellerId <= 0 {
			sellerId = companyItem.SellerId
		}
	}
	if sellerId > 0 {
		sellerItem, e := models.GetSysUserById(req.SellerId)
		if e != nil {
			if e.Error() == utils.ErrNoRow() {
				br.Msg = "所选营业部不存在，请刷新页面"
				return
			}
			br.Msg = "操作失败"
			br.ErrMsg = fmt.Sprintf("获取营业部销售失败, %v", e)
			return
		}
		sellerName = sellerItem.SysRealName
	}

	// 校验手机号是否存在
	usersOb := new(models.Users)
	{
		cond := fmt.Sprintf(` AND %s = ?`, usersOb.Cols().Mobile)
		pars := make([]interface{}, 0)
		pars = append(pars, req.Mobile)
		exist, e := usersOb.GetItemByCondition(cond, pars, "")
		if e != nil && e.Error() != utils.ErrNoRow() {
			br.Msg = "操作失败"
			br.ErrMsg = fmt.Sprintf("获取重复手机号失败, %v", e)
			return
		}
		if exist != nil && exist.UserId > 0 {
			br.Msg = "手机号已存在"
			return
		}
	}

	usersOb.RealName = req.RealName
	usersOb.Mobile = req.Mobile
	usersOb.AreaCode = req.AreaCode
	usersOb.SellerId = sellerId
	usersOb.SellerName = sellerName
	usersOb.SysUserId = sysUser.SysUserId
	usersOb.SysUserRealName = sysUser.SysRealName
	usersOb.CompanyId = req.CompanyId
	usersOb.CompanyName = companyName
	usersOb.Status = models.UserStatusFormal
	usersOb.AuthStatus = models.AuthStatusOpen
	usersOb.CreateTime = time.Now().Local()
	usersOb.ModifyTime = time.Now().Local()
	if e := usersOb.Create(); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("新增用户失败, %v", e)
		return
	}

	// 操作记录
	go func() {
		recordOb := new(models.CompanyUserOperateRecord)
		recordOb.UserId = usersOb.UserId
		recordOb.Remark = fmt.Sprintf("%s新增用户", sysUser.SysRealName)
		recordOb.SysUserId = sysUser.SysUserId
		recordOb.SysUserRealName = sysUser.SysRealName
		recordOb.CreateTime = time.Now().Local()
		if e := recordOb.Create(); e != nil {
			utils.FileLog.Info(fmt.Sprintf("新增操作记录失败, UserId: %d, ErrMsg: %v", usersOb.UserId, e))
		}
	}()

	br.Ret = 200
	br.Msg = "操作成功"
	br.Success = true
}

// Edit
// @Title 编辑用户
// @Description 编辑用户
// @Param	request	body request.UsersEditReq true "type json string"
// @Success 200 Ret=200 操作成功
// @router /edit [post]
func (this *UsersController) Edit() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req request.UsersEditReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常"
		br.ErrMsg = fmt.Sprintf("参数解析异常, %v", e)
		return
	}
	if req.UserId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数有误, UserId: %d", req.UserId)
		return
	}
	req.RealName = strings.TrimSpace(req.RealName)
	if req.RealName == "" {
		br.Msg = "请输入用户姓名"
		return
	}
	req.AreaCode = strings.TrimSpace(req.AreaCode)
	if req.AreaCode == "" {
		br.Msg = "请选择手机号区号"
		return
	}
	req.Mobile = strings.TrimSpace(req.Mobile)
	if req.Mobile == "" {
		br.Msg = "请输入手机号"
		return
	}
	if req.AreaCode == utils.AreaCodeMainland && !utils.ValidateMobileFormatat(req.Mobile) {
		br.Msg = "手机号格式有误"
		return
	}
	// 销售如果是空的那么创建人即为销售
	var sellerName, companyName string
	if req.SellerId <= 0 {
		req.SellerId = sysUser.SysUserId
		sellerName = sysUser.SysRealName
	}
	if req.SellerId > 0 {
		sellerItem, e := models.GetSysUserById(req.SellerId)
		if e != nil {
			if e.Error() == utils.ErrNoRow() {
				br.Msg = "所选营业部不存在，请刷新页面"
				return
			}
			br.Msg = "操作失败"
			br.ErrMsg = fmt.Sprintf("获取营业部销售失败, %v", e)
			return
		}
		sellerName = sellerItem.SysRealName
	}
	if req.CompanyId > 0 {
		companyOb := new(models.Company)
		companyItem, e := companyOb.GetItemById(req.CompanyId)
		if e != nil {
			if e.Error() == utils.ErrNoRow() {
				br.Msg = "所选机构不存在，请刷新页面"
				return
			}
			br.Msg = "操作失败"
			br.ErrMsg = fmt.Sprintf("获取机构失败, %v", e)
			return
		}
		companyName = companyItem.CompanyName
	}
	usersOb := new(models.Users)
	userItem, e := usersOb.GetItemById(req.UserId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "用户不存在，请刷新页面"
			return
		}
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取用户失败, %v", e)
		return
	}

	// 校验手机号是否存在
	{
		cond := fmt.Sprintf(` AND %s = ? AND %s <> ?`, usersOb.Cols().Mobile, usersOb.Cols().PrimaryId)
		pars := make([]interface{}, 0)
		pars = append(pars, req.Mobile, req.UserId)
		exist, e := usersOb.GetItemByCondition(cond, pars, "")
		if e != nil && e.Error() != utils.ErrNoRow() {
			br.Msg = "操作失败"
			br.ErrMsg = fmt.Sprintf("获取重复手机号失败, %v", e)
			return
		}
		if exist != nil && exist.UserId > 0 {
			br.Msg = "手机号已存在"
			return
		}
	}

	updateCols := []string{usersOb.Cols().RealName, usersOb.Cols().Mobile, usersOb.Cols().AreaCode}
	userItem.RealName = req.RealName
	userItem.Mobile = req.Mobile
	userItem.AreaCode = req.AreaCode
	if req.SellerId > 0 {
		userItem.SellerId = req.SellerId
		userItem.SellerName = sellerName
		updateCols = append(updateCols, usersOb.Cols().SellerId, usersOb.Cols().SellerName)
	}
	if req.CompanyId > 0 {
		userItem.CompanyId = req.CompanyId
		userItem.CompanyName = companyName
		updateCols = append(updateCols, usersOb.Cols().CompanyId, usersOb.Cols().CompanyName)
	}
	userItem.ModifyTime = time.Now().Local()
	if e := userItem.Update(updateCols); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("编辑用户失败, %v", e)
		return
	}

	// 操作记录
	go func() {
		recordOb := new(models.CompanyUserOperateRecord)
		recordOb.UserId = userItem.UserId
		recordOb.Remark = fmt.Sprintf("%s编辑用户", sysUser.SysRealName)
		recordOb.SysUserId = sysUser.SysUserId
		recordOb.SysUserRealName = sysUser.SysRealName
		recordOb.CreateTime = time.Now().Local()
		if e := recordOb.Create(); e != nil {
			utils.FileLog.Info(fmt.Sprintf("新增操作记录失败, UserId: %d, ErrMsg: %v", userItem.UserId, e))
		}
	}()

	br.Ret = 200
	br.Msg = "操作成功"
	br.Success = true
}

// CheckAdd
// @Title 新增用户校验
// @Description 新增用户校验
// @Param	request	body request.UsersAddReq true "type json string"
// @Success 200 Ret=200 操作成功
// @router /add/check [post]
func (this *UsersController) CheckAdd() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req request.UsersAddReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常"
		br.ErrMsg = fmt.Sprintf("参数解析异常, %v", e)
		return
	}
	req.AreaCode = strings.TrimSpace(req.AreaCode)
	if req.AreaCode == "" {
		br.Msg = "请选择手机号区号"
		return
	}
	req.Mobile = strings.TrimSpace(req.Mobile)
	if req.Mobile == "" {
		br.Msg = "请输入手机号"
		return
	}
	if req.AreaCode == utils.AreaCodeMainland && !utils.ValidateMobileFormatat(req.Mobile) {
		br.Msg = "手机号格式有误"
		return
	}

	// 校验手机号是否存在，区分不同情况
	usersOb := new(models.Users)
	cond := fmt.Sprintf(` AND %s = ?`, usersOb.Cols().Mobile)
	pars := make([]interface{}, 0)
	pars = append(pars, req.Mobile)
	exist, e := usersOb.GetItemByCondition(cond, pars, "")
	if e != nil && e.Error() != utils.ErrNoRow() {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("获取重复手机号失败, %v", e)
		return
	}

	resp := new(response.UsersAddCheckResp)
	resp.Tips = "校验通过"
	if exist != nil {
		// 试用客户
		if exist.Status == models.UserStatusTrial {
			resp.CheckResult = 1
			resp.Tips = "该客户已存在试用用户列表，是否确认将该用户移至当前客户下？"
		}
		// 个人投资者
		if exist.Status == models.UserStatusFormal && exist.CompanyId == 0 {
			resp.CheckResult = 2
			resp.Tips = "该用户已存在个人投资列表"
		}
		// 机构联系人
		if exist.Status == models.UserStatusFormal && exist.CompanyId > 0 {
			companyOb := new(models.Company)
			company, e := companyOb.GetItemById(exist.CompanyId)
			if e != nil {
				br.Msg = "操作失败"
				br.ErrMsg = fmt.Sprintf("获取联系人机构失败, %v", e)
				return
			}
			resp.CheckResult = 3
			resp.Tips = fmt.Sprintf("该用户已存在【%s】客户下", company.CompanyName)
		}
	}

	br.Data = resp
	br.Ret = 200
	br.Msg = "操作成功"
	br.Success = true
}

// Move
// @Title 移动用户
// @Description 移动用户
// @Param	request	body request.UsersMoveReq true "type json string"
// @Success 200 Ret=200 操作成功
// @router /move [post]
func (this *UsersController) Move() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req request.UsersMoveReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常"
		br.ErrMsg = fmt.Sprintf("参数解析异常, %v", e)
		return
	}
	if req.UserId <= 0 {
		br.Msg = "请选择用户"
		return
	}
	if req.CompanyId <= 0 {
		br.Msg = "请选择机构"
		return
	}
	usersOb := new(models.Users)
	userItem, e := usersOb.GetItemById(req.UserId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "用户不存在，请刷新页面"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("获取用户失败, %v", e)
		return
	}

	companyOb := new(models.Company)
	companyItem, e := companyOb.GetItemById(req.CompanyId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "机构不存在，请刷新页面"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("获取机构失败, %v", e)
		return
	}

	userItem.CompanyId = req.CompanyId
	userItem.CompanyName = companyItem.CompanyName
	userItem.AuthStatus = companyItem.AuthStatus
	userItem.ModifyTime = time.Now().Local()
	updateCols := []string{usersOb.Cols().CompanyId, usersOb.Cols().CompanyName, usersOb.Cols().AuthStatus, usersOb.Cols().ModifyTime}
	if e = userItem.Update(updateCols); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("移动用户失败, %v", e)
		return
	}

	// 操作记录
	go func() {
		recordOb := new(models.CompanyUserOperateRecord)
		recordOb.UserId = userItem.UserId
		recordOb.Remark = fmt.Sprintf("%s移动用户至【%s】", sysUser.SysRealName, companyItem.CompanyName)
		recordOb.SysUserId = sysUser.SysUserId
		recordOb.SysUserRealName = sysUser.SysRealName
		recordOb.CreateTime = time.Now().Local()
		if e := recordOb.Create(); e != nil {
			utils.FileLog.Info(fmt.Sprintf("新增操作记录失败, UserId: %d, MoveCompanyId: %d, ErrMsg: %v", userItem.UserId, companyItem.CompanyId, e))
		}
	}()

	br.Ret = 200
	br.Msg = "操作成功"
	br.Success = true
}

// Remove
// @Title 删除用户
// @Description 删除用户
// @Param	request	body request.UsersRemoveReq true "type json string"
// @Success 200 Ret=200 操作成功
// @router /remove [post]
func (this *UsersController) Remove() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req request.UsersRemoveReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常"
		br.ErrMsg = fmt.Sprintf("参数解析异常, %v", e)
		return
	}
	if req.UserId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("用户ID参数有误, UserId: %d", req.UserId)
		return
	}
	userOb := new(models.Users)
	usersItem, e := userOb.GetItemById(req.UserId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Ret = 200
			br.Msg = "操作成功"
			br.Success = true
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("获取机构失败, %v", e)
		return
	}
	// 操作权限校验
	if sysUser.SysRoleId != utils.AdminRoleId {
		if sysUser.SysUserId != usersItem.SysUserId && sysUser.SysUserId != usersItem.SellerId {
			br.Msg = "无权操作"
			return
		}
	}

	// 删除用户并移除微信用户关联
	if e = userOb.RemoveUsersAndUserRecord(req.UserId); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("删除用户并移除微信用户关联失败, %v", e)
		return
	}

	// 操作记录
	go func() {
		recordOb := new(models.CompanyUserOperateRecord)
		recordOb.UserId = usersItem.UserId
		recordOb.Remark = fmt.Sprintf("%s删除用户", sysUser.SysRealName)
		recordOb.SysUserId = sysUser.SysUserId
		recordOb.SysUserRealName = sysUser.SysRealName
		recordOb.CreateTime = time.Now().Local()
		if e := recordOb.Create(); e != nil {
			utils.FileLog.Info(fmt.Sprintf("新增操作记录失败, UserId: %d, ErrMsg: %v", usersItem.UserId, e))
		}
	}()

	br.Ret = 200
	br.Msg = "操作成功"
	br.Success = true
}

// TransFormal
// @Title 转正式
// @Description 转正式
// @Param	request	body request.UsersTransFormalReq true "type json string"
// @Success 200 Ret=200 操作成功
// @router /trans_formal [post]
func (this *UsersController) TransFormal() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req request.UsersTransFormalReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常"
		br.ErrMsg = fmt.Sprintf("参数解析异常, %v", e)
		return
	}
	if req.UserId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("用户ID有误, UserId: %d", req.UserId)
		return
	}
	req.RealName = strings.TrimSpace(req.RealName)
	if req.RealName == "" {
		br.Msg = "请输入用户姓名"
		return
	}

	// 用户校验
	usersOb := new(models.Users)
	userItem, e := usersOb.GetItemById(req.UserId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "用户不存在，请刷新页面"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("获取用户失败, %v", e)
		return
	}
	if userItem.Status != models.UserStatusTrial {
		br.Msg = "该用户不是试用客户"
		return
	}

	// 用户类型
	var (
		companyId   int
		companyName string
		authStatus  int
		sellerId    int
		sellerName  string
	)
	switch req.UserType {
	case models.UserTypePerson:
		if req.SellerId <= 0 {
			br.Msg = "请选择营业部"
			return
		}
		authStatus = models.AuthStatusOpen

		seller, e := models.GetSysUserById(req.SellerId)
		if e != nil {
			if e.Error() == utils.ErrNoRow() {
				br.Msg = "销售不存在，请刷新页面后重试"
				return
			}
			br.Msg = "操作失败"
			br.ErrMsg = fmt.Sprintf("获取销售失败, %v", e)
			return
		}
		sellerId = req.SellerId
		sellerName = seller.SysRealName
	case models.UserTypeCompany:
		if req.CompanyId <= 0 {
			br.Msg = "请选择所属机构"
			return
		}
		companyOb := new(models.Company)
		companyItem, e := companyOb.GetItemById(req.CompanyId)
		if e != nil {
			if e.Error() == utils.ErrNoRow() {
				br.Msg = "所选机构不存在，请刷新页面"
				return
			}
			br.Msg = "操作失败"
			br.ErrMsg = fmt.Sprintf("获取机构失败, %v", e)
			return
		}
		companyId = companyItem.CompanyId
		companyName = companyItem.CompanyName
		authStatus = companyItem.AuthStatus
		sellerId = companyItem.SellerId
		sellerName = companyItem.SellerName
	default:
		br.Msg = "客户类型有误"
		br.ErrMsg = fmt.Sprintf("客户类型有误, UserType: %d", req.UserType)
		return
	}

	// 转正式
	userItem.RealName = req.RealName
	userItem.SellerId = sellerId
	userItem.SellerName = sellerName
	userItem.CompanyId = companyId
	userItem.CompanyName = companyName
	userItem.SysUserId = sysUser.SysUserId
	userItem.SysUserRealName = sysUser.SysRealName
	userItem.Status = models.UserStatusFormal
	userItem.AuthStatus = authStatus
	userItem.ModifyTime = time.Now().Local()
	updateCols := []string{
		usersOb.Cols().RealName, usersOb.Cols().SellerId, usersOb.Cols().SellerName, usersOb.Cols().CompanyId, usersOb.Cols().CompanyName,
		usersOb.Cols().SysUserId, usersOb.Cols().SysUserRealName, usersOb.Cols().Status, usersOb.Cols().AuthStatus, usersOb.Cols().ModifyTime,
	}
	if e := userItem.Update(updateCols); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("用户转正式失败, %v", e)
		return
	}

	// 操作记录
	go func() {
		recordOb := new(models.CompanyUserOperateRecord)
		recordOb.UserId = userItem.UserId
		recordOb.Remark = fmt.Sprintf("%s转正式", sysUser.SysRealName)
		recordOb.SysUserId = sysUser.SysUserId
		recordOb.SysUserRealName = sysUser.SysRealName
		recordOb.CreateTime = time.Now().Local()
		if e := recordOb.Create(); e != nil {
			utils.FileLog.Info(fmt.Sprintf("新增操作记录失败, UserId: %d, ErrMsg: %v", userItem.UserId, e))
		}
	}()

	br.Ret = 200
	br.Msg = "操作成功"
	br.Success = true
}

// Detail
// @Title 用户详情
// @Description 用户详情
// @Param   UserId  query  int  true  "用户ID"
// @Success 200 {object} models.UsersItem
// @router /detail [get]
func (this *UsersController) Detail() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	userId, _ := this.GetInt("UserId")
	if userId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数有误, %d", userId)
		return
	}
	usersOb := new(models.Users)
	userItem, e := usersOb.GetItemById(userId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "用户不存在，请刷新页面"
			return
		}
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取用户失败, %v", e)
		return
	}
	resp := userItem.Format2Item()

	br.Data = resp
	br.Ret = 200
	br.Msg = "获取成功"
	br.Success = true
}

// PageList
// @Title 用户列表-分页
// @Description 用户列表-分页
// @Param	request	body request.UsersListForm true "type json string"
// @Success 200 {object} response.UsersPageListResp
// @router /page_list [get]
func (this *UsersController) PageList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	params := new(request.UsersListForm)
	if e := this.ParseForm(params); e != nil {
		br.Msg = "参数解析异常"
		br.ErrMsg = fmt.Sprintf("参数解析异常, %v", e)
		return
	}
	resp := new(response.UsersPageListResp)
	usersOb := new(models.Users)

	// 仅超管/创建人/对应销售可见
	cond := ``
	pars := make([]interface{}, 0)
	if params.UserStatus != models.UserStatusTrial && params.CompanyId <= 0 && sysUser.SysRoleId != utils.AdminRoleId {
		cond += fmt.Sprintf(` AND (%s = ? OR %s = ?)`, usersOb.Cols().SysUserId, usersOb.Cols().SellerId)
		pars = append(pars, sysUser.SysUserId, sysUser.SysUserId)
	}

	// 筛选项
	{
		// 机构，默认为个人
		cond += fmt.Sprintf(` AND %s = ?`, usersOb.Cols().CompanyId)
		pars = append(pars, params.CompanyId)

		// 用户类型
		if params.UserStatus > 0 {
			if params.UserStatus != models.UserStatusTrial && params.UserStatus != models.UserStatusFormal {
				br.Msg = "用户类型有误"
				br.ErrMsg = fmt.Sprintf("参数用户类型有误, UserStatus: %d", params.UserStatus)
				return
			}
			cond += fmt.Sprintf(` AND %s = ?`, usersOb.Cols().Status)
			pars = append(pars, params.UserStatus)
		}

		// 关键词（联系人名称/联系人手机号）
		keywords := strings.TrimSpace(params.Keywords)
		if keywords != "" {
			kw := fmt.Sprint("%", keywords, "%")
			cond += fmt.Sprintf(` AND (%s LIKE ? OR %s LIKE ?)`, usersOb.Cols().RealName, usersOb.Cols().Mobile)
			pars = append(pars, kw, kw)
		}

		// 营业部
		params.SellerIds = strings.TrimSpace(params.SellerIds)
		if params.SellerIds != "" {
			var sellerIds []int
			idArr := strings.Split(params.SellerIds, ",")
			for _, v := range idArr {
				id, _ := strconv.Atoi(v)
				if id > 0 {
					sellerIds = append(sellerIds, id)
				}
			}
			if len(sellerIds) == 0 {
				page := paging.GetPaging(params.CurrentIndex, params.PageSize, 0)
				resp.Paging = page
				resp.List = make([]*models.UsersItem, 0)
				br.Data = resp
				br.Ret = 200
				br.Msg = "获取成功"
				br.Success = true
				return
			}
			cond += fmt.Sprintf(` AND %s IN (%s)`, usersOb.Cols().SellerId, utils.GetOrmInReplace(len(sellerIds)))
			pars = append(pars, sellerIds)
		}

		// 创建时间区间
		params.StartTime = strings.TrimSpace(params.StartTime)
		params.EndTime = strings.TrimSpace(params.EndTime)
		if params.StartTime != "" && params.EndTime != "" {
			_, e := time.ParseInLocation(utils.FormatDate, params.StartTime, time.Local)
			if e != nil {
				br.Msg = "开始时间格式有误"
				return
			}
			_, e = time.ParseInLocation(utils.FormatDate, params.EndTime, time.Local)
			if e != nil {
				br.Msg = "结束时间格式有误"
				return
			}
			cond += fmt.Sprintf(` AND (%s BETWEEN ? AND ?)`, usersOb.Cols().CreateTime)
			pars = append(pars, fmt.Sprintf("%s 00:00:00", params.StartTime), fmt.Sprintf("%s 23:59:59", params.EndTime))
		}
	}

	// 分页
	var startSize int
	if params.PageSize <= 0 {
		params.PageSize = utils.PageSize20
	}
	if params.CurrentIndex <= 0 {
		params.CurrentIndex = 1
	}
	startSize = utils.StartIndex(params.CurrentIndex, params.PageSize)

	// 排序
	orderRule := fmt.Sprintf(`%s DESC`, usersOb.Cols().CreateTime)
	if params.SortField > 0 && params.SortRule > 0 {
		fieldMap := map[int]string{
			1: usersOb.Cols().CreateTime, 2: usersOb.Cols().RegisterTime, 3: usersOb.Cols().LastReadTime, 4: usersOb.Cols().ReadTimes,
		}
		ruleMap := map[int]string{1: "ASC", 2: "DESC"}
		if fieldMap[params.SortField] != "" && ruleMap[params.SortRule] != "" {
			orderRule = fmt.Sprintf("%s %s", fieldMap[params.SortField], ruleMap[params.SortRule])
		}
	}

	total, e := usersOb.GetCountByCondition(cond, pars)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取用户总数失败, %v", e)
		return
	}
	list, e := usersOb.GetPageItemsByCondition(cond, pars, []string{}, orderRule, startSize, params.PageSize)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取用户分页列表失败, %v", e)
		return
	}
	respList := make([]*models.UsersItem, 0)
	for _, v := range list {
		respList = append(respList, v.Format2Item())
	}

	page := paging.GetPaging(params.CurrentIndex, params.PageSize, total)
	resp.Paging = page
	resp.List = respList
	br.Data = resp
	br.Ret = 200
	br.Msg = "获取成功"
	br.Success = true
}

// Search
// @Title 用户列表-搜索
// @Description 用户列表-搜索
// @Param	request	body request.UsersListForm true "type json string"
// @Success 200 {object} response.UsersPageListResp
// @router /search [get]
func (this *UsersController) Search() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	params := new(request.UsersListForm)
	if e := this.ParseForm(params); e != nil {
		br.Msg = "参数解析异常"
		br.ErrMsg = fmt.Sprintf("参数解析异常, %v", e)
		return
	}
	// 用户检索，所有人可见
	resp := new(response.UsersPageListResp)
	usersOb := new(models.Users)
	cond := ``
	pars := make([]interface{}, 0)

	// 关键词（机构名称/联系人名称/联系人手机号）
	keywords := strings.TrimSpace(params.Keywords)
	if keywords != "" {
		kw := fmt.Sprint("%", keywords, "%")
		cond += fmt.Sprintf(` AND (%s LIKE ? OR %s LIKE ? OR %s LIKE ?)`, usersOb.Cols().CompanyName, usersOb.Cols().RealName, usersOb.Cols().Mobile)
		pars = append(pars, kw, kw, kw)
	}

	// 分页
	var startSize int
	if params.PageSize <= 0 {
		params.PageSize = utils.PageSize20
	}
	if params.CurrentIndex <= 0 {
		params.CurrentIndex = 1
	}
	startSize = utils.StartIndex(params.CurrentIndex, params.PageSize)

	total, e := usersOb.GetCountByCondition(cond, pars)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取用户总数失败, %v", e)
		return
	}
	list, e := usersOb.GetPageItemsByCondition(cond, pars, []string{}, "", startSize, params.PageSize)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取用户分页列表失败, %v", e)
		return
	}
	respList := make([]*models.UsersItem, 0)
	for _, v := range list {
		respList = append(respList, v.Format2Item())
	}

	page := paging.GetPaging(params.CurrentIndex, params.PageSize, total)
	resp.Paging = page
	resp.List = respList
	br.Data = resp
	br.Ret = 200
	br.Msg = "获取成功"
	br.Success = true
}

// OperateRecords
// @Title 用户-操作记录
// @Description 用户列表-操作记录
// @Param   UserId  query  int  true  "用户ID"
// @Success 200 {object} models.CompanyUserOperateRecordItem
// @router /operate_records [get]
func (this *UsersController) OperateRecords() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	userId, _ := this.GetInt("UserId")
	if userId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数有误, %d", userId)
		return
	}
	resp := make([]*models.CompanyUserOperateRecordItem, 0)

	recordOb := new(models.CompanyUserOperateRecord)
	cond := fmt.Sprintf(` AND %s = ?`, recordOb.Cols().UserId)
	pars := make([]interface{}, 0)
	pars = append(pars, userId)
	list, e := recordOb.GetItemsByCondition(cond, pars, []string{}, "")
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取操作记录列表失败, %v", e)
		return
	}
	for _, v := range list {
		resp = append(resp, v.Format2Item())
	}

	br.Data = resp
	br.Ret = 200
	br.Msg = "获取成功"
	br.Success = true
}

// TransAuth
// @Title 切换阅读权限
// @Description 切换阅读权限
// @Param	request	body request.UsersTransAuthReq true "type json string"
// @Success 200 Ret=200 操作成功
// @router /trans_auth [post]
func (this *UsersController) TransAuth() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req request.UsersTransAuthReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常"
		br.ErrMsg = fmt.Sprintf("参数解析异常, %v", e)
		return
	}
	if req.UserId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数有误, UserId: %d", req.UserId)
		return
	}
	usersOb := new(models.Users)
	usersItem, e := usersOb.GetItemById(req.UserId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Ret = 200
			br.Msg = "操作成功"
			br.Success = true
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("获取用户失败, %v", e)
		return
	}
	// 操作权限校验
	if sysUser.SysRoleId != utils.AdminRoleId {
		if sysUser.SysUserId != usersItem.SysUserId && sysUser.SysUserId != usersItem.SellerId {
			br.Msg = "无权操作"
			return
		}
	}

	transMapping := map[int]int{models.AuthStatusClose: models.AuthStatusOpen, models.AuthStatusOpen: models.AuthStatusClose}
	optRemarkMapping := map[int]string{models.AuthStatusClose: "关闭", models.AuthStatusOpen: "开启"}
	usersItem.AuthStatus = transMapping[usersItem.AuthStatus]
	usersItem.ModifyTime = time.Now().Local()
	updateCols := []string{usersOb.Cols().AuthStatus, usersOb.Cols().ModifyTime}
	if e = usersItem.Update(updateCols); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("切换用户阅读权限失败, %v", e)
		return
	}

	// 操作记录
	go func() {
		recordOb := new(models.CompanyUserOperateRecord)
		recordOb.UserId = usersItem.UserId
		recordOb.Remark = fmt.Sprintf("%s%s用户权限", sysUser.SysRealName, optRemarkMapping[usersItem.AuthStatus])
		recordOb.SysUserId = sysUser.SysUserId
		recordOb.SysUserRealName = sysUser.SysRealName
		recordOb.CreateTime = time.Now().Local()
		if e := recordOb.Create(); e != nil {
			utils.FileLog.Info(fmt.Sprintf("新增操作记录失败, UserId: %d, ErrMsg: %v", usersItem.UserId, e))
		}
	}()

	br.Ret = 200
	br.Msg = "操作成功"
	br.Success = true
}