hz_crm_api/controllers/eta_business/eta_business.go

package eta_business

import (
	"encoding/json"
	"fmt"
	"hongze/hz_crm_api/controllers"
	"hongze/hz_crm_api/models"
	"hongze/hz_crm_api/models/eta_business"
	etaBusinessService "hongze/hz_crm_api/services/eta_business"
	"hongze/hz_crm_api/utils"
	"strconv"
	"strings"
	"time"
)

// EtaBusinessController ETA商家
type EtaBusinessController struct {
	controllers.BaseAuthController
}

// PageList
// @Title 商家列表-分页
// @Description 商家列表-分页
// @Param   Keyword			query	string	false	"关键词: 商家名称/社会信用码/商家编码"
// @Param   SellerIds		query	string	false	"销售IDs"
// @Param   SigningStatus	query	string	false	"签约状态: 1-首次签约; 2-续约中; 3-已终止"
// @Param   Province		query	string	false	"省份筛选"
// @Param   City			query	string	false	"城市筛选"
// @Param   SortParam		query	string	false	"排序字段: SignTime-签约时间; ExpireTime-到期时间; CreateTime-创建时间; UserMax-用户上限"
// @Param   SortType		query	string	false	"排序类型: Asc-正序; Desc-倒序"
// @Success 200 Ret=200 获取成功
// @router /page_list [get]
func (this *EtaBusinessController) 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
	}
	// 权限校验
	resp := make([]*eta_business.EtaBusinessItem, 0)
	ok, e := etaBusinessService.CheckEtaBusinessOperateAuth(sysUser.RoleTypeCode)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作权限校验失败, ErrMsg: " + e.Error()
		return
	}
	if !ok {
		br.Data = resp
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		return
	}

	cond := ``
	pars := make([]interface{}, 0)
	order := ``
	// 关键词
	keyword := this.GetString("Keyword", "")
	keyword = strings.TrimSpace(keyword)
	if keyword != "" {
		kw := fmt.Sprint("%", keyword, "%")
		cond += fmt.Sprintf(` AND (%s = ? OR %s = ? OR %s = ?)`, eta_business.EtaBusinessColumns.BusinessName, eta_business.EtaBusinessColumns.BusinessCode, eta_business.EtaBusinessColumns.CreditCode)
		pars = append(pars, kw, kw, kw)
	}
	// 销售
	sellerIds := this.GetString("SellerIds", "")
	if sellerIds != "" {
		arr := strings.Split(sellerIds, ",")
		ids := make([]int, 0)
		for _, s := range arr {
			v, e := strconv.Atoi(s)
			if e != nil {
				br.Msg = "销售ID有误"
				return
			}
			ids = append(ids, v)
		}
		if len(ids) == 0 {
			br.Data = resp
			br.Ret = 200
			br.Success = true
			br.Msg = "获取成功"
			return
		}
		cond += fmt.Sprintf(` AND %s IN (%s)`, eta_business.EtaBusinessColumns.SellerId, utils.GetOrmInReplace(len(ids)))
		pars = append(pars, ids)
	}
	// 签约状态
	signingStatus, _ := this.GetInt("SigningStatus", 0)
	if signingStatus > 0 {
		cond += fmt.Sprintf(` AND %s = ?`, eta_business.EtaBusinessColumns.SigningStatus)
		pars = append(pars, signingStatus)
	}
	// TODO:商家地址（多选）
	province := this.GetString("Province", "")
	province = strings.TrimSpace(province)
	if province != "" {

	}
	//if province != "" {
	//	var provinceSql string
	//	slice := strings.Split(province, ",")
	//	for _, v := range slice {
	//		provinceSql += "'" + v + "'" + ","
	//	}
	//	provinceSql = strings.TrimRight(provinceSql, ",")
	//	condition += ` AND a.province IN (` + provinceSql + `) `
	//}
	//
	//if city != "" {
	//	var citySql string
	//	slice := strings.Split(city, ",")
	//	for _, v := range slice {
	//		citySql += "'" + v + "'" + ","
	//	}
	//	citySql = strings.TrimRight(citySql, ",")
	//	condition += ` AND a.city IN (` + citySql + `) `
	//}

	// @Param   SortParam		query	string	false	"排序字段: SignTime-签约时间; ExpireTime-到期时间; CreateTime-创建时间; UserMax-用户上限"
	// @Param   SortType		query	string	false	"排序类型: Asc-正序; Desc-倒序"
	// TODO:排序

	// 获取列表
	businessOb := new(eta_business.EtaBusiness)
	list, e := businessOb.GetItemsByCondition(cond, pars, []string{}, order)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取商家列表失败, Err: " + e.Error()
		return
	}
	for _, v := range list {
		b := new(eta_business.EtaBusinessItem)
		b.EtaBusinessId = v.EtaBusinessId
		b.BusinessName = v.BusinessName
		b.BusinessCode = v.BusinessCode
		b.CreditCode = v.CreditCode
		b.RegionType = v.RegionType
		b.Address = v.Address
		b.SellerId = v.SellerId
		b.SellerName = v.SellerName
		b.Leader = v.Leader
		b.IndustryId = v.IndustryId
		b.IndustryName = v.IndustryName
		b.CapitalScale = v.CapitalScale
		b.ResearchTeamSize = v.ResearchTeamSize
		b.UserMax = v.UserMax
		b.SigningStatus = v.SigningStatus
		b.Enable = v.Enable
		b.SigningTime = v.SigningTime.Format(utils.FormatDate)
		b.ExpiredTime = v.ExpiredTime.Format(utils.FormatDate)
		b.CreateTime = v.CreateTime.Format(utils.FormatDateTime)
		b.ModifyTime = v.ModifyTime.Format(utils.FormatDateTime)
		resp = append(resp, b)
	}

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

// Add
// @Title 新增商家
// @Description 新增商家
// @Param	request	body eta_business.EtaBusinessAddReq true "type json string"
// @Success 200 Ret=200 操作成功
// @router /add [post]
func (this *EtaBusinessController) 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
	}

	// 操作权限校验
	ok, e := etaBusinessService.CheckEtaBusinessOperateAuth(sysUser.RoleTypeCode)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作权限校验失败, ErrMsg: " + e.Error()
		return
	}
	if !ok {
		br.Msg = "无权操作"
		return
	}

	// 参数校验
	var req eta_business.EtaBusinessAddReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + e.Error()
		return
	}
	req.BusinessName = strings.TrimSpace(req.BusinessName)
	if req.BusinessName == "" {
		br.Msg = "商家名称不可为空"
		return
	}
	if req.CreditCode == "" {
		br.Msg = "社会统一信用码不可为空"
		return
	}
	req.Province = strings.TrimSpace(req.Province)
	if req.Province == "" {
		br.Msg = "省份不可为空"
		return
	}
	req.City = strings.TrimSpace(req.City)
	if req.City == "" {
		br.Msg = "城市不可为空"
		return
	}
	req.Leader = strings.TrimSpace(req.Leader)
	if req.Leader == "" {
		br.Msg = "决策人不可为空"
		return
	}
	if req.IndustryId <= 0 || req.IndustryName == "" {
		br.Msg = "所属行业不可为空"
		return
	}
	if req.ResearchTeamSize == "" {
		br.Msg = "研究团队规模不可为空"
		return
	}
	if req.UserMax <= 0 {
		br.Msg = "用户上限不可小于0"
		return
	}
	req.CapitalScale = strings.TrimSpace(req.CapitalScale)

	// 如果仅校验不新增, 那么不做第二页签约时间的校验
	var signTime, expiredTime time.Time
	if !req.IsCheck {
		if req.SigningTime == "" {
			br.Msg = "签约时间不可为空"
			return
		}
		if req.ExpiredTime == "" {
			br.Msg = "到期时间不可为空"
			return
		}
		signTime, e = time.ParseInLocation(utils.FormatDate, req.SigningTime, time.Local)
		if e != nil {
			br.Msg = "签约时间格式有误"
			br.ErrMsg = "签约时间格式有误, Err: " + e.Error()
			return
		}
		expiredTime, e = time.ParseInLocation(utils.FormatDate, req.ExpiredTime, time.Local)
		if e != nil {
			br.Msg = "到期时间格式有误"
			br.ErrMsg = "到期时间格式有误, Err: " + e.Error()
			return
		}
		if !expiredTime.After(signTime) {
			br.Msg = "到期时间不得早于签约时间"
			return
		}
	}

	// 重名校验
	{
		item := new(eta_business.EtaBusiness)
		cond := fmt.Sprintf(` AND %s = ?`, eta_business.EtaBusinessColumns.BusinessName)
		pars := make([]interface{}, 0)
		pars = append(pars, req.BusinessName)
		exist, e := item.GetItemByCondition(cond, pars)
		if e != nil && e.Error() != utils.ErrNoRow() {
			br.Msg = "操作失败"
			br.ErrMsg = "获取重名商家失败, Err: " + e.Error()
			return
		}
		if exist != nil {
			br.Msg = "商家名称已存在"
			return
		}
	}

	// 社会信用码重复校验
	{
		item := new(eta_business.EtaBusiness)
		cond := fmt.Sprintf(` AND %s = ?`, eta_business.EtaBusinessColumns.CreditCode)
		pars := make([]interface{}, 0)
		pars = append(pars, req.CreditCode)
		exist, e := item.GetItemByCondition(cond, pars)
		if e != nil && e.Error() != utils.ErrNoRow() {
			br.Msg = "操作失败"
			br.ErrMsg = "获取重复信用码商家失败, Err: " + e.Error()
			return
		}
		if exist != nil {
			br.Msg = "商家社会信用码已存在"
			return
		}
	}

	// 如果只做校验不新增, 此处校验通过后直接返回true
	if req.IsCheck {
		br.Data = true
		br.Ret = 200
		br.Success = true
		br.Msg = "操作成功"
		return
	}

	// 商家编码
	businessCode, e := eta_business.CreateEtaBusinessCode()
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "生成商家编码失败, Err: " + e.Error()
		return
	}

	now := time.Now().Local()
	// 若当前时间不在首次签约时间内, 也算作已终止, 进入合约期时会由定时任务改为首次签约
	status := eta_business.EtaBusinessSigningStatusFirst
	isTerminate := true
	if now.Equal(signTime) || now.Equal(expiredTime) {
		isTerminate = false
	}
	if now.After(signTime) && now.Before(expiredTime) {
		isTerminate = false
	}
	if isTerminate {
		status = eta_business.EtaBusinessSigningStatusTerminate
	}

	// 新增商家和签约
	businessItem := new(eta_business.EtaBusiness)
	businessItem.BusinessName = req.BusinessName
	businessItem.BusinessCode = businessCode
	businessItem.CreditCode = req.CreditCode
	businessItem.Province = req.Province
	businessItem.City = req.City
	businessItem.Address = req.Province + req.City
	businessItem.SellerId = req.SellerId
	businessItem.SellerName = req.SellerName
	businessItem.Leader = req.Leader
	businessItem.IndustryId = req.IndustryId
	businessItem.IndustryName = req.IndustryName
	businessItem.CapitalScale = req.CapitalScale
	businessItem.ResearchTeamSize = req.ResearchTeamSize
	businessItem.UserMax = req.UserMax
	businessItem.Enable = 1
	businessItem.SigningStatus = status
	businessItem.SigningTime = signTime
	businessItem.ExpiredTime = expiredTime
	businessItem.CreateTime = now
	businessItem.ModifyTime = now
	contractItem := new(eta_business.EtaBusinessContract)
	contractItem.SigningTime = signTime
	contractItem.ExpiredTime = expiredTime
	contractItem.CreateTime = now
	contractItem.ModifyTime = now
	if e = eta_business.CreateEtaBusinessAndContract(businessItem, contractItem); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "新增商家和签约失败, Err: " + e.Error()
		return
	}

	// 操作日志
	go func() {
		recordOb := new(eta_business.EtaBusinessOperationRecord)
		recordOb.EtaBusinessId = businessItem.EtaBusinessId
		recordOb.SellerId = businessItem.SellerId
		recordOb.SysUserId = sysUser.AdminId
		recordOb.SysRealName = sysUser.RealName
		recordOb.OperationType = eta_business.EtaBusinessOperationTypeAdd
		recordOb.OperationRemark = fmt.Sprintf("%s新增商户", sysUser.RealName)
		recordOb.CreateTime = time.Now().Local()
		_ = recordOb.Create()
	}()

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

// Edit
// @Title 编辑商家
// @Description 编辑商家
// @Param	request	body eta_business.EtaBusinessEditReq true "type json string"
// @Success 200 Ret=200 操作成功
// @router /edit [post]
func (this *EtaBusinessController) 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 eta_business.EtaBusinessEditReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + e.Error()
		return
	}
	if req.EtaBusinessId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = "参数有误, 商家ID为空"
		return
	}
	req.Province = strings.TrimSpace(req.Province)
	if req.Province == "" {
		br.Msg = "省份不可为空"
		return
	}
	req.City = strings.TrimSpace(req.City)
	if req.City == "" {
		br.Msg = "城市不可为空"
		return
	}
	req.Leader = strings.TrimSpace(req.Leader)
	if req.Leader == "" {
		br.Msg = "决策人不可为空"
		return
	}
	if req.IndustryId <= 0 || req.IndustryName == "" {
		br.Msg = "所属行业不可为空"
		return
	}
	if req.ResearchTeamSize == "" {
		br.Msg = "研究团队规模不可为空"
		return
	}
	if req.UserMax <= 0 {
		br.Msg = "用户上限不可小于0"
		return
	}
	req.CapitalScale = strings.TrimSpace(req.CapitalScale)

	// 权限校验
	ok, e := etaBusinessService.CheckEtaBusinessOperateAuth(sysUser.RoleTypeCode)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作权限校验失败, ErrMsg: " + e.Error()
		return
	}
	if !ok {
		br.Msg = "无权操作"
		return
	}

	ob := new(eta_business.EtaBusiness)
	item, e := ob.GetItemById(req.EtaBusinessId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "商家不存在, 请刷新页面"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = "获取商家信息失败, Err: " + e.Error()
		return
	}
	item.Province = req.Province
	item.City = req.City
	item.Address = req.Province + req.City
	item.Leader = req.Leader
	item.IndustryId = req.IndustryId
	item.IndustryName = req.IndustryName
	item.CapitalScale = req.CapitalScale
	item.ResearchTeamSize = req.ResearchTeamSize
	item.UserMax = req.UserMax
	item.ModifyTime = time.Now().Local()
	cols := []string{
		"Province", "City", "Address", "Leader", "IndustryId", "IndustryName", "CapitalScale", "ResearchTeamSize", "UserMax", "ModifyTime",
	}
	if e := item.Update(cols); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "编辑商家失败, Err: " + e.Error()
		return
	}

	// 操作日志
	go func() {
		recordOb := new(eta_business.EtaBusinessOperationRecord)
		recordOb.EtaBusinessId = item.EtaBusinessId
		recordOb.SellerId = item.SellerId
		recordOb.SysUserId = sysUser.AdminId
		recordOb.SysRealName = sysUser.RealName
		recordOb.OperationType = eta_business.EtaBusinessOperationTypeEdit
		recordOb.OperationRemark = fmt.Sprintf("%s编辑商户", sysUser.RealName)
		recordOb.CreateTime = time.Now().Local()
		_ = recordOb.Create()
	}()

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

// Signing
// @Title 签约续约
// @Description 签约续约
// @Param	request	body eta_business.EtaBusinessSigningReq true "type json string"
// @Success 200 Ret=200 操作成功
// @router /signing [post]
func (this *EtaBusinessController) Signing() {
	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 eta_business.EtaBusinessSigningReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + e.Error()
		return
	}
	if req.EtaBusinessId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = "参数有误, 商家ID为空"
		return
	}
	if req.SigningTime == "" {
		br.Msg = "签约时间不可为空"
		return
	}
	if req.ExpiredTime == "" {
		br.Msg = "到期时间不可为空"
		return
	}
	signTime, e := time.ParseInLocation(utils.FormatDate, req.SigningTime, time.Local)
	if e != nil {
		br.Msg = "签约时间格式有误"
		br.ErrMsg = "签约时间格式有误, Err: " + e.Error()
		return
	}
	expiredTime, e := time.ParseInLocation(utils.FormatDate, req.ExpiredTime, time.Local)
	if e != nil {
		br.Msg = "到期时间格式有误"
		br.ErrMsg = "到期时间格式有误, Err: " + e.Error()
		return
	}
	if !expiredTime.After(signTime) {
		br.Msg = "到期时间不得早于签约时间"
		return
	}

	// 权限校验
	ok, e := etaBusinessService.CheckEtaBusinessOperateAuth(sysUser.RoleTypeCode)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作权限校验失败, ErrMsg: " + e.Error()
		return
	}
	if !ok {
		br.Msg = "无权操作"
		return
	}

	// 获取商家信息
	businessOb := new(eta_business.EtaBusiness)
	business, e := businessOb.GetItemById(req.EtaBusinessId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "商家不存在, 请刷新页面"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = "获取商家信息失败, Err: " + e.Error()
		return
	}

	// 获取历史签约, 签约日期不可交叠
	contract := new(eta_business.EtaBusinessContract)
	cond := fmt.Sprintf(` AND %s = ?`, eta_business.EtaBusinessContractColumns.EtaBusinessId)
	pars := make([]interface{}, 0)
	pars = append(pars, req.EtaBusinessId)
	contracts, e := contract.GetItemsByCondition(cond, pars, []string{}, "")
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "获取商家签约列表失败, Err: " + e.Error()
		return
	}

	// 本次签约是否属于终止期
	now := time.Now().Local()
	isTerminate := true
	if now.Equal(signTime) || now.Equal(expiredTime) {
		isTerminate = false
	}
	if now.After(signTime) && now.Before(expiredTime) {
		isTerminate = false
	}

	// 是否为首次签约
	isFirst := true
	if len(contracts) > 0 {
		isFirst = false
		for _, c := range contracts {
			// 校验签约时间是否重叠
			pass := false
			if expiredTime.Before(c.SigningTime) {
				pass = true
			}
			if signTime.After(c.ExpiredTime) {
				pass = true
			}
			if !pass {
				br.Msg = "签约时间在存续期内, 请检查"
				return
			}
			// 上面判断若为终止, 则判断是否在历史签约存续期间
			if !isTerminate {
				continue
			}
			if now.Equal(c.SigningTime) || now.Equal(c.ExpiredTime) {
				isTerminate = false
				continue
			}
			if now.After(c.SigningTime) && now.Before(c.ExpiredTime) {
				isTerminate = false
				continue
			}
		}
	}

	// 是否更新签约状态
	status := eta_business.EtaBusinessSigningStatusContinue
	if isTerminate {
		status = eta_business.EtaBusinessSigningStatusTerminate
	}
	if !isTerminate && isFirst {
		status = eta_business.EtaBusinessSigningStatusFirst
	}
	if business.SigningStatus != status {
		business.SigningStatus = status
		business.ModifyTime = now
		cols := []string{"SigningStatus", "ModifyTime"}
		if e = business.Update(cols); e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = "更新签约状态失败, Err: " + e.Error()
			return
		}
	}

	// 新增签约
	contract.EtaBusinessId = req.EtaBusinessId
	contract.SigningTime = signTime
	contract.ExpiredTime = expiredTime
	contract.CreateTime = now
	contract.ModifyTime = now
	if e = contract.Create(); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "新增签约失败, Err: " + e.Error()
		return
	}

	// 续约操作日志
	if !isFirst {
		go func() {
			recordOb := new(eta_business.EtaBusinessOperationRecord)
			recordOb.EtaBusinessId = business.EtaBusinessId
			recordOb.SellerId = business.SellerId
			recordOb.SysUserId = sysUser.AdminId
			recordOb.SysRealName = sysUser.RealName
			recordOb.OperationType = eta_business.EtaBusinessOperationTypeRenewalContract
			recordOb.OperationRemark = fmt.Sprintf("%s添加续约", sysUser.RealName)
			recordOb.CreateTime = time.Now().Local()
			_ = recordOb.Create()
		}()
	}

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

// Enable
// @Title 禁用启用
// @Description 禁用启用
// @Param	request	body eta_business.EtaBusinessEnableReq true "type json string"
// @Success 200 Ret=200 操作成功
// @router /enable [post]
func (this *EtaBusinessController) Enable() {
	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 eta_business.EtaBusinessEnableReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + e.Error()
		return
	}
	if req.EtaBusinessId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = "参数有误, 商家ID为空"
		return
	}

	// 权限校验
	ok, e := etaBusinessService.CheckEtaBusinessOperateAuth(sysUser.RoleTypeCode)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作权限校验失败, ErrMsg: " + e.Error()
		return
	}
	if !ok {
		br.Msg = "无权操作"
		return
	}

	// 获取商家信息
	businessOb := new(eta_business.EtaBusiness)
	business, e := businessOb.GetItemById(req.EtaBusinessId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "商家不存在, 请刷新页面"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = "获取商家信息失败, Err: " + e.Error()
		return
	}

	// 禁启用
	typeMap := map[int]int{
		0: eta_business.EtaBusinessOperationTypeEnable,
		1: eta_business.EtaBusinessOperationTypeDisable,
	}
	typeRemarkMap := map[int]string{
		0: "启用",
		1: "禁用",
	}
	operateType := typeMap[business.Enable]
	operateRemark := typeRemarkMap[business.Enable]

	business.Enable = business.Enable ^ 1
	business.ModifyTime = time.Now().Local()
	cols := []string{"Enable", "ModifyTime"}
	if e = business.Update(cols); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "更新商家状态失败, Err: " + e.Error()
		return
	}

	// 操作日志
	go func() {
		recordOb := new(eta_business.EtaBusinessOperationRecord)
		recordOb.EtaBusinessId = business.EtaBusinessId
		recordOb.SellerId = business.SellerId
		recordOb.SysUserId = sysUser.AdminId
		recordOb.SysRealName = sysUser.RealName
		recordOb.OperationType = operateType
		recordOb.OperationRemark = fmt.Sprintf("%s%s商户", sysUser.RealName, operateRemark)
		recordOb.CreateTime = time.Now().Local()
		_ = recordOb.Create()
	}()

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

// MoveSeller
// @Title 移动销售
// @Description 移动销售
// @Param	request	body eta_business.EtaBusinessMoveSellerReq true "type json string"
// @Success 200 Ret=200 操作成功
// @router /move_seller [post]
func (this *EtaBusinessController) MoveSeller() {
	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 eta_business.EtaBusinessMoveSellerReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + e.Error()
		return
	}
	if req.EtaBusinessId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = "参数有误, 商家ID为空"
		return
	}
	if req.SellerId <= 0 || req.SellerName == "" {
		br.Msg = "销售不可为空"
		return
	}

	// 权限校验
	ok, e := etaBusinessService.CheckEtaBusinessOperateAuth(sysUser.RoleTypeCode)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作权限校验失败, ErrMsg: " + e.Error()
		return
	}
	if !ok {
		br.Msg = "无权操作"
		return
	}

	// 获取商家信息
	businessOb := new(eta_business.EtaBusiness)
	business, e := businessOb.GetItemById(req.EtaBusinessId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "商家不存在, 请刷新页面"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = "获取商家信息失败, Err: " + e.Error()
		return
	}

	// 更新销售
	business.SellerId = req.SellerId
	business.SellerName = req.SellerName
	business.ModifyTime = time.Now().Local()
	cols := []string{"SellerId", "SellerName", "ModifyTime"}
	if e = business.Update(cols); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "移动至销售失败, Err: " + e.Error()
		return
	}

	// 操作日志
	go func() {
		recordOb := new(eta_business.EtaBusinessOperationRecord)
		recordOb.EtaBusinessId = business.EtaBusinessId
		recordOb.SellerId = req.SellerId
		recordOb.SysUserId = sysUser.AdminId
		recordOb.SysRealName = sysUser.RealName
		recordOb.OperationType = eta_business.EtaBusinessOperationTypeMoveSeller
		recordOb.OperationRemark = fmt.Sprintf("%s移动到: %s", sysUser.RealName, req.SellerName)
		recordOb.CreateTime = time.Now().Local()
		_ = recordOb.Create()
	}()

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

// ContractList
// @Title 商家签约列表
// @Description 商家签约列表
// @Param   EtaBusinessId	query	int		true	"商家ID"
// @Success 200 Ret=200 获取成功
// @router /contract_list [get]
func (this *EtaBusinessController) ContractList() {
	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
	}
	// 权限校验
	resp := make([]*eta_business.EtaBusinessContractItem, 0)
	ok, e := etaBusinessService.CheckEtaBusinessOperateAuth(sysUser.RoleTypeCode)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作权限校验失败, ErrMsg: " + e.Error()
		return
	}
	if !ok {
		br.Data = resp
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		return
	}
	businessId, _ := this.GetInt("EtaBusinessId", 0)
	if businessId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = "参数有误, 商家ID"
		return
	}

	cond := fmt.Sprintf(` AND %s = ?`, eta_business.EtaBusinessContractColumns.EtaBusinessId)
	pars := make([]interface{}, 0)
	pars = append(pars, businessId)
	order := `signing_time DESC`

	contractOb := new(eta_business.EtaBusinessContract)
	list, e := contractOb.GetItemsByCondition(cond, pars, []string{}, order)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取商家签约列表失败, Err: " + e.Error()
		return
	}
	now := time.Now().Local()
	for _, v := range list {
		b := new(eta_business.EtaBusinessContractItem)
		b.EtaBusinessId = v.EtaBusinessId
		b.SigningTime = v.SigningTime.Format(utils.FormatDate)
		b.ExpiredTime = v.ExpiredTime.Format(utils.FormatDate)
		// 到期天数, 终止日按当天的23:59:59算
		strEnd := v.ExpiredTime.Format(utils.FormatDate)
		strEnd = strEnd + " 23:59:59"
		endTime, e := time.ParseInLocation(utils.FormatDateTime, strEnd, time.Local)
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "签约日期有误, Err: " + e.Error()
			return
		}
		b.ExpireDay = "-"
		if now.After(v.SigningTime) && now.Before(endTime) {
			diff := utils.GetDiffDays(now, v.ExpiredTime)
			b.ExpireDay = strconv.Itoa(diff)
			b.Using = true
		}
		resp = append(resp, b)
	}

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

// OperateRecordList
// @Title 操作日志列表
// @Description 操作日志列表
// @Param   EtaBusinessId	query	int		true	"商家ID"
// @Success 200 Ret=200 获取成功
// @router /operate_record_list [get]
func (this *EtaBusinessController) OperateRecordList() {
	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
	}
	// 权限校验
	resp := make([]*eta_business.EtaBusinessOperationRecordItem, 0)
	ok, e := etaBusinessService.CheckEtaBusinessOperateAuth(sysUser.RoleTypeCode)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作权限校验失败, ErrMsg: " + e.Error()
		return
	}
	if !ok {
		br.Data = resp
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		return
	}
	businessId, _ := this.GetInt("EtaBusinessId", 0)
	if businessId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = "参数有误, 商家ID"
		return
	}

	cond := fmt.Sprintf(` AND %s = ?`, eta_business.EtaBusinessOperationRecordColumns.EtaBusinessId)
	pars := make([]interface{}, 0)
	pars = append(pars, businessId)

	recordOb := new(eta_business.EtaBusinessOperationRecord)
	list, e := recordOb.GetItemsByCondition(cond, pars, []string{}, "")
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取商家操作日志列表失败, Err: " + e.Error()
		return
	}
	for _, v := range list {
		r := new(eta_business.EtaBusinessOperationRecordItem)
		r.EtaBusinessId = v.EtaBusinessId
		r.SysUserId = v.SysUserId
		r.SysRealName = v.SysRealName
		r.OperationType = v.OperationType
		r.OperationRemark = v.OperationRemark
		r.CreateTime = v.CreateTime.Format(utils.FormatDateTime)
		resp = append(resp, r)
	}

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