youngee_b_api/service/project.go

package service

import (
	"context"
	"fmt"
	"strconv"
	"strings"
	"time"
	"youngee_b_api/db"
	"youngee_b_api/model/common_model"
	"youngee_b_api/model/gorm_model"
	"youngee_b_api/model/http_model"
	"youngee_b_api/pack"
	"youngee_b_api/util"

	"github.com/gin-gonic/gin"

	"github.com/issue9/conv"
	"github.com/sirupsen/logrus"
)

var Project *project

type project struct {
}

func (*project) Create(ctx context.Context, newProject http_model.CreateProjectRequest, enterpriseID int64) (*http_model.CreateProjectData, error) {
	// build gorm_model.ProjectInfo
	// 查询关联商品信息
	product, err := db.GetProductByID(ctx, newProject.ProductID)
	if err != nil {
		return nil, err
	}
	AutoTaskID, err := db.GetLastAutoTaskID()
	if err != nil {
		return nil, err
	}
	AutoDefaultID, err := db.GetLastAutoDefaultID()
	if err != nil {
		return nil, err
	}
	// 按照品牌名-商品名对项目进行命名
	projectName := product.BrandName + "-" + product.ProductName
	//feeForm := fmt.Sprintf("[")
	feeFrom := []string{}
	for _, strategy := range newProject.RecruitStrategys {
		//if strategy.StrategyID
		feeFrom = append(feeFrom, strconv.FormatInt(strategy.FeeForm, 10))
		//feeForm += string(strategy.StrategyID)
	}
	feeFroms := strings.Join(feeFrom, ",")
	fmt.Printf("创建项目new %+v", newProject)
	RecruitDdl, _ := time.ParseInLocation("2006-01-02 15:04:05", newProject.RecruitDdl, time.Local)
	projectInfo := gorm_model.ProjectInfo{}
	if newProject.ProjectType == int64(1) {
		projectInfo = gorm_model.ProjectInfo{
			ProjectName:     projectName,
			ProjectStatus:   1,
			ProjectType:     newProject.ProjectType,
			TalentType:      newProject.TalentType,
			ProjectPlatform: newProject.ProjectPlatform,
			ProjectForm:     newProject.ProjectForm,
			RecruitDdl:      &RecruitDdl,
			ProjectDetail:   newProject.ProjectDetail,
			ContentType:     newProject.ContentType,
			EnterpriseID:    enterpriseID,
			ProductID:       newProject.ProductID,
			FeeForm:         feeFroms,
			AutoTaskID:      conv.MustInt64(AutoTaskID),
			AutoDefaultID:   conv.MustInt64(AutoDefaultID),
			IsRead:          0,
		}
	} else {
		projectInfo = gorm_model.ProjectInfo{
			ProjectName:     projectName,
			ProjectStatus:   1,
			ProjectType:     newProject.ProjectType,
			TalentType:      "[]",
			ProjectPlatform: newProject.ProjectPlatform,
			ProjectForm:     newProject.ProjectForm,
			ProjectDetail:   newProject.ProjectDetail,
			ContentType:     newProject.ContentType,
			EnterpriseID:    enterpriseID,
			ProductID:       newProject.ProductID,
			FeeForm:         feeFroms,
			AutoTaskID:      conv.MustInt64(AutoTaskID),
			AutoDefaultID:   conv.MustInt64(AutoDefaultID),
		}
	}
	// db create ProjectInfo
	projectID, err := db.CreateProject(ctx, projectInfo)
	if err != nil {
		return nil, err
	}
	if len(newProject.ProjectPhotos) != 0 {
		// build []gorm_model.ProjectPhoto
		projectPhotos := []gorm_model.ProjectPhoto{}
		for _, photo := range newProject.ProjectPhotos {
			projectPhoto := gorm_model.ProjectPhoto{
				PhotoUrl:  photo.PhotoUrl,
				PhotoUid:  photo.PhotoUid,
				ProjectID: *projectID,
			}
			projectPhotos = append(projectPhotos, projectPhoto)
		}
		// db create ProjectPhoto
		err = db.CreateProjectPhoto(ctx, projectPhotos)
		if err != nil {
			return nil, err
		}
	}
	// build
	if newProject.ProjectType == int64(1) {
		recruitStrategys := []gorm_model.RecruitStrategy{}
		for _, strategy := range newProject.RecruitStrategys { // 查询对应定价策略
			pricingStrategy, err := db.GetPricingStrategy(ctx, strategy.FollowersLow, strategy.FollowersUp, strategy.FeeForm, newProject.ProjectPlatform)
			if err != nil {
				return nil, err
			}
			// fmt.Printf(" %+v 对应定价策略 %+v", strategy, pricingStrategy)
			// 根据定价策略计算达人所见报价
			if strategy.FeeForm == 2 {
				strategy.TOffer = strategy.Offer * (1 - conv.MustFloat64(pricingStrategy.ServiceRate)/1000)
			}
			recruitStrategy := gorm_model.RecruitStrategy{
				FeeForm:       strategy.FeeForm,
				StrategyID:    strategy.StrategyID,
				FollowersLow:  strategy.FollowersLow,
				FollowersUp:   strategy.FollowersUp,
				RecruitNumber: strategy.RecruitNumber,
				ServiceCharge: strategy.ServiceCharge,
				Offer:         strategy.Offer,
				TOffer:        strategy.TOffer,
				ProjectID:     *projectID,
			}
			recruitStrategys = append(recruitStrategys, recruitStrategy)
		}
		err = db.CreateRecruitStrategy(ctx, recruitStrategys)
		if err != nil {
			return nil, err
		}
	}
	res := &http_model.CreateProjectData{
		ProjectID: *projectID,
	}
	fmt.Printf("%+v", res)
	return res, nil
}
func (*project) Update(ctx context.Context, newProject http_model.UpdateProjectRequest, enterpriseID int64) (*http_model.UpdateProjectData, error) {
	fmt.Println("RecruitDdl：", newProject.RecruitDdl)
	RecruitDdl, _ := time.ParseInLocation("2006-01-02 15:04:05", newProject.RecruitDdl, time.Local)
	oldProject, err3 := db.GetProjectDetail(ctx, conv.MustInt64(newProject.ProjectID))
	if err3 != nil {
		return nil, err3
	}
	feeFrom := []string{}
	for _, strategy := range newProject.RecruitStrategys {
		//if strategy.StrategyID
		feeFrom = append(feeFrom, strconv.FormatInt(strategy.FeeForm, 10))
		//feeForm += string(strategy.StrategyID)
	}
	feeFroms := strings.Join(feeFrom, ",")
	project := gorm_model.ProjectInfo{
		ProjectID:     conv.MustInt64(newProject.ProjectID),
		RecruitDdl:    &RecruitDdl,
		TalentType:    newProject.TalentType,
		ContentType:   conv.MustInt64(newProject.ContentType),
		ProjectDetail: newProject.ProjectDetail,
		ProjectForm:   conv.MustInt64(newProject.ProjectForm),
		EnterpriseID:  enterpriseID,
		ProjectStatus: conv.MustInt64(newProject.ProjectStatus),
		FeeForm:       feeFroms,
	}
	projectID, err := db.UpdateProject(ctx, project)
	if err != nil {
		return nil, err
	}
	// 删除该项目之前的所有图片
	err = db.DeleteProjectPhotoByProjecttID(ctx, *projectID)
	if err != nil {
		return nil, err
	}
	fmt.Printf("照片:\t %+v", newProject.ProjectPhotos)
	if len(newProject.ProjectPhotos) != 0 {
		// 新增图片
		projectPhotos := []gorm_model.ProjectPhoto{}
		for _, photo := range newProject.ProjectPhotos {
			projectPhoto := gorm_model.ProjectPhoto{
				ProjectID: project.ProjectID,
				PhotoUrl:  photo.PhotoUrl,
				PhotoUid:  photo.PhotoUid,
			}
			projectPhotos = append(projectPhotos, projectPhoto)
		}
		err = db.CreateProjectPhoto(ctx, projectPhotos)
		if err != nil {
			return nil, err
		}
	}
	// 删除该项目之前的所有策略
	err = db.DeleteRecruitStrategyByProjectID(ctx, *projectID)
	if err != nil {
		return nil, err
	}
	//fmt.Printf("策略:\t %+v", newProject.RecruitStrategys)
	if newProject.RecruitStrategys != nil {
		// 新增策略
		RecruitStrategys := []gorm_model.RecruitStrategy{}
		for _, Strategy := range newProject.RecruitStrategys {
			// 查询对应定价策略
			pricingStrategy, err := db.GetPricingStrategy(ctx, Strategy.FollowersLow, Strategy.FollowersUp, Strategy.FeeForm, oldProject.ProjectPlatform)
			if err != nil {
				return nil, err
			}
			// 根据定价策略计算达人所见报价
			if Strategy.FeeForm == 2 {
				Strategy.TOffer = Strategy.Offer * (1 - conv.MustFloat64(pricingStrategy.ServiceRate)/1000)
			}

			RecruitStrategy := gorm_model.RecruitStrategy{
				FeeForm:       conv.MustInt64(Strategy.FeeForm),
				StrategyID:    conv.MustInt64(Strategy.StrategyID),
				FollowersLow:  conv.MustInt64(Strategy.FollowersLow),
				FollowersUp:   conv.MustInt64(Strategy.FollowersUp),
				RecruitNumber: conv.MustInt64(Strategy.RecruitNumber),
				ServiceCharge: Strategy.ServiceCharge,
				Offer:         Strategy.Offer,
				TOffer:        Strategy.TOffer,
				ProjectID:     project.ProjectID,
			}
			fmt.Printf("Offer:\t %+v", Strategy.Offer)
			RecruitStrategys = append(RecruitStrategys, RecruitStrategy)
		}
		err = db.CreateRecruitStrategy(ctx, RecruitStrategys)
		if err != nil {
			return nil, err
		}
	}
	res := &http_model.UpdateProjectData{
		ProjectID: *projectID,
	}
	return res, nil
}

func (*project) Delete(ctx context.Context, projectID int64) (*http_model.DeleteProjectData, error) {
	// 删除该项目之前的所有图片
	err := db.DeleteProjectPhotoByProjecttID(ctx, projectID)
	if err != nil {
		return nil, err
	}
	// 删除该项目之前的所有策略
	err = db.DeleteRecruitStrategyByProjectID(ctx, projectID)
	if err != nil {
		return nil, err
	}
	//删除项目
	NewProjectID, err1 := db.DeleteProject(ctx, projectID)
	if err1 != nil {
		return nil, err1
	}
	res := &http_model.DeleteProjectData{
		ProjectID: *NewProjectID,
	}
	return res, nil
}

func (*project) GetFullProjectList(ctx context.Context, enterpriseID int64, pageSize, pageNum int32, condition *common_model.ProjectCondition) (*http_model.FullProjectListData, error) {

	fullProjects, total, err := db.GetFullProjectList(ctx, enterpriseID, pageSize, pageNum, condition)
	if err != nil {
		logrus.WithContext(ctx).Errorf("[project service] call GetFullProjectList error,err:%+v", err)
		return nil, err
	}
	fullProjectListData := new(http_model.FullProjectListData)
	fullProjectListData.FullProjectPreview = pack.MGormFullProjectToHttpFullProjectPreview(fullProjects)
	fullProjectListData.Total = conv.MustString(total)
	return fullProjectListData, nil
}

func (*project) GetProjectDraftList(ctx context.Context, enterpriseID int64, pageSize, pageNum int32, condition *common_model.ProjectCondition) (*http_model.ProjectDraftListData, error) {

	ProjectDrafts, total, err := db.GetProjectDraftList(ctx, enterpriseID, pageSize, pageNum, condition)
	if err != nil {
		logrus.WithContext(ctx).Errorf("[project service] call GetProjectDraftList error,err:%+v", err)
		return nil, err
	}
	ProjectDraftListData := new(http_model.ProjectDraftListData)
	ProjectDraftListData.ProjectDraftPreview = pack.MGormProjectDraftToHttpProjectDraftPreview(ProjectDrafts)
	ProjectDraftListData.Total = conv.MustString(total)
	return ProjectDraftListData, nil
}

func (*project) GetProjectTaskList(ctx context.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TaskConditions) (*http_model.ProjectTaskListData, error) {
	projectTasks, total, err := db.GetProjectTaskList(ctx, projectID, pageSize, pageNum, conditions)
	if err != nil {
		logrus.WithContext(ctx).Errorf("[project service] call GetProjectTaskList error,err:%+v", err)
		return nil, err
	}
	projectTaskListData := new(http_model.ProjectTaskListData)
	projectTaskListData.ProjectTaskPreview = pack.MGormProjectTaskToHttpProjectTaskPreview(projectTasks)
	projectTaskListData.Total = conv.MustString(total)
	return projectTaskListData, nil
}

func (*project) GetPorjectDetail(ctx context.Context, projectID int64) (*http_model.ShowProjectData, error) {

	project, err := db.GetProjectDetail(ctx, projectID)
	if err != nil {
		logrus.WithContext(ctx).Errorf("[project service] call GetPorjectDetail error,err:%+v", err)
		return nil, err
	}
	enterprise, err := db.GetEnterpriseByEnterpriseID(ctx, project.EnterpriseID)
	// fmt.Println("%+v", enterprise.UserID)
	if err != nil {
		logrus.WithContext(ctx).Errorf("[project service] call GetEnterpriseByEnterpriseID error,err:%+v", err)
		return nil, err
	}
	user, err := db.GetUserByID(ctx, enterprise.UserID)
	if err != nil {
		logrus.WithContext(ctx).Errorf("[project service] call GetUserByID error,err:%+v", err)
		return nil, err
	}
	// fmt.Println("%+v", user.Phone)
	//var RecruitStrategys []http_model.ShowRecruitStrategy
	ProjectDetail := http_model.ShowProjectData{
		ProjectID:       conv.MustString(project.ProjectID),
		ProjectName:     conv.MustString(project.ProjectName),
		ProjectStatus:   conv.MustString(project.ProjectStatus),
		ProjectType:     conv.MustString(project.ProjectType),
		ProjectPlatform: conv.MustString(project.ProjectPlatform),
		ProjectForm:     conv.MustString(project.ProjectForm),
		TalentType:      conv.MustString(project.TalentType),
		RecruitDdl:      util.GetTimePoionter(project.RecruitDdl),
		ContentType:     conv.MustString(project.ContentType),
		ProjectDetail:   conv.MustString(project.ProjectDetail),
		ProductID:       conv.MustString(project.ProductID),
		EnterpriseID:    conv.MustString(project.EnterpriseID),
		Balance:         conv.MustString(enterprise.Balance),
		FailReason:      conv.MustString(project.FailReason),
		CreateAt:        util.GetTimePoionter(project.CreatedAt),
		UpdateAt:        util.GetTimePoionter(project.UpdatedAt),
		Phone:           user.Phone,
		FinishAt:        util.GetTimePoionter(project.FinishAt),
		PassAt:          util.GetTimePoionter(project.PassAt),
		PayAt:           util.GetTimePoionter(project.PayAt),
	}
	Strategys, err := db.GetRecruitStrategys(ctx, projectID)
	fmt.Println("招募策略：", Strategys)
	if err != nil {
		logrus.WithContext(ctx).Error()
		return nil, err
	}
	for _, strategy := range Strategys {
		RecruitStrategy := http_model.ShowRecruitStrategy{
			RecruitStrategyID: conv.MustString(strategy.RecruitStrategyID),
			FeeForm:           conv.MustString(strategy.FeeForm),
			StrategyID:        conv.MustString(strategy.StrategyID),
			FollowersLow:      conv.MustString(strategy.FollowersLow),
			FollowersUp:       conv.MustString(strategy.FollowersUp),
			RecruitNumber:     conv.MustString(strategy.RecruitNumber),
			Offer:             conv.MustString(strategy.Offer),
			ServiceCharge:     conv.MustString(strategy.ServiceCharge),
			SelectedNumber:    strategy.SelectedNumber,
			WaitingNumber:     strategy.WaitingNumber,
			DeliveredNumber:   strategy.DeliveredNumber,
			SignedNumber:      strategy.SignedNumber,
		}
		ProjectDetail.RecruitStrategys = append(ProjectDetail.RecruitStrategys, RecruitStrategy)
	}
	Photos, err := db.GetProjectPhoto(ctx, projectID)
	if err != nil {
		logrus.WithContext(ctx).Error()
		return nil, err
	}
	for _, Photo := range Photos {
		ProjectPhoto := http_model.ShowProjectPhoto{
			PhotoUrl: Photo.PhotoUrl,
			PhotoUid: Photo.PhotoUid,
		}
		ProjectDetail.ProjectPhotos = append(ProjectDetail.ProjectPhotos, ProjectPhoto)
	}
	return &ProjectDetail, nil
}

func (*project) GetTaskLogisticsList(ctx context.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TalentConditions) (*http_model.TaskLogisticsListData, error) {
	TaskLogisticss, total, err := db.GetTaskLogisticsList(ctx, projectID, pageSize, pageNum, conditions)
	if err != nil {
		logrus.WithContext(ctx).Errorf("[project service] call GetTaskLogisticsList error,err:%+v", err)
		return nil, err
	}
	TaskLogisticsListData := new(http_model.TaskLogisticsListData)
	TaskLogisticsListData.TaskLogisticsPreview = pack.MGormTaskLogisticsInfoListToHttpTaskLogisticsPreviewList(TaskLogisticss)
	TaskLogisticsListData.Total = conv.MustString(total)
	return TaskLogisticsListData, nil
}

func (*project) ChangeTaskStatus(ctx *gin.Context, data http_model.ProjectChangeTaskStatusRequest) interface{} {
	RecruitStrategyIDs, err := db.ChangeTaskStatus(ctx, data.TaskIds, data.TaskStatus)
	if err != nil {
		logrus.WithContext(ctx).Errorf("[project service] call ChangeTaskStatus error,err:%+v", err)
		return err
	}
	if data.TaskStatus == "2" {
		err = db.CalculateSelectedNumberByRecruitStrategyID(ctx, RecruitStrategyIDs, 1)
		if err != nil {
			logrus.WithContext(ctx).Errorf("[project service] call ChangeTaskStatus error,err:%+v", err)
			return err
		}
	} else {
		err = db.CalculateSelectedNumberByRecruitStrategyID(ctx, RecruitStrategyIDs, -1)
		if err != nil {
			logrus.WithContext(ctx).Errorf("[project service] call ChangeTaskStatus error,err:%+v", err)
			return err
		}
	}
	return nil
}

func (*project) ChangeSpecialTaskStatus(ctx *gin.Context, data http_model.ProjectChangeTaskStatusRequest) interface{} {
	err := db.ChangeSpecialTaskStatus(ctx, data.TaskIds, data.TaskStatus, data.TaskStage)
	if err != nil {
		logrus.WithContext(ctx).Errorf("[project service] call ChangeSpecialTaskStatus error,err:%+v", err)
		return err
	}
	return nil
}

func (p *project) GetTaskScriptList(ctx *gin.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TalentConditions) (*http_model.TaskScriptListData, error) {
	TaskScripts, total, err := db.GetTaskScriptList(ctx, projectID, pageSize, pageNum, conditions)
	if err != nil {
		logrus.WithContext(ctx).Errorf("[project service] call GetTaskScriptList error,err:%+v", err)
		return nil, err
	}
	TaskScriptListData := new(http_model.TaskScriptListData)
	TaskScriptListData.TaskScriptPreview = pack.MGormTaskScriptInfoListToHttpTaskScriptPreviewList(TaskScripts)
	TaskScriptListData.Total = conv.MustString(total)
	return TaskScriptListData, nil
}

func (p *project) GetTaskSketchList(ctx *gin.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TalentConditions) (*http_model.TaskSketchListData, error) {
	TaskSketchs, total, err := db.GetTaskSketchList(ctx, projectID, pageSize, pageNum, conditions)
	if err != nil {
		logrus.WithContext(ctx).Errorf("[project service] call GetTaskSketchList error,err:%+v", err)
		return nil, err
	}
	TaskSketchListData := new(http_model.TaskSketchListData)
	TaskSketchListData.TaskSketchPreview = pack.MGormTaskSketchInfoListToHttpTaskSketchPreviewList(TaskSketchs)
	TaskSketchListData.Total = conv.MustString(total)
	return TaskSketchListData, nil
}

func (p *project) GetTaskLinkList(ctx *gin.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TalentConditions) (*http_model.TaskLinkListData, error) {
	TaskLinks, total, err := db.GetTaskLinkList(ctx, projectID, pageSize, pageNum, conditions)
	if err != nil {
		logrus.WithContext(ctx).Errorf("[project service] call GetTaskLinkList error,err:%+v", err)
		return nil, err
	}
	TaskLinkListData := new(http_model.TaskLinkListData)
	TaskLinkListData.TaskLinkPreview = pack.MGormTaskLinkInfoListToHttpTaskLinkPreviewList(TaskLinks)
	TaskLinkListData.Total = conv.MustString(total)
	return TaskLinkListData, nil
}

func (p *project) GetTaskDataList(ctx *gin.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TalentConditions) (*http_model.TaskDataListData, error) {
	TaskDatas, total, err := db.GetTaskDataList(ctx, projectID, pageSize, pageNum, conditions)
	if err != nil {
		logrus.WithContext(ctx).Errorf("[project service] call GetTaskDataList error,err:%+v", err)
		return nil, err
	}
	TaskDataListData := new(http_model.TaskDataListData)
	TaskDataListData.TaskDataPreview = pack.MGormTaskDataInfoListToHttpTaskDataPreviewList(TaskDatas)
	TaskDataListData.Total = conv.MustString(total)
	return TaskDataListData, nil
}

func (p *project) GetTaskFinishList(ctx *gin.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TalentConditions) (*http_model.TaskFinishListData, error) {
	TaskFinishs, total, err := db.GetTaskFinishList(ctx, pageSize, pageNum, conditions)
	if err != nil {
		logrus.WithContext(ctx).Errorf("[project service] call GetTaskFinishList error,err:%+v", err)
		return nil, err
	}
	TaskFinishListData := new(http_model.TaskFinishListData)
	TaskFinishListData.TaskFinishPreview = pack.MGormTaskFinishInfoListToHttpTaskFinishPreviewList(TaskFinishs)
	TaskFinishListData.Total = conv.MustString(total)
	return TaskFinishListData, nil
}

func (p *project) GetServiceCharge(ctx *gin.Context, data http_model.GetServiceChargeRequest) (*http_model.ServiceChargeData, error) {
	pricingStrategy, err := db.GetPricingStrategy(ctx, data.FollowersLow, data.FollowersUp, data.FeeForm, data.Platform)
	if err != nil {
		return nil, err
	}
	serviceFee := http_model.ServiceChargeData{
		ServiceCharge: pricingStrategy.ServiceCharge,
	}
	return &serviceFee, nil
}