hz_crm_api/services/cygx/contract_allocation.go

package cygx

import (
	"errors"
	"fmt"
	"hongze/hz_crm_api/models"
	"hongze/hz_crm_api/models/company"
	"hongze/hz_crm_api/models/cygx"
	"hongze/hz_crm_api/services/alarm_msg"
	"hongze/hz_crm_api/utils"
	"strconv"
	"strings"
	"time"
)

//
//func init() {
//	fmt.Println(GetCompanyContractPermissionNameMapBymapCompamy(map[int]string{6991: "1138"}))
//}

// GetCompanyContractPermissionNameMapBymapCompamy 获取合并之后的合同所对应的权限种类名称
func GetCompanyContractPermissionNameMapBymapCompamy(mapCompamy map[int]string) (mapContractResp map[int]string, err error) {
	if len(mapCompamy) == 0 {
		return
	}

	mapContracIdCompanyId := make(map[int]int) //建立合同ID与公司ID的map对应关系
	var companyContractIds []int
	//var companyContractIdGroup string //多个合同ID
	for k, v := range mapCompamy {
		//companyContractIdGroup += v + ","
		sliceContract := strings.Split(v, ",")
		for _, compamyContracId := range sliceContract {
			companyContractIdInt, _ := strconv.Atoi(compamyContracId)
			mapContracIdCompanyId[companyContractIdInt] = k
			companyContractIds = append(companyContractIds, companyContractIdInt)
		}
	}

	// 获取单个合同所对应的权限名称
	contractPermissionNameMap, e := GetCompanyContractPermissionNameMapById(companyContractIds)
	if e != nil {
		err = errors.New("GetCompanyContractPermissionNameMapById, Err: " + e.Error())
		return
	}

	mapContractResp = make(map[int]string, 0)
	for k, v := range mapCompamy {
		sliceContract := strings.Split(v, ",")
		for _, compamyContracId := range sliceContract {
			companyContractIdInt, _ := strconv.Atoi(compamyContracId)
			for k2, v2 := range contractPermissionNameMap {
				if companyContractIdInt == k2 {
					mapContractResp[k] += v2 + ","
				}
			}
		}
	}

	for k, v := range mapContractResp {
		mapContractResp[k] = strings.TrimRight(v, ",")
	}
	return
}

// GetCompanyContractPermissionNameMapById 获取合并之后的合同所对应的权限种类名称
func GetCompanyContractPermissionNameMapById(companyContractIds []int) (mapContractResp map[int]string, err error) {
	//return
	lenArr := len(companyContractIds)
	if lenArr == 0 {
		return
	}
	var condition string
	var pars []interface{}

	condition += " AND  company_contract_id IN (" + utils.GetOrmInReplace(lenArr) + ")"
	pars = append(pars, companyContractIds)

	companyContractList, e := company.GetCompanyContractList(condition, pars)
	if e != nil && e.Error() != utils.ErrNoRow() {
		err = errors.New("GetCompanyContractList, Err: " + e.Error())
		return
	}

	permissionList, e := models.GetChartPermissionList()
	if e != nil && e.Error() != utils.ErrNoRow() {
		err = errors.New("GetChartPermissionList, Err: " + e.Error())
		return
	}
	mappermissionName := make(map[int]string)
	for _, v := range permissionList {
		if v.ProductId == 2 {
			mappermissionName[v.ChartPermissionId] = v.Remark
		}
	}

	mapContractIdPerssion := make(map[int]string) //单个合同ID所对应的套餐或者权限名称
	for _, v := range companyContractList {
		if v.RaiPackageType == 1 {
			mapContractIdPerssion[v.CompanyContractId] = "70w套餐"
		}
		if v.RaiPackageType == 2 {
			mapContractIdPerssion[v.CompanyContractId] = "45w套餐"
		}
	}

	companyContractPermissionList, e := company.GetCompanyContractPermissionList(condition, pars)
	if e != nil && e.Error() != utils.ErrNoRow() {
		err = errors.New("GetCompanyContractPermissionList, Err: " + e.Error())
		return
	}

	mapIsUpgrade := make(map[string]bool) //合同ID对应的行业是否有升级
	for _, v := range companyContractPermissionList {
		//如果开通的不是整个套餐，那么就做单独的子权限处理
		if strings.Count(mapContractIdPerssion[(v.CompanyContractId)], "w套餐") == 0 {
			if v.ChartPermissionId == utils.CHART_PERMISSION_ID_YANXUAN {
				if v.ExpensiveYx == 1 {
					mapContractIdPerssion[(v.CompanyContractId)] += utils.CHART_PERMISSION_NAME_MF_YANXUAN + "(5w),"
				} else if v.ExpensiveYx == 2 {
					mapContractIdPerssion[(v.CompanyContractId)] += utils.CHART_PERMISSION_NAME_MF_YANXUAN + "(10w),"
				} else {
					mapContractIdPerssion[(v.CompanyContractId)] += utils.CHART_PERMISSION_NAME_MF_YANXUAN + "(3w),"
				}
			} else {
				mapContractIdPerssion[(v.CompanyContractId)] += mappermissionName[v.ChartPermissionId] + ","
				if v.IsUpgrade == 1 {
					//合同ID，权限名称形成唯一的主键索引
					perssionName := mappermissionName[v.ChartPermissionId]
					perssionName = strings.Replace(perssionName, "(客观)", "", -1)
					perssionName = strings.Replace(perssionName, "(主观)", "", -1)
					mapIsUpgrade[fmt.Sprint(v.CompanyContractId, "perssionName", perssionName)] = true
				}
			}
		} else {
			if v.ChartPermissionId == utils.CHART_PERMISSION_ID_YANXUAN {
				if v.ExpensiveYx == 1 {
					mapContractIdPerssion[(v.CompanyContractId)] += "," + utils.CHART_PERMISSION_NAME_MF_YANXUAN + "(5w)"
				} else {
					mapContractIdPerssion[(v.CompanyContractId)] += "," + utils.CHART_PERMISSION_NAME_MF_YANXUAN + "(3w)"
				}
			}
		}
	}
	//合并客观权限
	for k, v := range mapContractIdPerssion {
		perssionName := v
		if strings.Count(v, utils.YI_YAO_NAME) == 2 {
			perssionName = strings.Replace(perssionName, "医药(主观)", "医药", -1)
			perssionName = strings.Replace(perssionName, "医药(客观)", "", -1)
		}
		if strings.Count(v, utils.XIAO_FEI_NAME) == 2 {
			perssionName = strings.Replace(perssionName, "消费(主观)", "消费", -1)
			perssionName = strings.Replace(perssionName, "消费(客观)", "", -1)
		}
		if strings.Count(v, utils.KE_JI_NAME) == 2 {
			perssionName = strings.Replace(perssionName, "科技(主观)", "科技", -1)
			perssionName = strings.Replace(perssionName, "科技(客观)", "", -1)
		}
		if strings.Count(v, utils.ZHI_ZAO_NAME) == 2 {
			perssionName = strings.Replace(perssionName, "智造(主观)", "智造", -1)
			perssionName = strings.Replace(perssionName, "智造(客观)", "", -1)
		}

		perssionName = strings.TrimRight(perssionName, ",")
		mapContractIdPerssion[k] = perssionName
	}
	mapContractResp = make(map[int]string, 0)

	//过滤多余的","
	for k, v := range mapContractIdPerssion {
		sliceName := strings.Split(v, ",")
		var nameArr []string
		for _, vName := range sliceName {
			if vName == "" {
				continue
			}
			if mapIsUpgrade[fmt.Sprint(k, "perssionName", vName)] {
				vName += "(升级)"
			}
			nameArr = append(nameArr, vName)
		}
		mapContractResp[k] = strings.Join(nameArr, ",")
	}
	return
}

// GetCompanyPermissionNameStatusMapByCompanyId 通过公司ID，获取公司当下所有权限的状态信息
func GetCompanyPermissionNameStatusMapByCompanyId(companyIds []int) (mapResp map[string]string, err error) {
	//return
	lenArr := len(companyIds)
	if lenArr == 0 {
		return
	}
	var condition string
	var pars []interface{}

	condition += " AND  company_id IN (" + utils.GetOrmInReplace(lenArr) + ") AND product_id = 2 "
	pars = append(pars, companyIds)

	//获取所有开通买方研选正式试用的客户列表
	listCompanyPermission, e := company.GetCompanyReportPermissionList(condition, pars, 0, 0)
	if e != nil && e.Error() != utils.ErrNoRow() {
		err = errors.New("GetCompanyReportPermissionList, Err: " + e.Error())
		return
	}

	//获取行业权限ID与名称的映射关系
	permissionList, e := models.GetChartPermissionList()
	if e != nil && e.Error() != utils.ErrNoRow() {
		err = errors.New("GetChartPermissionList, Err: " + e.Error())
		return
	}

	mapResp = make(map[string]string, 0)
	mapChartPermission := make(map[int]string)
	for _, v := range permissionList {
		mapChartPermission[v.ChartPermissionId] = v.PermissionName
	}

	for _, v := range listCompanyPermission {
		if mapChartPermission[v.ChartPermissionId] == "" {
			continue
		}
		//公司ID与权限名称组成映射关系
		mapResp[fmt.Sprint(v.CompanyId, mapChartPermission[v.ChartPermissionId])] = v.Status
	}

	return
}

// 判断合同审核通过时间是否超过九十天
func GetMapIsGrayByCompanyContractIds(companyContractIds []int) (mapResp map[int]bool, err error) {
	lenArr := len(companyContractIds)
	if lenArr == 0 {
		return
	}
	var condition string
	var pars []interface{}
	pars = make([]interface{}, 0)
	condition = " AND  company_contract_id IN (" + utils.GetOrmInReplace(lenArr) + ")    GROUP BY company_contract_id ORDER BY create_time DESC  "
	pars = append(pars, companyContractIds)
	companyContractPermissionList, e := company.GetCompanyContractPermissionList(condition, pars)
	if e != nil && e.Error() != utils.ErrNoRow() {
		err = errors.New("GetCompanyContractPermissionList, Err: " + e.Error())
		return
	}
	//超过九十天就置灰
	timeInit := time.Now().AddDate(0, 0, -180)
	mapResp = make(map[int]bool, 0)
	for _, v := range companyContractPermissionList {
		if v.CreateTime.Before(timeInit) {
			mapResp[v.CompanyContractId] = true
		}
	}
	return
}

//func init3() {
//	var condition string
//	var pars []interface{}
//	//默认只查询权益 2023-06-01 之后的合同
//	condition += ` AND c.product_id = ?  AND a.start_date > ? `
//	pars = append(pars, 2, "2023-06-01")
//
//	//列表页数据
//	list, err := cygx.GetCompanyContractListJoinCompany(condition, pars, 0, 1000)
//	if err != nil {
//		fmt.Println(err)
//		return
//	}
//
//	for _, v := range list {
//		fmt.Println(v.CompanyContractId)
//		HandleAllocationCompanyContractByYanXuan(v.CompanyContractId)
//	}
//
//	fmt.Println(len(list))
//}

// 如果合同只有研选的时候，自动处理派点
func HandleAllocationCompanyContractByYanXuan(companyContractId int) (err error) {
	defer func() {
		if err != nil {
			fmt.Println(err)
			go alarm_msg.SendAlarmMsg(fmt.Sprint("如果合同只有研选的时候，自动处理派点失败，Err：", err.Error(), "companyContractId", companyContractId), 2)
		}
	}()
	var condition string
	var pars []interface{}
	pars = make([]interface{}, 0)
	condition = " AND  company_contract_id = ?  "
	pars = append(pars, companyContractId)
	companyContractPermissionList, e := company.GetCompanyContractPermissionList(condition, pars)
	if e != nil && e.Error() != utils.ErrNoRow() {
		err = errors.New("GetCompanyContractPermissionList, Err: " + e.Error())
		return
	}
	if e != nil && e.Error() != utils.ErrNoRow() {
		err = errors.New("GetCygxAllocationCompanyContractPermissionListById, Err: " + e.Error())
		return
	}

	if len(companyContractPermissionList) > 1 {
		return
	}
	var expensiveYxmoney float64
	for _, v := range companyContractPermissionList {
		if v.ChartPermissionId != utils.CHART_PERMISSION_ID_YANXUAN {
			err = errors.New("没有发现研选权限: ")
			return
		}
		if v.ExpensiveYx == 1 {
			expensiveYxmoney = 5
		} else if v.ExpensiveYx == 2 {
			expensiveYxmoney = 10
		} else {
			expensiveYxmoney = 3
		}
	}

	var items []*cygx.CygxAllocationCompanyContract
	var itemsPermission []*cygx.CygxAllocationCompanyContractPermission

	itemPermission := new(cygx.CygxAllocationCompanyContractPermission)
	itemPermission.CompanyContractId = companyContractId
	//itemPermission.AdminId = sysUser.AdminId
	//itemPermission.AdminName = sysUser.RealName
	itemPermission.Proportion = 0
	itemPermission.Money = expensiveYxmoney
	itemPermission.MoneyAvg = 0
	itemPermission.ChartPermissionName = utils.CHART_PERMISSION_NAME_MF_YANXUAN
	itemPermission.CreateTime = time.Now()
	itemPermission.ModifyTime = time.Now()
	itemsPermission = append(itemsPermission, itemPermission)

	item := new(cygx.CygxAllocationCompanyContract)
	item.CompanyContractId = companyContractId
	//item.AdminId = sysUser.AdminId
	//item.AdminName = sysUser.RealName
	item.Proportion = 0
	item.Money = expensiveYxmoney
	item.RealName = utils.CHART_PERMISSION_NAME_MF_YANXUAN
	item.ChartPermissionName = utils.CHART_PERMISSION_NAME_MF_YANXUAN
	item.CreateTime = time.Now()
	item.ModifyTime = time.Now()
	items = append(items, item)

	e = cygx.AddAndUpdateCygxAllocationCompanyContract(items, itemsPermission, companyContractId)
	if e != nil {
		err = errors.New("AddAndUpdateCygxAllocationCompanyContract, Err: " + e.Error())
		return
	}
	return
}

//func init() {
//	var condition string
//	var pars []interface{}
//
//	condition = " AND status = 1  "
//
//	list, err := company.GetCompanyContractList(condition, pars)
//	if err != nil {
//		fmt.Println(err)
//		return
//	}
//	fmt.Println(len(list))
//	//return
//	for _, v := range list {
//		fmt.Println(v.CompanyContractId)
//		HandleCompanyContractPackageDifference(v.CompanyContractId)
//	}
//
//}

// HandleCompanyContractPackageDifference 更新与上一份合同的金额的对比 '增加套餐','减少套餐','维持套餐'
func HandleCompanyContractPackageDifference(companyContractId int) (err error) {
	defer func() {
		if err != nil {
			fmt.Println(err)
			go alarm_msg.SendAlarmMsg(fmt.Sprint("更新与上一份合同的金额的对比 '增加套餐','减少套餐','维持套餐'失败，Err：", err.Error(), "companyContractId", companyContractId), 2)
		}
	}()
	var condition string
	var pars []interface{}

	condition = " AND company_contract_id = ?  "
	pars = append(pars, companyContractId)
	detail, e := company.GetCompanyContracDetail(condition, pars)
	if e != nil {
		err = errors.New("GetCompanyContracDetail,detail Err: " + e.Error())
		return
	}

	//如果不是续约合同就不做对比处理
	if detail.ContractType != "续约合同" {
		return
	}
	//获取前一份合同的信息
	pars = make([]interface{}, 0)
	condition = " AND company_id = ? AND company_contract_id < ?   AND status = 1    AND product_id = ?  ORDER BY company_contract_id DESC   LIMIT  1  "
	pars = append(pars, detail.CompanyId, companyContractId, detail.ProductId)
	detailPrevious, e := company.GetCompanyContracDetail(condition, pars)
	if e != nil {
		err = errors.New("GetCompanyContracDetail,detailPrevious Err: " + e.Error())
		return
	}
	var packageDifference string

	if detail.Money > detailPrevious.Money {
		packageDifference = "增加套餐"
	} else if detail.Money < detailPrevious.Money {
		packageDifference = "减少套餐"
	} else {
		packageDifference = "维持套餐"
	}

	e = company.UpdateCompanyContractPackageDifference(packageDifference, companyContractId)
	if e != nil {
		err = errors.New("UpdateCompanyContractPackageDifference, Err: " + e.Error())
		return
	}
	return

}

// HandleCompanyContractPermissionContractType 更新合同权限表中的权限名称，以及对应的行业权限类型（行业新签、行业续约）
func HandleCompanyContractPermissionContractType(companyContractId int) (err error) {
	defer func() {
		if err != nil {
			fmt.Println(err)
			go alarm_msg.SendAlarmMsg(fmt.Sprint("更新合同权限表中的权限名称，以及对应的行业权限类型（行业新签、行业续约）失败，HandleCompanyContractPermissionContractType Err：", err.Error(), "companyContractId", companyContractId), 2)
		}
	}()
	var condition string
	var pars []interface{}

	condition = " AND company_contract_id = ?  "
	pars = append(pars, companyContractId)
	detail, e := company.GetCompanyContracDetail(condition, pars)
	if e != nil {
		err = errors.New("GetCompanyContracDetail,detail Err: " + e.Error())
		return
	}

	//获取权限ID与名称的map映射
	permissionList, e := models.GetChartPermissionList()
	if e != nil && e.Error() != utils.ErrNoRow() {
		err = errors.New("GetChartPermissionList Err: " + e.Error())
		return
	}

	mapChartPermission := make(map[int]string)
	for _, v := range permissionList {
		mapChartPermission[v.ChartPermissionId] = v.PermissionName
	}

	companyId := detail.CompanyId
	//如果不是续约合同就不做对比处理
	pars = make([]interface{}, 0)
	condition = " AND  company_contract_id  != ?   AND  company_id = ? "
	pars = append(pars, companyContractId, companyId)

	//获取历史签约信息
	companyContractPermissionListHistory, e := company.GetCompanyContractPermissionList(condition, pars)
	if e != nil && e.Error() != utils.ErrNoRow() {
		err = errors.New("companyContractPermissionListHistory Err: " + e.Error())
		return
	}

	var mapHistoryPerssionName []string
	for _, v := range companyContractPermissionListHistory {
		mapHistoryPerssionName = append(mapHistoryPerssionName, mapChartPermission[v.ChartPermissionId])
	}

	pars = make([]interface{}, 0)
	condition = " AND  company_contract_id  = ?   "
	pars = append(pars, companyContractId)
	//获取当前签约的合同信息
	companyContractPermissionLisThis, e := company.GetCompanyContractPermissionList(condition, pars)
	if e != nil && e.Error() != utils.ErrNoRow() {
		err = errors.New("companyContractPermissionLisThis Err: " + e.Error())
		return
	}

	var items []*company.CompanyContractPermission
	for _, v := range companyContractPermissionLisThis {
		v.PermissionName = mapChartPermission[v.ChartPermissionId]
		if v.PermissionName == "" {
			continue
		}
		//已经存在的属于行业续约、不存在的属于行业新签
		if utils.InArrayByStr(mapHistoryPerssionName, v.PermissionName) {
			v.ContractType = "行业续约"
		} else {
			v.ContractType = "行业新签"
		}
		items = append(items, v)
	}
	//批量更新合同权限表的权限行业名称，以及签约合同时，当前行业类型（行业续约、行业新签）
	e = company.UpdateCompanyContractPermissionMulti(items)
	if e != nil {
		err = errors.New("UpdateCompanyContractPermissionMulti Err: " + e.Error())
		return
	}
	return
}

func initCRM14_4() {
	//func init() {
	permissionList, e := models.GetChartPermissionList()
	if e != nil && e.Error() != utils.ErrNoRow() {
		fmt.Println(permissionList)
		return
	}

	mapChartPermission := make(map[int]string)
	for _, v := range permissionList {
		mapChartPermission[v.ChartPermissionId] = v.PermissionName
	}

	var condition string
	var pars []interface{}
	condition = " AND status = 1    AND  product_id = 2  "
	companyContractList, e := company.GetCompanyContractList(condition, pars)
	if e != nil && e.Error() != utils.ErrNoRow() {
		fmt.Println(e)
		return
	}
	fmt.Println(len(companyContractList))
	for k, v := range companyContractList {
		fmt.Println(k)
		HandleCompanyContractPermissionContractType(v.CompanyContractId)
	}

	//var companyContractIds []int
	//for _, v := range companyContractList {
	//	companyContractIds = append(companyContractIds, v.CompanyContractId)
	//}
	//condition = " AND  company_contract_id IN (" + utils.GetOrmInReplace(len(companyContractIds)) + ")  "
	//pars = append(pars, companyContractIds)
	//
	//companyContractPermissionList, e := company.GetCompanyContractPermissionList(condition, pars)
	//if e != nil && e.Error() != utils.ErrNoRow() {
	//	fmt.Println(e)
	//	return
	//}
	//
	//var items []*company.CompanyContractPermission
	//
	//for _, v := range companyContractPermissionList {
	//	v.PermissionName = mapChartPermission[v.ChartPermissionId]
	//
	//	items = append(items, v)
	//}
	//fmt.Println(len(items))
	////return
	//e = company.UpdateCompanyContractPermissionMulti(items)
	//if e != nil && e.Error() != utils.ErrNoRow() {
	//	fmt.Println(e)
	//	return
	//}

}