fonchain-approval-fork/pkg/service/approval.go

package service

import (
	"context"
	"errors"
	"fmt"
	"github.com/fonchain_enterprise/fonchain-approval-fork/api/approval"
	"github.com/fonchain_enterprise/fonchain-approval-fork/pkg/common/page"
	"github.com/fonchain_enterprise/fonchain-approval-fork/pkg/m"
	"github.com/fonchain_enterprise/fonchain-approval-fork/pkg/model"
	"github.com/fonchain_enterprise/fonchain-approval-fork/pkg/serializer"
	"gorm.io/gorm"
)

type ApprovalProvider struct {
	approval.UnimplementedApprovalServer
}

func (a *ApprovalProvider) Create(ctx context.Context, in *approval.CreateRequest) (*approval.ApprovalResponse, error) {
	response := &approval.ApprovalResponse{}

	//下载单子只能下载一次
	if in.Type == model.TypeBundlePayPrice {
		if model.ExistPayApproval(in) == true {
			return response, errors.New("该画展宝已经有审批中或者审批通过的提交")
		}
	}

	if model.LeaveBalanceUsefulTime[in.Type] == model.OnceAYear || model.LeaveBalanceUsefulTime[in.Type] == model.Once {
		if model.ExistLeaveApplyApproval(in) == true {
			if model.LeaveBalanceUsefulTime[in.Type] == model.OnceAYear {
				return response, errors.New(m.ErrorOnceAYear)
			} else if model.LeaveBalanceUsefulTime[in.Type] == model.Once {
				return response, errors.New(m.ErrorOnce)
			}
		}
	}

	//if in.Type == model.TypeMakeUp {
	//	if model.CheckMakeUpApplyApproval(in) == true {
	//		return response, errors.New(m.ErrorOnce)
	//	}
	//}

	entity, err := model.StoreApproval(in)
	if err != nil {
		return response, err
	}

	if entity != nil {
		response.ID = entity.ID
	}
	response.Success = true

	return response, err
}

func (a *ApprovalProvider) UpdateExhibitionApplyID(ctx context.Context, in *approval.UpdateEhApplyIDRequest) (*approval.UpdateEhApplyIDResponse, error) {

	response := &approval.UpdateEhApplyIDResponse{}
	model.DB.Model(&model.Exhibition{}).Where(&model.Exhibition{ApprovalID: in.ApprovalID}).Update("apply_id", in.ApplyId)
	return response, nil

}

func (a *ApprovalProvider) UsedNumByUser(ctx context.Context, in *approval.UsedNumByUserRequest) (*approval.UsedNumByUserResponse, error) {

	response := &approval.UsedNumByUserResponse{}

	total := model.GetExhibitionNumByUser(in.Domain, in.SubmitterID)

	response.Total = 0
	if total > 0 {
		response.Total = uint64(total)
	}

	return response, nil

}

func (a *ApprovalProvider) Update(ctx context.Context, in *approval.CreateRequest) (*approval.ApprovalResponse, error) {

	response := &approval.ApprovalResponse{}

	entity, err := model.UpdateApproval(in)

	if err == nil {
		response.ID = entity.ID
		response.Success = true
	}

	return response, err
}

func (a *ApprovalProvider) NowLevelByInfo(ctx context.Context, in *approval.NowLevelByInfoRequest) (*approval.WorkFlowResponse, error) {

	response := &approval.WorkFlowResponse{}
	var approvalObj *model.Approval

	if err := model.DB.First(&approvalObj, in.ApprovalID).Error; err != nil {
		return response, err
	}

	workFlow, err1 := model.GetNowWorkFlowByApprovalId(approvalObj.ID)

	if err1 != nil {
		return response, err1
	}
	response.ID = workFlow.ID
	response.UserID = workFlow.UserId
	response.Status = uint64(workFlow.Status)

	return response, nil
}

func (a *ApprovalProvider) SetStatus(ctx context.Context, in *approval.StatusRequest) (*approval.StatusResponse, error) {

	response := &approval.StatusResponse{}

	var approvalObj *model.Approval
	var err error

	if in.Status == model.StatusDoing {
		return response, errors.New("status code wrong")
	}

	if err := model.DB.First(&approvalObj, in.ID).Error; err != nil {
		return response, err
	}

	if approvalObj.Status != model.StatusDoing {
		return response, errors.New(m.ErrorWrongStatus)
	}

	if err := model.UpdateLeaveBalance(approvalObj, in.LeaveBalance); err != nil {
		return response, errors.New(m.ErrorUpdateLeaveBalance)
	}

	// 审批人审批内容
	if in.Status == model.StatusFail {
		err = approvalObj.Refuse(in.Reply, in.WorkFlowId)
	} else {
		err = approvalObj.Pass(in.Reply, in.WorkFlowId)
	}

	return response, err
}

func (a *ApprovalProvider) Remove(ctx context.Context, in *approval.RemoveRequest) (*approval.RemoveResponse, error) {

	response := &approval.RemoveResponse{}

	for _, ID := range in.IDs {

		err := model.DB.Transaction(func(tx *gorm.DB) error {

			var err error
			var entity *model.Approval

			// 确定有数据则执行删除
			if err = model.DB.Where(&model.Approval{Domain: &in.Domain}).
				Find(&entity, ID).Error; err != nil {
				return err
			}

			//删除子关联数据
			if err = entity.DeleteContent(); err != nil {
				return err
			}

			if err = model.DB.Where(&model.Approval{Domain: &in.Domain}).
				Delete(&model.Approval{}, ID).Error; err != nil {
				return err
			}

			//删除流
			if err = model.DB.Where(&model.ApprovalWorkFlow{ApprovalID: ID}).
				Delete(&model.ApprovalWorkFlow{}).Error; err != nil {
				return err
			}

			return nil
		})

		if err != nil {
			return nil, err
		}
	}

	response.Success = true

	return response, nil

}

func (a *ApprovalProvider) ChangeBundlePay(ctx context.Context, in *approval.ChangeBundlePayRequest) (*approval.CommonResponse, error) {
	response := &approval.CommonResponse{}

	m := &model.BundlePayPrice{Status: in.Status}

	model.DB.Model(&model.BundlePayPrice{}).Where(&model.BundlePayPrice{ID: in.ID}).Updates(&m)

	return response, nil
}

func (a *ApprovalProvider) IsExistPayRight(ctx context.Context, in *approval.IsExistPayRightRequest) (*approval.IsExistPayRightResponse, error) {
	response := &approval.IsExistPayRightResponse{IsPass: false}

	var err error
	var count int64

	subQuery1 := model.DB.Model(&model.Approval{}).Where(&model.Approval{SubmitterID: in.UserId, Type: model.TypeBundlePayPrice, Status: model.StatusOk}).
		Select("id")

	model.DB.Model(&model.BundlePayPrice{}).Where("approval_id in (?)", subQuery1).Where(&model.BundlePayPrice{ShowUid: in.ShowUid}).Count(&count)

	if count >= 1 {
		response.IsPass = true
	}

	return response, err
}

func (a *ApprovalProvider) Detail(ctx context.Context, in *approval.DetailRequest) (*approval.CreateRequest, error) {
	response := &approval.CreateRequest{}
	var err error
	var entity *model.Approval
	var briefEntity *model.Approval

	if err := model.DB.Model(&model.Approval{}).First(&briefEntity, in.ID).Error; err != nil {
		return response, err
	}

	entity, err = briefEntity.GetApprovalInfo()

	response = serializer.BuildApproval(entity, in.UserId)

	return response, err
}

func (a *ApprovalProvider) Information(ctx context.Context, in *approval.InformationRequest) (*approval.InformationResponse, error) {

	return model.ApprovalInfo(in)

}

func (a *ApprovalProvider) Viewed(ctx context.Context, in *approval.ViewedRequest) (*approval.ApprovalResponse, error) {

	response := &approval.ApprovalResponse{}
	var err error

	if err = model.Viewed(in); err != nil {
		return response, err
	}

	response.ID = in.ID
	response.Success = true

	return response, err

}

func (a *ApprovalProvider) MySubmit(ctx context.Context, in *approval.ListRequest) (*approval.ListResponse, error) {

	//获取人的 部门角色（1、管理组 2、超级管理 3、Leader角色）
	response := &approval.ListResponse{}

	var list []*model.Approval
	var count int64

	list, count = model.MySubmitApprovals(in)

	response.Count = uint64(count)
	response.Data = serializer.BuildApprovals(list, in.UserID)
	return response, nil
}

func (a *ApprovalProvider) MyWork(ctx context.Context, in *approval.ListRequest) (*approval.ListResponse, error) {

	//获取人的 部门角色（1、管理组 2、超级管理 3、Leader角色）
	response := &approval.ListResponse{}

	var list []*model.Approval
	var count int64

	if in.Status == 0 && in.ApprovedBossId == 0 {
		list, count = model.MyAllWorkApprovals(in)
	} else if in.Status == 4 && in.ApprovedBossId == 0 {
		list, count = model.MyReadApprovals(in)
	} else {
		list, count = model.MyWorkApprovals(in)
	}

	response.Count = uint64(count)
	response.Data = serializer.BuildApprovals(list, in.UserID)
	return response, nil
}

// UpdateSetting 设置配置抄送者和审核者
func (a *ApprovalProvider) UpdateSetting(ctx context.Context, in *approval.SettingRequest) (*approval.SettingResponse, error) {

	var err error
	response := &approval.SettingResponse{}
	var setting model.ApprovalSetting
	copyUsers := model.FormatCopyUsers(in.CopyUsers)
	approvalUsers := model.FormatApproveUsers(in.ApprovalUsers)
	if approvalUsers == nil && len(approvalUsers) == 0 {
		return response, errors.New("必须要有抄送人")
	}

	//首次
	if err := model.DB.Model(&model.ApprovalSetting{}).
		Where(&model.ApprovalSetting{Domain: in.Domain, KeyWord: in.KeyWord}).
		First(&setting).Error; err != nil {

		setting = model.ApprovalSetting{
			KeyWord:       in.KeyWord,
			CopyUsers:     copyUsers,
			ApprovalUsers: approvalUsers,
			Domain:        in.Domain,
		}

		err = model.DB.Save(&setting).Error

	} else {
		setting.KeyWord = in.KeyWord
		setting.CopyUsers = copyUsers
		setting.ApprovalUsers = approvalUsers
		//setting.ApproverID = in.ApproverID
		//setting.ApproverName = in.ApproverName

		err = model.DB.Where(&model.ApprovalSetting{Domain: in.Domain, KeyWord: in.KeyWord}).Updates(&setting).Error

		fmt.Println(copyUsers == nil)
		fmt.Println(copyUsers)
		if copyUsers == nil { //空数组
			model.DB.Exec("UPDATE approval_setting SET copy_users = '[]' WHERE id = ?", setting.ID)
			//model.DB.Where(&model.ApprovalSetting{Domain: in.Domain, KeyWord: in.KeyWord}).Update("copy_users", "[]")
		}

	}

	if err == nil {
		response.ID = setting.ID
		response.Success = true
	}

	return response, err
}

func (a *ApprovalProvider) DetailSetting(ctx context.Context, in *approval.DetailSettingRequest) (*approval.SettingRequest, error) {

	response := &approval.SettingRequest{}
	var setting model.ApprovalSetting
	if in.KeyWord == "" {
		return response, nil
	}

	if err := model.DB.Model(&model.ApprovalSetting{}).Preload("ApprovalType").
		Where(&model.ApprovalSetting{Domain: in.Domain, KeyWord: in.KeyWord}).
		First(&setting).Error; err != nil {
		response.Domain = in.Domain
	} else {
		response = serializer.BuildSetting(&setting)
	}

	return response, nil
}

func (a *ApprovalProvider) CreateType(ctx context.Context, in *approval.CreateTypeRequest) (*approval.TypeResponse, error) {
	response := &approval.TypeResponse{}

	fmt.Println("创建类型123123:", in.String())
	//创建分组
	groupId, err := model.GetGroupIdByName(in.GroupName, in.Domain)
	if err != nil {
		return response, err
	}

	keyWord := model.KeyWordFromTitle(in.Title)

	if model.DataExist(in.Domain, keyWord, in.Title) == true {
		return response, errors.New(m.ErrorAlreadyExist)
	}

	typeObj := model.ApprovalType{
		KeyWord: keyWord,
		Title:   in.Title,
		Domain:  in.Domain,
		Remark:  in.Remark,
		GroupId: groupId,
		KeyJson: model.ToKeyInfos(in.KeyInfos),
	}

	if err := model.DB.Create(&typeObj).Error; err != nil {
		return response, err
	}

	response.ID = typeObj.ID
	response.Domain = typeObj.Domain

	return response, nil
}

func (a *ApprovalProvider) DetailType(ctx context.Context, in *approval.TypeResponse) (*approval.CreateTypeRequest, error) {
	response := &approval.CreateTypeRequest{}
	var typeObj model.ApprovalType
	var err error

	if in.Keyword != "" {
		err = model.DB.Preload("ApprovalTypeGroup").Where(&model.ApprovalType{KeyWord: in.Keyword}).First(&typeObj).Error
	} else {
		err = model.DB.Preload("ApprovalTypeGroup").First(&typeObj, in.ID).Error
	}

	if err != nil {
		return nil, err
	}

	response = serializer.BuildType(&typeObj)

	return response, nil
}

func (a *ApprovalProvider) UpdateType(ctx context.Context, in *approval.CreateTypeRequest) (*approval.TypeResponse, error) {
	response := &approval.TypeResponse{}
	var typeObj model.ApprovalType

	if err := model.DB.First(&typeObj, in.ID).Error; err != nil {
		return nil, err
	}

	if typeObj.Title != in.Title && model.IsSystemKeyWork(in.Title) == true {
		return response, errors.New(m.ErrorChangeType)
	}

	typeObj.Title = in.Title
	typeObj.Remark = in.Remark
	if len(in.KeyInfos) > 0 {
		typeObj.KeyJson = model.ToKeyInfos(in.KeyInfos)
	}

	if err := model.DB.Save(&typeObj).Error; err != nil {
		return nil, err
	}
	response.ID = in.ID
	response.Domain = in.Domain

	return response, nil
}

func (a *ApprovalProvider) AllType(ctx context.Context, in *approval.CommonRequest) (*approval.AllTypeResponse, error) {

	response := &approval.AllTypeResponse{}
	var list []*model.ApprovalType
	var count int64

	modelObj := model.DB.Model(&model.ApprovalType{}).Preload("ApprovalTypeGroup").
		Where(&model.ApprovalType{Domain: in.Domain, GroupId: in.GroupId}).Order("id desc")
	modelObj.Count(&count)

	if in.Page != 0 && in.PageSize != 0 {
		modelObj.Limit(int(in.PageSize)).Offset(page.GetOffset(in.Page, in.PageSize))
	}

	modelObj.Find(&list)

	response.Data = serializer.BuildTypes(list)

	response.Count = uint64(count)

	return response, nil
}

func (a *ApprovalProvider) AllGroup(ctx context.Context, in *approval.CommonRequest) (*approval.AllGroupResponse, error) {

	response := &approval.AllGroupResponse{}
	var list []*model.ApprovalTypeGroup
	var count int64

	modelObj := model.DB.Model(&model.ApprovalTypeGroup{}).Preload("ApprovalTypes").
		Where(&model.ApprovalTypeGroup{Domain: &in.Domain}).Order("id desc")
	modelObj.Count(&count)

	if in.Page != 0 && in.PageSize != 0 {
		modelObj.Limit(int(in.PageSize)).Offset(page.GetOffset(in.Page, in.PageSize))
	}

	modelObj.Find(&list)

	response.Data = serializer.BuildGroups(list)

	response.Count = uint64(count)

	return response, nil
}

func (a *ApprovalProvider) RemoveType(ctx context.Context, in *approval.RemoveRequest) (*approval.StatusResponse, error) {
	response := &approval.StatusResponse{}

	if len(in.IDs) <= 0 {
		return response, errors.New(m.ErrorNotFound)
	}

	if err := model.DB.Delete(&model.ApprovalType{}, in.IDs).Error; err != nil {
		return response, err
	}

	return response, nil
}