opms_backend/opms_parent/app/service/opsdev/project_inventory.go

package opsdev

import (
	"context"
	"fmt"

	"dashoo.cn/opms_libary/micro_srv"
	"dashoo.cn/opms_libary/request"
	contractdao "dashoo.cn/opms_parent/app/dao/contract"
	opsdevdao "dashoo.cn/opms_parent/app/dao/opsdev"
	"dashoo.cn/opms_parent/app/model/opsdev"
	"dashoo.cn/opms_parent/app/service"
	"github.com/gogf/gf/frame/g"
)

// ProjectInventoryService 项目清单服务
type ProjectInventoryService struct {
	Dao         *opsdevdao.OpsDeliveryProjectDao
	ContractDao *contractdao.CtrContractDao
	Tenant      string
	userInfo    request.UserInfo
}

// NewProjectInventoryService 初始化服务
func NewProjectInventoryService(ctx context.Context) (*ProjectInventoryService, error) {
	tenant, err := micro_srv.GetTenant(ctx)
	if err != nil {
		return nil, fmt.Errorf("获取租户信息异常：%s", err.Error())
	}
	userInfo, err := micro_srv.GetUserInfo(ctx)
	if err != nil {
		return nil, fmt.Errorf("获取用户信息异常：%s", err.Error())
	}
	return &ProjectInventoryService{
		Dao:         opsdevdao.NewOpsDeliveryProjectDao(tenant),
		ContractDao: contractdao.NewCtrContractDao(tenant),
		Tenant:      tenant,
		userInfo:    userInfo,
	}, nil
}

// GetList 获取项目清单列表
func (s *ProjectInventoryService) GetList(req *opsdev.ProjectInventorySearchReq) (int, []*opsdev.ProjectInventoryRsp, error) {
	db := s.Dao.DB.Table("ops_delivery_project")
	db = db.LeftJoin("ctr_contract", "ctr_contract.id = ops_delivery_project.contract_id")
	db = db.LeftJoin("cust_customer", "cust_customer.id = ops_delivery_project.cust_id")
	db = db.Where("ops_delivery_project.deleted_time IS NULL")

	if req.ContractNo != "" {
		db = db.WhereLike("ctr_contract.contract_code", "%"+req.ContractNo+"%")
	}
	if req.ProjectName != "" {
		db = db.WhereLike("ops_delivery_project.project_name", "%"+req.ProjectName+"%")
	}
	if req.ProductLine != "" {
		db = db.Where("ops_delivery_project.product_line", req.ProductLine)
	}
	if req.ProjectStatus != "" {
		db = db.Where("ops_delivery_project.project_status", req.ProjectStatus)
	}
	if req.DeliveryNode != "" {
		db = db.Where("ops_delivery_project.delivery_node", req.DeliveryNode)
	}
	if req.DeliveryUserId > 0 {
		db = db.Where("ops_delivery_project.delivery_user_id", req.DeliveryUserId)
	}
	if req.SalesUserId > 0 {
		db = db.Where("ops_delivery_project.sales_user_id", req.SalesUserId)
	}
	if req.PlanDeliveryTimeStart != "" {
		db = db.WhereGTE("ops_delivery_project.plan_delivery_time", req.PlanDeliveryTimeStart)
	}
	if req.PlanDeliveryTimeEnd != "" {
		db = db.WhereLTE("ops_delivery_project.plan_delivery_time", req.PlanDeliveryTimeEnd)
	}
	if req.PlanAcceptTimeStart != "" {
		db = db.WhereGTE("ops_delivery_project.plan_accept_time", req.PlanAcceptTimeStart)
	}
	if req.PlanAcceptTimeEnd != "" {
		db = db.WhereLTE("ops_delivery_project.plan_accept_time", req.PlanAcceptTimeEnd)
	}

	if s.userInfo.UserName != "admin" {
		hasPermission := false
		for _, role := range s.userInfo.Roles {
			if role == "SysAdmin" || role == "ResearchAndDevelopmentDirector" ||
				role == "ResearchAndDevelopmentSupervisor" || role == "QualityAssuranceSupervisor" ||
				role == "GeneralManager" || role == "SalesDirector" || role == "SaleAssociate" {
				hasPermission = true
				break
			}
		}

		if !hasPermission {
			userIds := []int{s.userInfo.Id}
			for _, role := range s.userInfo.Roles {
				if role == "ProjectManager" || role == "ProjectDeliveryManager" {
					db = db.Where("ops_delivery_project.delivery_user_id IN (?)", userIds)
					hasPermission = true
					break
				}
				if role == "SalesEngineer" {
					db = db.Where("ops_delivery_project.sales_user_id IN (?)", userIds)
					hasPermission = true
					break
				}
			}

			if !hasPermission {
				db = db.Where("1 = 0")
			}
		}
	}

	total, err := db.Count()
	if err != nil {
		return 0, nil, err
	}

	pageNum, pageSize := req.PageNum, req.PageSize
	if pageNum <= 0 {
		pageNum = 1
	}
	if pageSize <= 0 {
		pageSize = 20
	}

	db = db.Order("ops_delivery_project.created_time DESC")
	var records []*opsdev.ProjectInventoryRsp
	err = db.Page(pageNum, pageSize).Fields(
		"ops_delivery_project.id",
		"ops_delivery_project.project_name",
		"ops_delivery_project.product_line",
		"ops_delivery_project.project_status",
		"ops_delivery_project.delivery_node",
		"ops_delivery_project.delivery_user_id",
		"ops_delivery_project.delivery_user_name",
		"ops_delivery_project.sales_user_id",
		"ops_delivery_project.sales_user_name",
		"ops_delivery_project.plan_delivery_time",
		"ops_delivery_project.plan_accept_time",
		"ops_delivery_project.contract_id",
		"ops_delivery_project.contract_no",
		"ctr_contract.contract_amount",
		"ctr_contract.collected_amount",
		"ops_delivery_project.cust_id",
		"ops_delivery_project.cust_name",
	).Scan(&records)
	if err != nil {
		return 0, nil, err
	}

	return total, records, nil
}

// GetProjectManagers 获取项目管理人员列表
func (s *ProjectInventoryService) GetProjectManagers(roleType string) ([]*opsdev.ProjectManagerRsp, error) {
	var roleKeys []string

	switch roleType {
	case "projectManager":
		roleKeys = []string{"ProjectManager"}
	case "deliveryManager":
		roleKeys = []string{"ProjectDeliveryManager"}
	case "sales":
		roleKeys = []string{"SalesEngineer"}
	case "all":
		roleKeys = []string{"ProjectManager", "ProjectDeliveryManager"}
	default:
		roleKeys = []string{"ProjectManager", "ProjectDeliveryManager"}
	}

	db := s.Dao.DB.Table("sys_user")
	db = db.LeftJoin("sys_user_role", "sys_user_role.user_id = sys_user.id")
	db = db.LeftJoin("sys_role", "sys_role.id = sys_user_role.role_id")
	db = db.LeftJoin("sys_dept", "sys_dept.id = sys_user.dept_id")
	db = db.Where("sys_user.deleted_time IS NULL")
	db = db.Where("sys_user.status", "10")
	db = db.WhereIn("sys_role.role_key", roleKeys)
	db = db.Distinct()

	var records []*opsdev.ProjectManagerRsp
	err := db.Fields(
		"sys_user.id as user_id",
		"sys_user.user_name",
		"sys_user.nick_name",
		"sys_dept.dept_name",
	).Scan(&records)
	if err != nil {
		return nil, err
	}

	return records, nil
}

// GetContractProducts 获取合同产品列表
func (s *ProjectInventoryService) GetContractProducts(contractId int) ([]*opsdev.ContractProductRsp, error) {
	productDao := contractdao.NewCtrContractProductDao(s.Tenant)
	db := productDao.Where("contract_id", contractId)
	db = db.Where("deleted_time IS NULL")
	db = db.Order("id ASC")

	var records []*opsdev.ContractProductRsp
	err := db.Scan(&records)
	if err != nil {
		return nil, err
	}

	return records, nil
}

// GetProductLines 获取产品线列表
func (s *ProjectInventoryService) GetProductLines() []g.Map {
	return []g.Map{
		{"dictValue": "10", "dictLabel": "Biobank"},
		{"dictValue": "20", "dictLabel": "LIMS"},
		{"dictValue": "30", "dictLabel": "CellBank"},
		{"dictValue": "40", "dictLabel": "MCS"},
		{"dictValue": "50", "dictLabel": "信息化设备"},
		{"dictValue": "60", "dictLabel": "MedCare"},
		{"dictValue": "70", "dictLabel": "咨询服务"},
	}
}

// GetProjectStatusList 获取项目状态列表
func (s *ProjectInventoryService) GetProjectStatusList() []g.Map {
	return []g.Map{
		{"dictValue": "10", "dictLabel": "待指派"},
		{"dictValue": "20", "dictLabel": "交付中"},
		{"dictValue": "30", "dictLabel": "暂停"},
		{"dictValue": "40", "dictLabel": "交付完成"},
		{"dictValue": "50", "dictLabel": "验收"},
		{"dictValue": "90", "dictLabel": "作废"},
	}
}

// GetDeliveryNodes 获取交付节点列表
func (s *ProjectInventoryService) GetDeliveryNodes() []g.Map {
	return []g.Map{
		{"dictValue": "05", "dictLabel": "已指派"},
		{"dictValue": "10", "dictLabel": "内部启动会"},
		{"dictValue": "15", "dictLabel": "外部启动会"},
		{"dictValue": "20", "dictLabel": "制定计划"},
		{"dictValue": "30", "dictLabel": "项目实施"},
		{"dictValue": "40", "dictLabel": "完成部署"},
		{"dictValue": "50", "dictLabel": "试运行"},
		{"dictValue": "60", "dictLabel": "交付完成"},
	}
}

// Export 导出项目清单
func (s *ProjectInventoryService) Export(ctx context.Context, req *opsdev.ProjectInventoryExportReq) (content *opsdev.ProjectInventoryExportContent, err error) {
	db := s.Dao.DB.Table("ops_delivery_project")
	db = db.LeftJoin("ctr_contract", "ctr_contract.id = ops_delivery_project.contract_id")
	db = db.LeftJoin("cust_customer", "cust_customer.id = ops_delivery_project.cust_id")
	db = db.Where("ops_delivery_project.deleted_time IS NULL")

	if req.ContractNo != "" {
		db = db.WhereLike("ctr_contract.contract_code", "%"+req.ContractNo+"%")
	}
	if req.ProjectName != "" {
		db = db.WhereLike("ops_delivery_project.project_name", "%"+req.ProjectName+"%")
	}
	if req.ProductLine != "" {
		db = db.Where("ops_delivery_project.product_line", req.ProductLine)
	}
	if req.ProjectStatus != "" {
		db = db.Where("ops_delivery_project.project_status", req.ProjectStatus)
	}
	if req.DeliveryNode != "" {
		db = db.Where("ops_delivery_project.delivery_node", req.DeliveryNode)
	}
	if req.DeliveryUserId > 0 {
		db = db.Where("ops_delivery_project.delivery_user_id", req.DeliveryUserId)
	}
	if req.SalesUserId > 0 {
		db = db.Where("ops_delivery_project.sales_user_id", req.SalesUserId)
	}
	if req.PlanDeliveryTimeStart != "" {
		db = db.WhereGTE("ops_delivery_project.plan_delivery_time", req.PlanDeliveryTimeStart)
	}
	if req.PlanDeliveryTimeEnd != "" {
		db = db.WhereLTE("ops_delivery_project.plan_delivery_time", req.PlanDeliveryTimeEnd)
	}

	if s.userInfo.UserName != "admin" {
		hasPermission := false
		for _, role := range s.userInfo.Roles {
			if role == "SysAdmin" || role == "ResearchAndDevelopmentDirector" ||
				role == "ResearchAndDevelopmentSupervisor" || role == "QualityAssuranceSupervisor" ||
				role == "GeneralManager" || role == "SalesDirector" || role == "SaleAssociate" {
				hasPermission = true
				break
			}
		}
		if !hasPermission {
			userIds := []int{s.userInfo.Id}
			for _, role := range s.userInfo.Roles {
				if role == "ProjectManager" || role == "ProjectDeliveryManager" {
					db = db.Where("ops_delivery_project.delivery_user_id IN (?)", userIds)
					hasPermission = true
					break
				}
				if role == "SalesEngineer" {
					db = db.Where("ops_delivery_project.sales_user_id IN (?)", userIds)
					hasPermission = true
					break
				}
			}
			if !hasPermission {
				db = db.Where("1 = 0")
			}
		}
	}

	db = db.Order("ops_delivery_project.created_time DESC")
	var records []*opsdev.ProjectInventoryRsp
	err = db.Fields(
		"ops_delivery_project.id",
		"ops_delivery_project.project_name",
		"ops_delivery_project.product_line",
		"ops_delivery_project.project_status",
		"ops_delivery_project.delivery_node",
		"ops_delivery_project.delivery_user_name",
		"ops_delivery_project.sales_user_name",
		"ops_delivery_project.plan_delivery_time",
		"ops_delivery_project.plan_accept_time",
		"ops_delivery_project.contract_no",
		"ctr_contract.contract_amount",
		"ctr_contract.collected_amount",
		"ops_delivery_project.cust_name",
	).Scan(&records)
	if err != nil {
		return nil, err
	}

	productLines := s.GetProductLines()
	projectStatuses := s.GetProjectStatusList()
	deliveryNodes := s.GetDeliveryNodes()

	productLineMap := make(map[string]string)
	for _, pl := range productLines {
		productLineMap[pl["dictValue"].(string)] = pl["dictLabel"].(string)
	}
	projectStatusMap := make(map[string]string)
	for _, ps := range projectStatuses {
		projectStatusMap[ps["dictValue"].(string)] = ps["dictLabel"].(string)
	}
	deliveryNodeMap := make(map[string]string)
	for _, dn := range deliveryNodes {
		deliveryNodeMap[dn["dictValue"].(string)] = dn["dictLabel"].(string)
	}

	exportDataList := make([]map[string]interface{}, 0, len(records))
	for _, item := range records {
		planDeliveryTime := item.PlanDeliveryTime
		if len(planDeliveryTime) > 10 {
			planDeliveryTime = planDeliveryTime[:10]
		}
		planAcceptTime := item.PlanAcceptTime
		if len(planAcceptTime) > 10 {
			planAcceptTime = planAcceptTime[:10]
		}

		exportData := map[string]interface{}{
			"contractNo":       item.ContractNo,
			"projectName":      item.ProjectName,
			"productLine":      productLineMap[item.ProductLine],
			"projectStatus":    projectStatusMap[item.ProjectStatus],
			"deliveryNode":     deliveryNodeMap[item.DeliveryNode],
			"deliveryUserName": item.DeliveryUserName,
			"salesUserName":    item.SalesUserName,
			"planDeliveryTime": planDeliveryTime,
			"planAcceptTime":   planAcceptTime,
			"contractAmount":   fmt.Sprintf("%.2f", item.ContractAmount),
			"collectedAmount":  fmt.Sprintf("%.2f", item.CollectedAmount),
			"custName":         item.CustName,
		}
		exportDataList = append(exportDataList, exportData)
	}

	contentBase64, err := service.CommonExportExcel(ctx, "项目清单", opsdev.ProjectInventoryExportData{}, exportDataList)
	if err != nil {
		return nil, err
	}

	exportContent := new(opsdev.ProjectInventoryExportContent)
	exportContent.Content = contentBase64
	return exportContent, nil
}