younggee_s_api/db/s_project.go

package db

import (
	"context"
	"fmt"
	"github.com/sirupsen/logrus"
	"reflect"
	"time"
	"youngee_b_api/model/common_model"
	"youngee_b_api/model/gorm_model"
	"youngee_b_api/model/http_model"
	"youngee_b_api/util"
)

// CreateSProject 新建服务商加入商单后的种草任务
func CreateSProject(ctx context.Context, newSProject gorm_model.SProjectInfo) (int, error) {
	db := GetWriteDB(ctx)
	err := db.Create(&newSProject).Error
	if err != nil {
		return 0, err
	}
	return newSProject.SProjectId, nil
}

// GetSProjectList 根据服务商ID和其他附加条件查询种草任务列表
func GetSProjectList(ctx context.Context, supplierId int, pageSize, pageNum int32, condition *common_model.SProjectCondition) ([]*gorm_model.SProjectInfo, int64, error) {
	db := GetReadDB(ctx)

	// 1. 根据服务商id过滤
	db = db.Debug().Model(gorm_model.SProjectInfo{}).Where("supplier_id = ? and project_status <> 1", supplierId)

	// 2. 根据SProjectCondition条件过滤
	conditionType := reflect.TypeOf(condition).Elem()
	conditionValue := reflect.ValueOf(condition).Elem()
	for i := 0; i < conditionType.NumField(); i++ {
		field := conditionType.Field(i)
		tag := field.Tag.Get("condition")
		value := conditionValue.FieldByName(field.Name)
		if (tag == "project_id" || tag == "project_name") && !util.IsBlank(value) {
			db = db.Where(fmt.Sprintf("project_id like '%%%v%%' or project_name like '%%%v%%'", value.Interface(), value.Interface()))
		} else if !util.IsBlank(value) && tag != "updated_at" {
			db = db.Where(fmt.Sprintf("%s = ?", tag), value.Interface())
		}
	}

	// 3. 确定查询总数和返回当前页数据
	var total int64
	var SProjects []*gorm_model.SProjectInfo
	if err := db.Count(&total).Error; err != nil {
		logrus.WithContext(ctx).Errorf("[GetFullProjectList] error query mysql total, err:%+v", err)
		return nil, 0, err
	}
	limit := pageSize
	offset := pageSize * pageNum // assert pageNum start with 0
	err := db.Order("s_project_id desc").Limit(int(limit)).Offset(int(offset)).Find(&SProjects).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[GetFullProjectList] error query mysql total, err:%+v", err)
		return nil, 0, err
	}
	return SProjects, total, nil
}

// GetSProjectDetail 查询服务商种草任务详情
func GetSProjectDetail(ctx context.Context, sProjectId int) (*gorm_model.SProjectInfo, error) {
	db := GetReadDB(ctx)
	var sProjectInfo *gorm_model.SProjectInfo
	// 1. 根据服务商种草任务id过滤
	err := db.Model(gorm_model.SProjectInfo{}).Where("s_project_id = ?", sProjectId).Find(&sProjectInfo).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[GetSProjectDetail] error query mysql, err:%+v", err)
		return nil, err
	}
	return sProjectInfo, nil
}

// GetSpecialProjectList 根据服务商ID和其他附加条件查询定向种草任务列表
func GetSpecialProjectList(ctx context.Context, supplierId int, pageSize, pageNum int32, condition *common_model.SpecialSProjectCondition, tag int) ([]*gorm_model.SProjectInfo, int64, error) {
	db := GetReadDB(ctx)

	// 1. 根据服务商id过滤
	if tag == 1 {
		db = db.Debug().Model(gorm_model.SProjectInfo{}).Where("supplier_id = ? and project_status = 8 and project_type = 2", supplierId)
	} else {
		db = db.Debug().Model(gorm_model.SProjectInfo{}).Where("supplier_id = ? and project_type = 2 and s_project_status = 2", supplierId)
	}

	// 2. 根据SProjectCondition条件过滤
	conditionType := reflect.TypeOf(condition).Elem()
	conditionValue := reflect.ValueOf(condition).Elem()
	for i := 0; i < conditionType.NumField(); i++ {
		field := conditionType.Field(i)
		tag := field.Tag.Get("condition")
		value := conditionValue.FieldByName(field.Name)
		if (tag == "project_id" || tag == "project_name") && !util.IsBlank(value) {
			db = db.Where(fmt.Sprintf("project_id like '%%%v%%' or project_name like '%%%v%%'", value.Interface(), value.Interface()))
		} else if !util.IsBlank(value) && tag != "updated_at" {
			db = db.Where(fmt.Sprintf("%s = ?", tag), value.Interface())
		}
	}

	// 3. 确定查询总数和返回当前页数据
	var total int64
	var SProjects []*gorm_model.SProjectInfo
	if err := db.Count(&total).Error; err != nil {
		logrus.WithContext(ctx).Errorf("[GetFullProjectList] error query mysql total, err:%+v", err)
		return nil, 0, err
	}
	limit := pageSize
	offset := pageSize * pageNum // assert pageNum start with 0
	err := db.Order("s_project_id desc").Limit(int(limit)).Offset(int(offset)).Find(&SProjects).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[GetFullProjectList] error query mysql total, err:%+v", err)
		return nil, 0, err
	}
	return SProjects, total, nil
}

// UpdateSProjectStatus 更新SProject信息
func UpdateSProjectStatus(ctx context.Context, newSProject *http_model.SpecialSProjectAddToListRequest) error {
	db := GetWriteDB(ctx)
	var operatorType int
	if newSProject.SubAccountId == 0 {
		operatorType = 1
	} else {
		operatorType = 2
	}
	var currentTime time.Time
	currentTime = time.Now()
	whereCondition := gorm_model.SProjectInfo{SProjectId: newSProject.SProjectId}
	sProjectInfo := gorm_model.SProjectInfo{
		SProjectStatus: newSProject.SProjectStatus,
		SubAccountId:   newSProject.SubAccountId,
		OperatorType:   operatorType,
		AgreeTime:      &currentTime,
	}
	err := db.Model(&gorm_model.SProjectInfo{}).Where(whereCondition).Updates(sProjectInfo).Error
	if err != nil {
		return err
	}
	return nil
}

// CreateSpecialStrategy 创建定向种草任务服务商修改后的招募策略
func CreateSpecialStrategy(ctx context.Context, recruitStrategy []gorm_model.RecruitStrategy) error {
	db := GetWriteDB(ctx)
	fmt.Println("CreateSpecialStrategy", recruitStrategy)
	err := db.Create(&recruitStrategy).Error
	if err != nil {
		return err
	}
	return nil
}

// UpdateSProjectStrategyStatus 修改SProject的招募策略修改标志
func UpdateSProjectStrategyStatus(ctx context.Context, req *http_model.SpecialAddStrategyRequest) error {
	db := GetWriteDB(ctx)
	whereCondition := gorm_model.SProjectInfo{SProjectId: req.SProjectId}
	var createStrategyId int
	var createStrategyType int
	if req.SubAccountId == 0 {
		createStrategyId = req.SupplierId
		createStrategyType = 1
	} else {
		createStrategyType = 2
		createStrategyId = req.SubAccountId
	}
	sProjectInfo := gorm_model.SProjectInfo{
		CreateStrategyId:   createStrategyId,
		StrategyStatus:     1,
		CreateStrategyType: createStrategyType,
	}
	err := db.Model(&gorm_model.SProjectInfo{}).Where(whereCondition).Updates(sProjectInfo).Error
	if err != nil {
		return err
	}
	return nil
}

// GetFullSProjectBillList 服务商种草任务账单
func GetFullSProjectBillList(ctx context.Context, supplierId int, projectType int, ProjectPlatform int, projectStatus int, pageSize, pageNum int32) ([]*gorm_model.SProjectInfo, int64, error) {
	db := GetReadDB(ctx).Model(gorm_model.SProjectInfo{}).Where("supplier_id = ? and project_type = ?", supplierId, projectType)

	// 仅当 ProjectPlatform 非零时才过滤
	if ProjectPlatform != 0 {
		db = db.Where("project_platform = ?", ProjectPlatform)
	}

	// 仅当 projectStatus 非零时才过滤
	if projectStatus != 0 {
		db = db.Where("project_status = ?", projectStatus)
	}

	// 查询总数
	var total int64
	if err := db.Count(&total).Error; err != nil {
		logrus.WithContext(ctx).Errorf("[GetFullProjectList] error query mysql total, err:%+v", err)
		return nil, 0, err
	}

	// 查询当前页数据
	var SProjects []*gorm_model.SProjectInfo
	limit := pageSize
	offset := pageSize * pageNum // 假设 pageNum 从 0 开始
	err := db.Order("s_project_id desc").Limit(int(limit)).Offset(int(offset)).Find(&SProjects).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[GetFullProjectList] error query mysql, err:%+v", err)
		return nil, 0, err
	}

	return SProjects, total, nil
}

// FindSProjectByProjectIdAndSupplierId 根据种草任务ID和服务商ID查找种草任务是否加入商单
func FindSProjectByProjectIdAndSupplierId(ctx context.Context, projectId string, supplierId int) (int64, error) {
	db := GetWriteDB(ctx)
	whereCondition := gorm_model.SProjectInfo{
		ProjectId:  projectId,
		SupplierId: supplierId,
	}
	var total int64
	err := db.Debug().Model(gorm_model.SProjectInfo{}).Where(whereCondition).Count(&total).Error
	if err != nil {
		return 0, err
	}
	return total, nil
}

func GetSProjectTaskList(ctx context.Context, sProjectId int, condition string, pageSize, pageNum int32) ([]*gorm_model.YoungeeTaskInfo, int64, error) {
	db := GetReadDB(ctx)

	// 基础查询条件 - 必须有s_project_id
	db = db.Debug().Model(gorm_model.YoungeeTaskInfo{}).Where("s_project_id = ?", sProjectId)

	// 如果condition不为空
	if condition != "" {
		// db = db.Where("talent_id = ? OR talent_name LIKE ?", condition, "%"+condition+"%")
		db = db.Where("talent_id = ?", condition)
	}

	var taskInfos []*gorm_model.YoungeeTaskInfo

	// 查询总数
	var totalTask int64
	if err := db.Count(&totalTask).Error; err != nil {
		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
		return nil, 0, err
	}

	// 查询该页数据
	limit := pageSize
	offset := pageSize * (pageNum - 1) // 假设pageNum从1开始
	err := db.Order("task_id").Limit(int(limit)).Offset(int(offset)).Find(&taskInfos).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql data, err:%+v", err)
		return nil, 0, err
	}

	return taskInfos, totalTask, nil
}

// GetUnifiedTaskList 获取统一的账单列表（合并本地生活和种草任务）
func GetUnifiedTaskList(ctx context.Context, supplierId int, pageSize, pageNum int32, status int, condition string) ([]*http_model.SupplierAmountBillListData, int64, error) {
	db := GetReadDB(ctx).Debug()

	var statusCondition string
	if status == 10 {
		statusCondition = "= 10"
	} else {
		statusCondition = "< 10"
	}

	localLifeSQL := fmt.Sprintf(`
        SELECT
            s_local_id AS s_id,
            local_id AS id,
            local_name AS name,
            3 AS type,
            local_platform AS platform,
            apply_num,
            recruit_num,
            settle_num,
            enterprise_id,
            supplier_id,
            service_charge,
            create_time,
            finish_time,
            store_id AS product_id
        FROM younggee_s_local_life_info
        WHERE supplier_id = ? AND task_status %s
    `, statusCondition)

	projectSQL := fmt.Sprintf(`
        SELECT
            s_project_id AS s_id,
            project_id AS id,
            project_name AS name,
            1 AS type,
            project_platform AS platform,
            apply_num,
            recruit_num,
            settle_num,
            enterprise_id,
            supplier_id,
            service_charge,
            create_time,
            finish_time,
            product_id
        FROM younggee_s_project_info
        WHERE supplier_id = ? AND project_status %s
    `, statusCondition)

	var total int64
	countSQL := "SELECT COUNT(*) FROM ((" + localLifeSQL + ") UNION ALL (" + projectSQL + ")) AS combined"
	if err := db.Raw(countSQL, supplierId, supplierId).Scan(&total).Error; err != nil {
		logrus.WithContext(ctx).Errorf("[GetUnifiedTaskList] error query total count, err:%+v", err)
		return nil, 0, err
	}

	offset := pageSize * pageNum
	paginatedSQL := `
        SELECT * FROM ((` + localLifeSQL + `) UNION ALL (` + projectSQL + `)) AS combined
        ORDER BY create_time DESC
        LIMIT ? OFFSET ?
    `
	var tasks []*http_model.SupplierAmountBillListData
	if err := db.Raw(paginatedSQL, supplierId, supplierId, pageSize, offset).Scan(&tasks).Error; err != nil {
		logrus.WithContext(ctx).Errorf("[GetUnifiedTaskList] error query data, err:%+v", err)
		return nil, 0, err
	}

	return tasks, total, nil
}