opms_backend/opms_parent/app/service/contract/report.go

package service

import (
	"context"
	dao "dashoo.cn/micro/app/dao/contract"
	"dashoo.cn/micro/app/model/contract"
	"dashoo.cn/micro/app/service"
	"dashoo.cn/opms_libary/micro_srv"
	"dashoo.cn/opms_libary/myerrors"
	"fmt"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/os/gtime"
)

type ContractReportService struct {
	Dao *dao.CtrContractDao
	*service.ContextService
}

func NewContractReportService(ctx context.Context) (svc *ContractReportService, err error) {
	tenant, err := micro_srv.GetTenant(ctx)
	if err != nil {
		err = myerrors.TipsError(fmt.Sprintf("获取租户码异常：%s", err.Error()))
		return nil, err //fmt.Errorf("获取租户码异常：%s", err.Error())
	}

	svc = new(ContractReportService)
	if svc.ContextService, err = svc.Init(ctx); err != nil {
		return nil, err
	}
	svc.Dao = dao.NewCtrContractDao(tenant)
	return svc, nil
}

type CollectionNumData struct {
	contract.CtrContractCollection
	InchargeId   int     `orm:"incharge_id"           json:"inchargeId"`   // 负责人ID
	InchargeName string  `orm:"incharge_name"         json:"inchargeName"` // 负责人(销售工程师)
	ProductLine  string  `orm:"product_line"          json:"productLine"`  // 产品线
	Total        float64 `orm:"total"`                                     // 合计
}

// QueryCollectionNum 业绩指标-回款金额
func (s *ContractReportService) QueryCollectionNum(date string) (interface{}, error) {
	where := ""
	// 权限限制（销售工程师看自己的）
	if service.StringsContains(s.CxtUser.Roles, "SalesEngineer") {
		where = fmt.Sprintf("b.incharge_id='%v'", s.CxtUser.Id)
	}
	// 获取数据
	var collectionInfos []*CollectionNumData
	err := s.Dao.DB.Model("ctr_contract_collection a").InnerJoin("ctr_contract b", "a.contract_id=b.id").Where(fmt.Sprintf("collection_datetime LIKE '%v%%'", date)).Where(where).Fields("a.*,b.incharge_id,b.incharge_name,b.product_line,SUM(a.collection_amount) total").Group("incharge_id, product_line").Order("incharge_id ASC, product_line ASC").Scan(&collectionInfos)
	if err != nil {
		return nil, err
	}
	// 获取销售数据
	userList, err := service.GetUserListByRoleCode(s.Ctx, []string{"SalesEngineer"}, 1000)
	if err != nil {
		return nil, err
	}
	// 权限限制（销售工程师看自己的）
	if service.StringsContains(s.CxtUser.Roles, "SalesEngineer") {
		userList = []map[string]interface{}{
			{
				"Id":       s.CxtUser.Id,
				"NickName": s.CxtUser.NickName,
			},
		}
	}
	// BIOBANK CELLSOP LIMS+基因 其他
	header, data := make([]g.Map, 0), make([]g.Map, 0)
	header = append(header, g.Map{"prop": "userName", "label": "销售工程师"}, g.Map{"prop": "bio", "label": "BIOBANK"}, g.Map{"prop": "cell", "label": "CELLSOP"}, g.Map{"prop": "lims", "label": "LIMS+基因"}, g.Map{"prop": "other", "label": "其他"}, g.Map{"prop": "total", "label": "合计"})

	user2Collections := make(map[int][]*CollectionNumData, 0)
	total := float64(0)
	for _, col := range collectionInfos {
		if _, ok := user2Collections[col.InchargeId]; !ok {
			user2Collections[col.InchargeId] = make([]*CollectionNumData, 0)
		}
		user2Collections[col.InchargeId] = append(user2Collections[col.InchargeId], col)
		total += col.Total
	}
	// 统计数据
	for _, user := range userList {
		bio, cell, lims, other, tot := float64(0), float64(0), float64(0), float64(0), float64(0)
		if len(user2Collections[user["Id"].(int)]) > 0 {
			for _, col := range user2Collections[user["Id"].(int)] {
				tot += col.Total
				if col.ProductLine == "10" {
					bio += col.Total
				} else if col.ProductLine == "20" {
					cell += col.Total
				} else if col.ProductLine == "30" {
					lims += col.Total
				} else {
					other += col.Total
				}
			}
		}
		data = append(data, g.Map{
			"userName": user["NickName"],
			"bio":      fmt.Sprintf("%.2f", bio),
			"cell":     fmt.Sprintf("%.2f", cell),
			"lims":     fmt.Sprintf("%.2f", lims),
			"other":    fmt.Sprintf("%.2f", other),
			"total":    fmt.Sprintf("%.2f", tot),
		})
	}
	data = append(data, g.Map{
		"userName": "",
		"bio":      "",
		"cell":     "",
		"lims":     "",
		"other":    "",
		"total":    fmt.Sprintf("总计：%.2f元", total),
	})

	return g.Map{"header": header, "data": data}, nil
}

// QueryContractNum 业绩指标-签约合同金额
func (s *ContractReportService) QueryContractNum(date string) (interface{}, error) {
	type ContractNumData struct {
		contract.CtrContract
		Total float64 `orm:"total"` // 合计
	}
	where := ""
	// 权限限制（销售工程师看自己的）
	if service.StringsContains(s.CxtUser.Roles, "SalesEngineer") {
		where = fmt.Sprintf("incharge_id='%v'", s.CxtUser.Id)
	}
	// 获取数据
	var contractInfos []*ContractNumData
	err := s.Dao.Where(fmt.Sprintf("contract_sign_time LIKE '%v%%' AND appro_status='30'", date)).Where(where).Fields("ctr_contract.*,SUM(contract_amount) total").Group("incharge_id, product_line").Order("incharge_id ASC, product_line ASC").Scan(&contractInfos)
	if err != nil {
		return nil, err
	}
	// 获取销售数据
	userList, err := service.GetUserListByRoleCode(s.Ctx, []string{"SalesEngineer"}, 1000)
	if err != nil {
		return nil, err
	}
	// 权限限制（销售工程师看自己的）
	if service.StringsContains(s.CxtUser.Roles, "SalesEngineer") {
		userList = []map[string]interface{}{
			{
				"Id":       s.CxtUser.Id,
				"NickName": s.CxtUser.NickName,
			},
		}
	}
	// BIOBANK CELLSOP LIMS+基因 其他
	header, data := make([]g.Map, 0), make([]g.Map, 0)
	header = append(header, g.Map{"prop": "userName", "label": "销售工程师"}, g.Map{"prop": "bio", "label": "BIOBANK"}, g.Map{"prop": "cell", "label": "CELLSOP"}, g.Map{"prop": "lims", "label": "LIMS+基因"}, g.Map{"prop": "other", "label": "其他"}, g.Map{"prop": "total", "label": "合计"})

	user2Contracts := make(map[int][]*ContractNumData, 0)
	total := float64(0)
	for _, col := range contractInfos {
		if _, ok := user2Contracts[col.InchargeId]; !ok {
			user2Contracts[col.InchargeId] = make([]*ContractNumData, 0)
		}
		user2Contracts[col.InchargeId] = append(user2Contracts[col.InchargeId], col)
		total += col.Total
	}
	// 统计数据
	for _, user := range userList {
		bio, cell, lims, other, tot := float64(0), float64(0), float64(0), float64(0), float64(0)
		if len(user2Contracts[user["Id"].(int)]) > 0 {
			for _, col := range user2Contracts[user["Id"].(int)] {
				tot += col.Total
				if col.ProductLine == "10" {
					bio += col.Total
				} else if col.ProductLine == "20" {
					cell += col.Total
				} else if col.ProductLine == "30" {
					lims += col.Total
				} else {
					other += col.Total
				}
			}
		}
		data = append(data, g.Map{
			"userName": user["NickName"],
			"bio":      fmt.Sprintf("%.2f", bio),
			"cell":     fmt.Sprintf("%.2f", cell),
			"lims":     fmt.Sprintf("%.2f", lims),
			"other":    fmt.Sprintf("%.2f", other),
			"total":    fmt.Sprintf("%.2f", tot),
		})
	}
	data = append(data, g.Map{
		"userName": "",
		"bio":      "",
		"cell":     "",
		"lims":     "",
		"other":    "",
		"total":    fmt.Sprintf("总计：%.2f元", total),
	})

	return g.Map{"header": header, "data": data}, nil
}

// QueryContractExpireNum 售后运维到期统计表
func (s *ContractReportService) QueryContractExpireNum(date string) (interface{}, error) {
	if date != "" {
		date += "-01 00:00:00"
		date = gtime.NewFromStr(date).AddDate(1, 0, 0).Format("Y-m")
	}
	where := ""
	// 权限限制（销售工程师看自己的）
	if service.StringsContains(s.CxtUser.Roles, "SalesEngineer") {
		where = fmt.Sprintf("incharge_id='%v'", s.CxtUser.Id)
	}
	// 获取数据
	var contractInfos []*contract.CtrContract
	err := s.Dao.Where(fmt.Sprintf("contract_end_time LIKE '%v%%' AND appro_status='30'", date)).Where(where).Order("incharge_id ASC, contract_end_time ASC").Scan(&contractInfos)
	if err != nil {
		return nil, err
	}

	header, data := make([]g.Map, 0), make([]g.Map, 0)
	header = append(header, g.Map{"prop": "userName", "label": "销售工程师"}, g.Map{"prop": "code", "label": "合同编号"}, g.Map{"prop": "endTime", "label": "合同结束时间"}, g.Map{"prop": "cusName", "label": "客户名称"}, g.Map{"prop": "amount", "label": "合同总金额"})

	total := 0
	for _, info := range contractInfos {
		data = append(data, g.Map{
			"userName": info.InchargeName,
			"code":     info.ContractCode,
			"endTime":  info.ContractEndTime.Format("Y-m-d"),
			"cusName":  info.CustName,
			"amount":   fmt.Sprintf("总计：%.2f元", info.ContractAmount),
		})
		total += 1
	}
	data = append(data, g.Map{
		"userName": "",
		"code":     "",
		"endTime":  "",
		"cusName":  "",
		"amount":   fmt.Sprintf("总计：%v", total),
	})

	return g.Map{"header": header, "data": data}, nil
}