youngee_b_api/app/dao/project_dao.go

package dao

import (
	"errors"
	"fmt"
	"gorm.io/gorm"
	"time"
	"youngee_b_api/app/entity"
	"youngee_b_api/app/vo"
)

type ProjectDAO struct{}

// 根据projectId获取project信息
func (d ProjectDAO) GetProjectById(projectId string) (*entity.Project, error) {
	var project entity.Project
	err := Db.Where("project_id = ?", projectId).Find(&project).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, nil
		} else {
			return nil, err
		}
	}
	return &project, err
}

// 根据projectId获取违约状态id
func (d ProjectDAO) GetAutoDefaultId(projectId string) (*int64, error) {
	var autoDefaultId int64
	err := Db.Model(&entity.Project{}).Where("project_id = ?", projectId).Select("auto_default_id").Find(&autoDefaultId).Error
	if err != nil {
		return nil, nil
	}
	return &autoDefaultId, nil
}

// 根据enterpriseId查询指定某天的所有带货数据
func (d ProjectDAO) GetProjectListOfDay(enterpriseId string, date time.Time) ([]entity.Project, error) {
	var projects []entity.Project
	// 构建查询
	query := Db.Model(&entity.Project{})
	if enterpriseId != "" {
		query = query.Where("enterprise_id = ?", enterpriseId)
	}
	// 将日期部分提取出来进行匹配
	query = query.Where("DATE(created_at) = ?", date.Format("2006-01-02"))
	err := query.Find(&projects).Error
	return projects, err
}

// 创建种草任务
func (d ProjectDAO) CreateProject(project entity.Project) error {
	err := Db.Omit("auto_fail_at", "auto_script_break_at", "auto_sketch_break_at", "pay_at", "pass_at", "finish_at", "submit_at").Create(&project).Error
	if err != nil {
		return err
	}
	return nil
}

// 更新种草任务
func (d ProjectDAO) UpdateProject(project entity.Project) error {
	err := Db.Model(&entity.Project{}).Where("project_id = ?", project.ProjectId).Updates(project).Error
	if err != nil {
		return err
	}
	return nil
}

// 更新开票状态字段
func (d ProjectDAO) UpdateInvoiceStatus(projectIDs []string) error {
	err := Db.Debug().Model(&entity.Project{}).Where("project_id IN ?", projectIDs).Updates(entity.Project{InvoiceStatus: 1}).Error
	if err != nil {
		return err
	}
	return nil
}

// 获取种草任务列表
func (d ProjectDAO) GetProjectPreviews(param *vo.ProjectSearchParam) ([]vo.ReProjectTaskPreview, int64, error) {
	var reProjectTaskPreviews []vo.ReProjectTaskPreview
	var projects []entity.Project
	var total int64
	query := Db.Model(&entity.Project{})
	// 动态添加查询条件
	if param.SubAccountId == 0 {
		if param.EnterpriseId == "" {
			return reProjectTaskPreviews, 0, errors.New("enterpriseId is empty")
		}
		query = query.Where("enterprise_id = ?", param.EnterpriseId)
	} else {
		query = query.Where("sub_account_id = ?", param.SubAccountId)
	}
	if param.ProjectType != 0 {
		query = query.Where("project_type = ?", param.ProjectType)
	}
	if param.ProjectPlatform != 0 {
		query = query.Where("project_platform = ?", param.ProjectPlatform)
	}
	if param.ProjectStatus != 0 {
		query = query.Where("project_status = ?", param.ProjectStatus)
	}
	if param.ProjectForm != 0 {
		query = query.Where("project_form = ?", param.ProjectForm)
	}
	if param.ContentType != 0 {
		query = query.Where("content_type = ?", param.ContentType)
	}
	if param.ProjectId != "" {
		query = query.Where("project_id = ?", param.ProjectId)
	}
	if param.ProjectName != "" {
		query = query.Where("project_name LIKE ?", "%"+param.ProjectName+"%")
	}
	query.Count(&total)
	query = query.Select("enterprise_id, sub_account_id, project_id, project_platform, project_status, estimated_cost, project_form, content_type, need_review, need_quality, need_calculate, product_id, tools")
	offset := (param.Page - 1) * param.PageSize
	if param.Order == 1 {
		if err := query.Order("created_at asc").Offset(offset).Limit(param.PageSize).Find(&projects).Error; err != nil {
			return nil, 0, err
		}
	} else {
		if err := query.Order("created_at desc").Offset(offset).Limit(param.PageSize).Find(&projects).Error; err != nil {
			return nil, 0, err
		}
	}
	for _, project := range projects {
		reProjectTaskPreview := vo.ReProjectTaskPreview{
			EnterpriseId:    project.EnterpriseID,
			SubAccountId:    project.SubAccountId,
			ProjectId:       project.ProjectId,
			ProjectPlatform: project.ProjectPlatform,
			ProjectStatus:   project.ProjectStatus,
			EstimatedCost:   project.EstimatedCost,
			ProjectForm:     project.ProjectForm,
			ContentType:     project.ContentType,
			NeedReview:      project.NeedReview,
			NeedQuality:     project.NeedQuality,
			NeedCalculate:   project.NeedCalculate,
			ProductId:       project.ProductID,
			Tools:           project.Tools,
		}
		reProjectTaskPreviews = append(reProjectTaskPreviews, reProjectTaskPreview)
	}

	return reProjectTaskPreviews, total, nil
}

// 删除种草任务
func (d ProjectDAO) DeleteProject(projectId string) (*string, error) {
	if projectId == "" {
		return &projectId, nil
	}
	err := Db.Where("project_id = ?", projectId).Delete(&entity.Project{}).Error
	if err != nil {
		return nil, err
	}
	return &projectId, nil
}

// 获取草稿箱——电商带货任务列表
func (d ProjectDAO) GetProjectDraftList(param *vo.ProjectDraftParam) ([]vo.ReProjectTaskPreview, int64, error) {
	var reProjectTaskPreviews []vo.ReProjectTaskPreview
	var projects []entity.Project
	var total int64
	query := Db.Model(&entity.Project{}).Where("project_status = ?", 1)
	// 动态添加查询条件
	if param.SubAccountId == 0 {
		if param.EnterpriseId == "" {
			return reProjectTaskPreviews, 0, errors.New("enterpriseId is empty")
		}
		query = query.Where("enterprise_id = ?", param.EnterpriseId)
	} else {
		query = query.Where("sub_account_id = ?", param.SubAccountId)
	}
	if param.ProjectType != 0 {
		query = query.Where("project_type = ?", param.ProjectType)
	}
	if param.ProjectPlatform != 0 {
		query = query.Where("project_platform = ?", param.ProjectPlatform)
	}
	query.Count(&total)
	query = query.Select("enterprise_id, sub_account_id, project_id, project_platform, project_type, created_at, product_id")
	offset := (param.Page - 1) * param.PageSize
	if err := query.Order("created_at asc").Offset(offset).Limit(param.PageSize).Find(&projects).Error; err != nil {
		return nil, 0, err
	}
	for _, project := range projects {
		reProjectTaskPreview := vo.ReProjectTaskPreview{
			EnterpriseId:    project.EnterpriseID,
			SubAccountId:    project.SubAccountId,
			ProjectId:       project.ProjectId,
			ProjectPlatform: project.ProjectPlatform,
			ProjectType:     project.ProjectType,
			CreatedAt:       project.CreatedAt.Format("2006-01-02 15:04:05"),
			ProductId:       project.ProductID,
		}
		reProjectTaskPreviews = append(reProjectTaskPreviews, reProjectTaskPreview)
	}

	return reProjectTaskPreviews, total, nil
}

// 获取公开种草中全部指定状态值的项目
func (d ProjectDAO) GetProjectList(value int64, fieldName string) ([]*entity.Project, error) {
	var projectInfos []*entity.Project
	err := Db.Model(entity.Project{}).Where(fmt.Sprintf("project_type = ? AND %s = ? ", fieldName), 1, value).Find(&projectInfos).Error
	if err != nil {
		return nil, err
	}
	return projectInfos, nil
}

// 违约管理——违约公开种草任务列表
func (d ProjectDAO) GetProjectPublicList(param *vo.DefaultSearchParam) ([]vo.ReTaskDefaultPublic, int64, error) {
	var reTaskDefaultPublics []vo.ReTaskDefaultPublic
	var projects []entity.Project
	var total int64
	query := Db.Model(&entity.Project{}).Where("project_type = ?", 1)
	// 动态添加查询条件
	if param.SubAccountId == 0 {
		if param.EnterpriseId == "" {
			return reTaskDefaultPublics, 0, errors.New("enterpriseId is empty")
		}
		query = query.Where("enterprise_id = ?", param.EnterpriseId)
	} else {
		query = query.Where("sub_account_id = ?", param.SubAccountId)
	}
	if param.Platform != 0 {
		query = query.Where("project_platform = ?", param.Platform)
	}
	if param.TaskId != "" {
		query = query.Where("project_id = ?", param.TaskId)
	}
	query.Count(&total)
	query = query.Select("enterprise_id, sub_account_id, project_id, project_platform, project_form, content_type, product_id")
	offset := (param.Page - 1) * param.PageSize
	if err := query.Order("created_at asc").Offset(offset).Limit(param.PageSize).Find(&projects).Error; err != nil {
		return nil, 0, err
	}
	for _, project := range projects {
		reTaskDefaultPublic := vo.ReTaskDefaultPublic{
			EnterpriseId: project.EnterpriseID,
			SubAccountId: project.SubAccountId,
			TaskId:       project.ProjectId,
			Platform:     project.ProjectPlatform,
			TaskForm:     project.ProjectForm,
			ContentType:  project.ContentType,
			TaskType:     1,
			ProductId:    project.ProductID,
		}
		reTaskDefaultPublics = append(reTaskDefaultPublics, reTaskDefaultPublic)
	}

	return reTaskDefaultPublics, total, nil
}

// 违约管理——违约定向种草任务列表
func (d ProjectDAO) GetProjectTargetList(param *vo.DefaultSearchParam) ([]vo.ReTaskDefaultTarget, int64, error) {
	var reTaskDefaultTargets []vo.ReTaskDefaultTarget
	var projects []entity.Project
	var total int64
	query := Db.Model(&entity.Project{}).Where("project_type = ?", 2)
	// 动态添加查询条件
	if param.SubAccountId == 0 {
		if param.EnterpriseId == "" {
			return reTaskDefaultTargets, 0, errors.New("enterpriseId is empty")
		}
		query = query.Where("enterprise_id = ?", param.EnterpriseId)
	} else {
		query = query.Where("sub_account_id = ?", param.SubAccountId)
	}
	if param.Platform != 0 {
		query = query.Where("project_platform = ?", param.Platform)
	}
	if param.TaskId != "" {
		query = query.Where("project_id = ?", param.TaskId)
	}
	query.Count(&total)
	query = query.Select("enterprise_id, sub_account_id, project_id, project_platform, tools, content_type, product_id")
	offset := (param.Page - 1) * param.PageSize
	if err := query.Order("created_at asc").Offset(offset).Limit(param.PageSize).Find(&projects).Error; err != nil {
		return nil, 0, err
	}
	for _, project := range projects {
		reTaskDefaultPublic := vo.ReTaskDefaultTarget{
			EnterpriseId: project.EnterpriseID,
			SubAccountId: project.SubAccountId,
			TaskId:       project.ProjectId,
			Platform:     project.ProjectPlatform,
			Tools:        project.Tools,
			ContentType:  project.ContentType,
			TaskType:     1,
			ProductId:    project.ProductID,
		}
		reTaskDefaultTargets = append(reTaskDefaultTargets, reTaskDefaultPublic)
	}

	return reTaskDefaultTargets, total, nil
}

// 获取品牌种草冻结中的任务
func (d ProjectDAO) GetProjectFrozenList(enterpriseId string) ([]*entity.Project, error) {
	var projects []*entity.Project
	query := Db.Debug().Model(entity.Project{})
	query.Select("project_id, product_id, enterprise_id, sub_account_id, project_platform, payment_amount, pay_at") // 冻结金额：payment_amount
	err := query.Where(fmt.Sprintf("enterprise_id = ? AND (project_status between 7 and 8) "), enterpriseId).Find(&projects).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return projects, nil
		} else {
			return nil, err
		}
	}
	return projects, nil
}

// 获取品牌种草冻结解除的任务
func (d ProjectDAO) GetProjectFrozenCancelList(enterpriseId string) ([]*entity.Project, error) {
	var projects []*entity.Project
	query := Db.Debug().Model(entity.Project{})
	query.Select("project_id, product_id, enterprise_id, sub_account_id, project_platform, settlement_amount, pay_at") // 解冻金额：settlement_amount
	err := query.Where(fmt.Sprintf("enterprise_id = ? AND (project_status between 9 and 10) "), enterpriseId).Find(&projects).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return projects, nil
		} else {
			return nil, err
		}
	}
	return projects, nil
}

// 获取品牌种草账单列表
func (d ProjectDAO) GetBillProjectPreviews(param *vo.ProjectSearchParam) ([]vo.ReBillProjectTaskPreview, int64, error) {
	var reBillProjectTaskPreviews []vo.ReBillProjectTaskPreview
	var projects []entity.Project
	var total int64
	query := Db.Model(&entity.Project{})
	// 动态添加查询条件
	if param.SubAccountId == 0 {
		if param.EnterpriseId == "" {
			return reBillProjectTaskPreviews, 0, errors.New("enterpriseId is empty")
		}
		query = query.Where("enterprise_id = ?", param.EnterpriseId)
	} else {
		query = query.Where("sub_account_id = ?", param.SubAccountId)
	}
	if param.ProjectType != 0 {
		query = query.Where("project_type = ?", param.ProjectType)
	}
	if param.ProjectPlatform != 0 {
		query = query.Where("project_platform = ?", param.ProjectPlatform)
	}
	if param.ProjectStatus != 0 {
		query = query.Where("project_status = ?", param.ProjectStatus)
	}
	if param.ProjectId != "" {
		query = query.Where("project_id = ?", param.ProjectId)
	}
	if param.ProjectName != "" {
		query = query.Where("project_name LIKE ?", "%"+param.ProjectName+"%")
	}
	query.Count(&total)
	query = query.Select("enterprise_id, sub_account_id, project_id, project_platform, project_status, estimated_cost, project_form, content_type, product_id, settlement_amount")
	offset := (param.Page - 1) * param.PageSize
	if err := query.Order("created_at asc").Offset(offset).Limit(param.PageSize).Find(&projects).Error; err != nil {
		return nil, 0, err
	}
	for _, project := range projects {
		reBillProjectTaskPreview := vo.ReBillProjectTaskPreview{
			EnterpriseId:    project.EnterpriseID,
			SubAccountId:    project.SubAccountId,
			ProjectId:       project.ProjectId,
			ProjectPlatform: project.ProjectPlatform,
			ProjectStatus:   project.ProjectStatus,
			ProjectForm:     project.ProjectForm,
			ContentType:     project.ContentType,
			ProductId:       project.ProductID,
			EstimatedCost:   project.EstimatedCost,    // 应付金额
			CashAmount:      project.SettlementAmount, //实际结算金额
		}
		reBillProjectTaskPreviews = append(reBillProjectTaskPreviews, reBillProjectTaskPreview)
	}

	return reBillProjectTaskPreviews, total, nil
}