fonchain-approval-fork/pkg/model/exhibition.go

package model

import (
	"github.com/fonchain_enterprise/fonchain-approval/api/approval"
	"github.com/fonchain_enterprise/fonchain-approval/pkg/common/collection"
	"gorm.io/plugin/soft_delete"
	"time"
)

// Exhibition 审批-画展包
type Exhibition struct {
	ID                  uint64                `gorm:"primaryKey;column:id" json:"id"`                     // ID
	DeletedAt           soft_delete.DeletedAt `gorm:"column:deleted_at" json:"deletedAt"`                 // 删除时间
	CreatedAt           time.Time             `gorm:"column:created_at" json:"createdAt"`                 // 创建时间
	UpdatedAt           time.Time             `gorm:"column:updated_at" json:"updatedAt"`                 // 更新时间
	ReceivedAt          string                `gorm:"column:received_at" json:"receivedAt"`               // 领取时间
	Address             string                `gorm:"column:address" json:"Address"`                      // 地点
	ApprovalID          uint64                `gorm:"column:approval_id" json:"approvalId"`               // 关联申请的ID
	ApprovalExhibitions []*ApprovalExhibition `gorm:"foreignKey:ExhibitionID" json:"ApprovalExhibitions"` //关联包
}

// TableName get sql table name.获取数据库表名
func (m *Exhibition) TableName() string {
	return "exhibition"
}

func (m *Exhibition) SaveApprovalContent(in *approval.ApprovalRequest, a *Approval) error {

	//主体保存
	m.ApprovalID = a.ID
	m.ReceivedAt = in.Exhibition.ReceivedAt
	m.Address = in.Exhibition.Address

	err := DB.Create(m).Error
	if err != nil {
		return err
	}

	//绑定画作保存
	var approvalExhibitions []ApprovalExhibition
	for _, approvalExhibition := range in.Exhibition.ApprovalExhibitions {
		temp := ApprovalExhibition{

			ApprovalID:    a.ID,
			ExhibitionID:  m.ID,
			PackageName:   approvalExhibition.PackageName,
			PackageID:     approvalExhibition.PackageID,
			PackageSize:   approvalExhibition.PackageSize,
			PackageNumber: approvalExhibition.PackageNumber,
		}

		approvalExhibitions = append(approvalExhibitions, temp)
	}

	if len(approvalExhibitions) > 0 {
		err = DB.Create(&approvalExhibitions).Error
	}

	return err
}

func (m *Exhibition) UpdateApprovalContent(in *approval.ApprovalRequest, a *Approval) error {

	approvalExhibitions := in.Exhibition.ApprovalExhibitions
	var oldApprovalExhibitions []ApprovalExhibition
	var oldPackageID []uint64
	var inPackageID []uint64
	var err error
	inApprovalExhibitionMap := make(map[uint64]*approval.ApprovalExhibition, len(approvalExhibitions))

	DB.Where(&ApprovalExhibition{ExhibitionID: m.ID}).Find(&oldApprovalExhibitions)

	for _, oldAW := range oldApprovalExhibitions {
		oldPackageID = append(oldPackageID, oldAW.PackageID)
	}

	for _, approvalWork := range approvalExhibitions {
		inPackageID = append(inPackageID, approvalWork.PackageID)
		inApprovalExhibitionMap[approvalWork.PackageID] = approvalWork
	}

	needDel := collection.DiffArrayUint64(oldPackageID, inPackageID)

	if len(needDel) > 0 {
		DB.Where(&ApprovalExhibition{ExhibitionID: m.ID}).Where("package_id in ?", needDel).
			Delete(&ApprovalExhibition{})
	}

	needAdd := collection.DiffArrayUint64(inPackageID, oldPackageID)

	//传递的id去除表 新增
	if len(needAdd) > 0 {
		var approvalWorks []ApprovalExhibition
		for _, one := range approvalExhibitions {
			temp := ApprovalExhibition{
				ApprovalID:    a.ID,
				ExhibitionID:  m.ID,
				PackageName:   one.PackageName,
				PackageID:     one.PackageID,
				PackageSize:   one.PackageSize,
				PackageNumber: one.PackageNumber,
			}

			approvalWorks = append(approvalWorks, temp)
		}

		if len(approvalWorks) > 0 {
			if err = DB.Create(&approvalWorks).Error; err != nil {
				return err
			}
		}
	}

	//更新 主要修改绑定的数据权限id
	changeIds := collection.IntersectArrayUint64(inPackageID, oldPackageID)
	if len(changeIds) > 0 {
		for _, tempId := range changeIds {

			if _, ok := inApprovalExhibitionMap[tempId]; ok == false {
				continue
			}

			temp := ApprovalExhibition{
				ApprovalID:    a.ID,
				ExhibitionID:  m.ID,
				PackageName:   inApprovalExhibitionMap[tempId].PackageName,
				PackageID:     inApprovalExhibitionMap[tempId].PackageID,
				PackageSize:   inApprovalExhibitionMap[tempId].PackageSize,
				PackageNumber: inApprovalExhibitionMap[tempId].PackageNumber,
			}

			DB.Model(&ApprovalExhibition{}).
				Where(&ApprovalExhibition{PackageID: inApprovalExhibitionMap[tempId].PackageID, ExhibitionID: m.ID}).
				Updates(temp)
		}
	}

	return err

}

func (m *Exhibition) BuildResContent(a *Approval, request *approval.ApprovalRequest) {
	//ApprovalWorks []*ApprovalWork `protobuf:"bytes,4,rep,name=ApprovalWorks,json=approvalWorks,proto3" json:"ApprovalWorks,omitempty"`
	var approvalExhibitions []*approval.ApprovalExhibition

	for _, one := range m.ApprovalExhibitions {
		temp := &approval.ApprovalExhibition{

			ID:            one.ID,
			ApprovalID:    one.ApprovalID,
			ExhibitionID:  one.ExhibitionID,
			PackageID:     one.PackageID,
			PackageName:   one.PackageName,
			PackageSize:   one.PackageSize,
			PackageNumber: one.PackageNumber,
		}
		approvalExhibitions = append(approvalExhibitions, temp)

	}

	request.Exhibition = &approval.Exhibition{
		ID:         m.ID,
		ReceivedAt: m.ReceivedAt,
		Address:    m.Address,

		ApprovalExhibitions: approvalExhibitions,
	}
}

func (m *Exhibition) DeleteApproval(p *Approval) error {
	var err error

	if err = DB.Where(&ApprovalExhibition{ApprovalID: p.ID}).
		Delete(&ApprovalExhibition{}).Error; err != nil {
		return err
	}

	if err = DB.Where(&Exhibition{ApprovalID: p.ID}).
		Delete(&Exhibition{}).Error; err != nil {
		return err
	}

	return err
}