eta_mini_crm_ht/services/product.go

package services

import (
	"errors"
	"eta/eta_mini_crm_ht/models"
	"eta/eta_mini_crm_ht/utils"
	"time"
)

func GetUnsetProductCountByCondition(productType string, permissionIds []int, condition string, pars []interface{}) (total int, ids []int, err error) {
	setIds, err := models.GetProductSourceIdsByProductType(productType)
	if err != nil {
		return
	}
	switch productType {
	case "report":
		return getReportIdsByCondition(setIds, permissionIds, condition, pars)
	case "media":
		return getMediaIdsByCondition(setIds, permissionIds, condition, pars)
	default:
		err = errors.New("不支持的产品类型查询")
		return
	}
}

func getReportIdsByCondition(setIds []int, permissionIds []int, condition string, pars []interface{}) (total int, filterIds []int, err error) {
	permissionNames, err := models.GetPermissionNamesWithRiskLevel(permissionIds)
	var conditionHT string
	var conditionETA string
	if err != nil {
		utils.FileLog.Error("查询品种名称失败", err.Error)
		return
	}
	if len(permissionNames) > 0 {
		conditionHT = "(source ='HT' and plate_name in (" + utils.GetOrmReplaceHolder(len(permissionNames)) + "))"
	}
	filterPermissionIds, err := models.FilterPermissionIdsWithRiskLevel(permissionIds)
	if err != nil {
		utils.FileLog.Error("过滤品种Id失败", err.Error)
		return
	}
	classifyCondition := utils.GetOrmReplaceHolder(len(filterPermissionIds))
	var classifyPars []interface{}
	classifyPars = append(classifyPars, filterPermissionIds)
	classifyIds, err := models.GetClassifyIdsByPermissionIds(classifyCondition, classifyPars)
	if len(classifyIds) > 0 {
		conditionETA = "(source ='ETA' and classify_id in (" + utils.GetOrmReplaceHolder(len(classifyIds)) + "))"
	}
	if conditionHT != "" {
		if conditionETA != "" {
			condition += "and ( " + conditionHT + " or " + conditionETA + ")"
			pars = append(pars, permissionNames)
			pars = append(pars, classifyIds)
		} else {
			condition += "and " + conditionHT
			pars = append(pars, permissionNames)
		}
	} else {
		if conditionETA != "" {
			condition += "and " + conditionETA
			pars = append(pars, classifyIds)
		}
	}
	var ids []int
	ids, err = models.GetReportIdsByCondition(condition, pars)
	if err != nil {
		utils.FileLog.Error("查询报告Id失败", err.Error)
		return
	}
	filterMap := make(map[int]bool)
	for _, filterId := range setIds {
		filterMap[filterId] = true
	}
	for _, id := range ids {
		if !filterMap[id] {
			filterIds = append(filterIds, id)
			total++
		}
	}
	return
}

func getMediaIdsByCondition(setIds []int, permissionIds []int, condition string, pars []interface{}) (total int, filterIds []int, err error) {
	filterPermissionIds, err := models.FilterPermissionIdsWithRiskLevel(permissionIds)
	if err != nil {
		utils.FileLog.Error("过滤品种id失败", err.Error)
		return
	}
	mediaIds, err := models.GetMediaIdIdsByPermissionId(filterPermissionIds)
	if err != nil {
		utils.FileLog.Error("过滤媒体Id失败", err.Error)
		return
	}
	if condition != "" {
		condition += "and id in (" + utils.GetOrmReplaceHolder(len(mediaIds)) + ")"
		pars = append(pars, mediaIds)
		mediaIds, err = models.GetMediaIdsByCondition(condition, pars)
	}
	filterMap := make(map[int]bool)
	for _, filterId := range setIds {
		filterMap[filterId] = true
	}
	for _, id := range mediaIds {
		if !filterMap[id] {
			total++
			filterIds = append(filterIds, id)
		}
	}
	return
}

func GetUnsetProductByCondition(productType string, ids []int, sortCondition string, startSize int, pageSize int) (products []*ProductView, err error) {
	switch productType {
	case "report":
		var reports []models.Report
		reports, err = models.GetReportByIds(sortCondition, ids, startSize, pageSize)
		if err != nil {
			utils.FileLog.Error("查询报告产品失败", err.Error)
			return
		}
		for _, report := range reports {
			products = append(products, &ProductView{
				ProductName:   report.Title,
				SourceId:      report.Id,
				ProductType:   "report",
				PublishedTime: report.PublishedTime,
			})
		}
		return
	case "media":
		var medias []models.Media
		medias, err = models.GetMediasById(ids, sortCondition, startSize, pageSize)
		if err != nil {
			utils.FileLog.Error("查询报告产品失败", err.Error)
			return
		}
		for _, media := range medias {
			products = append(products, &ProductView{
				ProductName:   media.MediaName,
				SourceId:      media.Id,
				ProductType:   media.SourceType,
				PublishedTime: media.PublishedTime.Format(time.DateTime),
			})
		}
		return
	default:
		err = errors.New("不支持的产品类型查询")
		return
	}
}

type ProductView struct {
	ProductName   string
	SourceId      int
	ProductType   string
	RiskLevel     string
	PublishedTime string
}