fms_api/services/fms/contract_register.go

package fms

import (
	"errors"
	"fmt"
	"github.com/shopspring/decimal"
	"hongze/fms_api/models/base"
	"hongze/fms_api/models/crm"
	"hongze/fms_api/models/fms"
	"hongze/fms_api/services/alarm_msg"
	crmService "hongze/fms_api/services/crm"
	"hongze/fms_api/services/resource"
	"hongze/fms_api/utils"
	"os"
	"regexp"
	"sort"
	"strings"
	"time"
)

// CheckContractRegisterAmount 校验合同登记金额-判断是否需要更新合同登记状态
func CheckContractRegisterAmount(registerId int) {
	var err error
	defer func() {
		if err != nil {
			alarm_msg.SendAlarmMsg("校验合同登记金额失败, ErrMsg: "+err.Error(), 3)
		}
	}()

	// 获取合同登记信息
	cr := new(fms.ContractRegister)
	item, e := cr.Fetch(registerId)
	if e != nil {
		err = errors.New("获取合同登记信息失败, Err: " + e.Error())
		return
	}
	amount := decimal.NewFromFloat(item.ContractAmount).Round(2)

	// 获取开票/到款信息
	invoiceCond := `contract_register_id = ?`
	invoicePars := make([]interface{}, 0)
	invoicePars = append(invoicePars, registerId)
	ci := new(fms.ContractInvoice)
	invoiceList, e := ci.List(invoiceCond, invoicePars, "")
	if e != nil {
		err = errors.New("获取开票到款信息失败, Err: " + e.Error())
		return
	}
	invoiceAmount := decimal.NewFromFloat(0).Round(2)
	paymentAmount := decimal.NewFromFloat(0).Round(2)
	for i := range invoiceList {
		a := decimal.NewFromFloat(invoiceList[i].OriginAmount).Round(2)
		if invoiceList[i].InvoiceType == fms.ContractInvoiceTypeMake {
			invoiceAmount = invoiceAmount.Add(a)
		}
		if invoiceList[i].InvoiceType == fms.ContractInvoiceTypePay {
			paymentAmount = paymentAmount.Add(a)
		}
	}

	status := fms.ContractRegisterStatusIng
	// 以下情况更新合同登记状态为已完成
	// 1.合同存在代付; 2.合同状态为已签回且合同金额=开票金额=到款金额; 3合同状态为已终止
	if item.HasInvoice == 0 || (amount.Equal(invoiceAmount) && invoiceAmount.Equal(paymentAmount) && item.ContractStatus == fms.ContractStatusCheckedBack) || item.ContractStatus == fms.ContractStatusEnd {
		status = fms.ContractRegisterStatusComplete
	}
	updateCols := []string{"InvoicedAmount", "PaymentAmount", "RegisterStatus", "ModifyTime"}
	ia, _ := invoiceAmount.Round(2).Float64()
	pa, _ := paymentAmount.Round(2).Float64()
	item.InvoicedAmount = ia
	item.PaymentAmount = pa
	item.RegisterStatus = status
	item.ModifyTime = time.Now().Local()
	if e = item.Update(updateCols); e != nil {
		err = errors.New("更新合同登记金额及状态失败, Err: " + e.Error())
		return
	}
	return
}

// HandleContractServiceAndDetail 根据请求数据获取套餐服务详情信息
func HandleContractServiceAndDetail(serviceList []fms.ContractServiceAddReq, base642Image bool, serviceAmountMap map[int]float64) (serviceDetailList []*fms.ContractServiceAndDetail, err error) {
	serviceDetailList = make([]*fms.ContractServiceAndDetail, 0)
	if len(serviceList) < 0 {
		err = errors.New("请至少选择一种套餐")
		return
	}
	for i := 0; i < len(serviceList); i++ {
		item := serviceList[i]
		hasDetail := "否"
		// 合同模板
		serviceTemp, e := fms.GetContractServiceTemplateById(item.ServiceTemplateId)
		if e != nil {
			err = errors.New("找不到该模板")
			return
		}
		serviceDetail := &fms.ContractServiceAndDetail{
			ServiceTemplateId:  item.ServiceTemplateId,
			Title:              item.Title,
			Value:              item.Value,
			ProductId:          serviceTemp.ProductId,
			HasDetail:          hasDetail,
			TableValue:         serviceTemp.TableValue,
			ChartPermissionId:  serviceTemp.ChartPermissionId,
			ChartPermissionIds: item.ChartPermissionIds,
			//Detail:             detailList,
		}
		serviceDetailList = append(serviceDetailList, serviceDetail)
	}
	return
}

// HandleContractServiceAmount 根据请求数据获取套餐金额详情信息
func HandleContractServiceAmount(serviceAmountList []fms.ContractServiceAmountAddReq, serviceAmountMap map[int]float64, currencyUnit string) (list []*fms.ContractServiceAmount, err error) {
	if len(serviceAmountList) < 0 {
		err = errors.New("请至少输入一种套餐金额信息")
		return
	}
	for i := 0; i < len(serviceAmountList); i++ {
		item := serviceAmountList[i]
		serviceAmountMap[item.ProductId] = item.ServiceAmount
		if item.ProductId !=crm.CompanyProductRai && item.ProductId != crm.CompanyProductFicc {
			err = errors.New("请选择正确和套餐类型")
			return
		}
		serviceDetail := &fms.ContractServiceAmount{
			ProductId:     item.ProductId,
			ServiceAmount: item.ServiceAmount,
			CurrencyUnit:  currencyUnit,
			TimeBase:      base.TimeBase{},
		}
		list = append(list, serviceDetail)
	}
	return
}

// GetContractServiceAndDetail 根据合同登记ID获取服务详情
func GetContractServiceAndDetail(contractRegisterId int) (serviceList []*fms.ContractServiceAndDetail, err error) {
	list, e := fms.GetContractServiceAndDetailList(contractRegisterId)
	if e != nil {
		err = errors.New(fmt.Sprint("查找合同服务异常", e))
		return
	}
	serviceList = list
	//newLen := len(serviceList)
	//for i := 0; newLen > i; i++ {
	//	if serviceList[i].HasDetail == "是" {
	//		detail, e := fms.GetContractServiceDetailByServiceId(serviceList[i].ContractServiceId)
	//		if e != nil {
	//			err = errors.New(fmt.Sprint("查找合同服务详情异常", e))
	//			return
	//		}
	//		serviceList[i].Detail = detail
	//	}
	//}
	return
}

// UploadImageBase64 将base64的图片上传至oss
func UploadImageBase64(base64Str string) (resourceUrl string, err error) {
	ext := ".png"
	uploadDir := "./static"
	randStr := utils.GetRandStringNoSpecialChar(28)
	fileName := randStr + ext
	fpath := uploadDir + "/" + fileName

	b, _ := regexp.MatchString(`^data:\s*image\/(\w+);base64,`, base64Str)
	if !b {
		err = errors.New("图片格式不正确")
		return
	}
	re, _ := regexp.Compile(`^data:\s*image\/(\w+);base64,`)
	base64Str = re.ReplaceAllString(base64Str, "")
	base64Str = strings.Replace(base64Str, " ", "", -1)

	base64Str = strings.Replace(base64Str, " ", "", -1)
	err = utils.SaveBase64ToFile(base64Str, fpath)
	if err != nil {
		return
	}
	defer os.Remove(fpath)

	savePath := utils.OssUploadImgDir + time.Now().Format("200601/20060102/")
	savePath += fileName
	// 上传到阿里云
	err = resource.UploadVideoAliyun(fileName, fpath, savePath)
	if err != nil {
		return
	}
	resourceUrl = utils.OssHost + savePath
	return
}

// FixContractInvoiceSellerInfo 修复开票登记销售相关信息(一次性)
func FixContractInvoiceSellerInfo() {
	sellerList, e := crmService.GetSellerDepartmentListWithGroupAndTeam()
	if e != nil {
		fmt.Println("获取销售列表失败, Err: " + e.Error())
		return
	}
	sellerMap := make(map[int]*crm.SellerAdminWithGroupTeam)
	for i := range sellerList {
		sellerMap[sellerList[i].SellerId] = sellerList[i]
	}

	registerCond := ``
	registerPars := make([]interface{}, 0)
	registerOB := new(fms.ContractRegister)
	registerList, e := registerOB.List(registerCond, registerPars)
	if e != nil {
		fmt.Println("获取合同登记列表失败, Err: " + e.Error())
		return
	}
	invUpCols := []string{"SellerId", "SellerName", "SellerGroupId", "SellerGroupName", "SellerTeamId", "SellerTeamName"}
	fmt.Println("start 修复")
	for i := range registerList {
		registerId := registerList[i].ContractRegisterId
		sellerId := registerList[i].SellerId
		sellerItem := sellerMap[sellerId]
		if sellerItem == nil {
			fmt.Printf("ID-%d 无销售信息\n", registerId)
			continue
		}

		invOB := new(fms.ContractInvoice)
		invCond := `invoice_type = 1 AND contract_register_id = ?`
		invPars := make([]interface{}, 0)
		invPars = append(invPars, registerId)
		invList, e := invOB.List(invCond, invPars, "")
		if e != nil {
			fmt.Println("获取开票登记列表失败, Err: " + e.Error())
			return
		}
		for _, v := range invList {
			v.SellerId = sellerItem.SellerId
			v.SellerName = sellerItem.SellerName
			v.SellerGroupId = sellerItem.GroupId
			v.SellerGroupName = sellerItem.GroupName
			v.SellerTeamId = sellerItem.TeamId
			v.SellerTeamName = sellerItem.TeamName
			if e = v.Update(invUpCols); e != nil {
				fmt.Println("更新开票登记失败, Err: " + e.Error())
				return
			}
			fmt.Printf("ID-%d 修复成功\n", v.ContractInvoiceId)
		}
	}
	fmt.Println("end 修复")
	return
}

// FixContractInvoicePaymentType 修复历史到款登记付款方式(一次性)
func FixContractInvoicePaymentType() {
	registerCond := ``
	registerPars := make([]interface{}, 0)
	registerOB := new(fms.ContractRegister)
	registerList, e := registerOB.List(registerCond, registerPars)
	if e != nil {
		fmt.Println("获取合同登记列表失败, Err: " + e.Error())
		return
	}
	invUpCols := []string{"PayType"}
	fmt.Println("start 修复")
	for i := range registerList {
		registerId := registerList[i].ContractRegisterId

		invOB := new(fms.ContractInvoice)
		invCond := `invoice_type = 2 AND contract_register_id = ?`
		invPars := make([]interface{}, 0)
		invPars = append(invPars, registerId)
		invList, e := invOB.List(invCond, invPars, "")
		if e != nil {
			fmt.Println("获取到款登记列表失败, Err: " + e.Error())
			return
		}

		dayDiff := registerList[i].EndDate.Sub(registerList[i].StartDate).Hours() / 24
		for _, v := range invList {
			v.PayType = CalculateContractPaymentType(v.Amount, registerList[i].ContractAmount, dayDiff)
			if e = v.Update(invUpCols); e != nil {
				fmt.Println("更新到款登记付款方式失败, Err: " + e.Error())
				return
			}
			fmt.Printf("ID-%d 修复成功\n", v.ContractInvoiceId)
		}
	}
	fmt.Println("end 修复")
	return
}

// FixContractSummaryData 修复开票到款汇总数据(一次性)
func FixContractSummaryData() {
	registerCond := ``
	registerPars := make([]interface{}, 0)
	registerOB := new(fms.ContractRegister)
	registerList, e := registerOB.List(registerCond, registerPars)
	if e != nil {
		fmt.Println("获取合同登记列表失败, Err: " + e.Error())
		return
	}
	fmt.Println("start 修复")
	for i := range registerList {
		fmt.Printf("正在修复-%d", registerList[i].ContractRegisterId)
		SummaryInvoicePaymentByContractRegisterId(registerList[i].ContractRegisterId)
	}
	fmt.Println("end 修复")
	return
}


func GetContractServiceNameFormat(registerIds []int) (serviceNameMap map[int]string, serviceFormatMap map[int][]fms.ContractServiceTemplateFormat, err error) {
	serviceNameMap = make(map[int]string)
	serviceMap := make(map[int][]string, 0)
	serviceFormatMap = make(map[int][]fms.ContractServiceTemplateFormat, 0)
	serviceIndustryStr := "医药,消费,科技,智造"
	serviceIdMap := make(map[int]*fms.ContractServiceTemplateFullName, 0)
	serviceIndustryMap := make(map[int]map[string][]*fms.ContractServiceTemplateFullName, 0)
	allServiceList, e := fms.GetContractServiceTemplateFullName()
	if e != nil {
		err = fmt.Errorf("获取所有套餐失败, Err: "+e.Error())
		return
	}
	for _, v := range allServiceList {
		serviceIdMap[v.ServiceTemplateId] = v
	}
	// 获取服务套餐
	servicesList, e := fms.GetContractRegisterServicesByRegisterIds(registerIds)
	if e != nil {
		err = fmt.Errorf("获取套餐字符串失败, Err: "+e.Error())
		return
	}
	for i := range servicesList {
		item := servicesList[i]
		if item.Title == "行业套餐" || item.Title == "权益大套餐" {
			continue
		}
		if fullItem, ok := serviceIdMap[item.ServiceTemplateId]; ok {
			if fullItem.ParentTitle == "行业套餐" {
				continue
			}
			if fullItem.ParentTitle != "" {
				if strings.Contains(serviceIndustryStr, fullItem.ParentTitle) {
					if _, ok1 := serviceIndustryMap[item.ContractRegisterId]; !ok1 {
						serviceIndustryMap[item.ContractRegisterId] = make(map[string][]*fms.ContractServiceTemplateFullName)
					}
					serviceIndustryMap[item.ContractRegisterId][fullItem.ParentTitle] = append(serviceIndustryMap[item.ContractRegisterId][fullItem.ParentTitle], fullItem)
				} else {
					formatTitle := ""
					if fullItem.ParentTitle == "策略" {
						formatTitle = fullItem.Title
					}else{
						formatTitle = fullItem.ParentTitle+"("+fullItem.Title+")"
					}
					serviceMap[item.ContractRegisterId] = append(serviceMap[item.ContractRegisterId], formatTitle)
					tmp := fms.ContractServiceTemplateFormat{
						FormatTitle:        formatTitle,
						ServiceTemplateId:  fullItem.ServiceTemplateId,
						ServiceTemplatePid: fullItem.Pid,
						ServiceProductId:   fullItem.ProductId,
					}
					serviceFormatMap[item.ContractRegisterId] = append(serviceFormatMap[item.ContractRegisterId], tmp)
				}
			}else{
				serviceMap[item.ContractRegisterId] = append(serviceMap[item.ContractRegisterId], fullItem.Title)
				tmp := fms.ContractServiceTemplateFormat{
					FormatTitle:        fullItem.Title,
					ServiceTemplateId:  fullItem.ServiceTemplateId,
					ServiceTemplatePid: fullItem.Pid,
					ServiceProductId:   fullItem.ProductId,
				}
				serviceFormatMap[item.ContractRegisterId] = append(serviceFormatMap[item.ContractRegisterId], tmp)
			}
		}
	}
	for k, v := range serviceIndustryMap {
		for sk, sv := range v {
			formatTitle := ""
			templateId := 0
			pid := 0
			if len(sv) >= 2 {
				formatTitle = sk
				templateId = sv[0].Pid
			}else{
				formatTitle = sk+"("+sv[0].Title+")"
				templateId = sv[0].ServiceTemplateId
				pid = sv[0].Pid
			}
			serviceMap[k] = append(serviceMap[k], formatTitle)
			tmp := fms.ContractServiceTemplateFormat{
				FormatTitle:       formatTitle,
				ServiceTemplateId: templateId,
				ServiceTemplatePid: pid,
				ServiceProductId:   sv[0].ProductId,
			}
			serviceFormatMap[k] = append(serviceFormatMap[k], tmp)
		}
	}

	// 给套餐内容排序
	for k, v := range serviceFormatMap {
		sort.Sort(fms.ContractServiceTemplateFormatList(v))
		for _, sv := range v {
			serviceNameMap[k] += sv.FormatTitle+","
		}
		serviceNameMap[k] = strings.Trim(serviceNameMap[k], ",")
	}
	return
}