ArmedPolice/app/controller/manage/material.go

package manage

import (
	model2 "ArmedPolice/app/common/model"
	"ArmedPolice/app/controller/basic"
	"ArmedPolice/app/model"
	"ArmedPolice/app/service"
	"ArmedPolice/config"
	"ArmedPolice/serve/orm"
	"errors"
	"gorm.io/gorm"
	"time"
)

type Material struct{ *service.Session }

type MaterialHandle func(session *service.Session) *Material

type (
	// MaterialBasic 基本信息
	MaterialBasic struct {
		basic.CommonIDString
		*model.ManageMaterialBasic
	}
	// MaterialInfo 基本信息
	MaterialInfo struct {
		basic.CommonIDString
		ManufacturerID string `json:"manufacturer_id"`
		*model.ManageMaterialInfo
	}
	// MaterialParams 基本参数
	MaterialParams struct {
		ID, ManufacturerID, MaterialID uint64
		Code, Title, Image, Remark     string
		Unit                           int
		Price                          float64
		SupplierID                     uint64
		Stock                          float64
	}
)

func (c *MaterialParams) isExistForCode(iModel model2.IModel, tenantID uint64) (bool, error) {
	var count int64

	if err := model2.Count(iModel, &count, model2.NewWhere("tenant_id", tenantID), model2.NewWhere("code", c.Code)); err != nil {
		return false, err
	}
	return count > 0, nil
}

// List 列表信息
func (c *Material) List(manufacturerID, supplierID uint64, code, title string, page, pageSize int) (*basic.PageDataResponse, error) {
	mManageMaterial := model.NewManageMaterial()

	where := make([]*model2.ModelWhere, 0)

	if manufacturerID > 0 {
		where = append(where, model2.NewWhere("m.manufacturer_id", manufacturerID))
	}
	if supplierID > 0 {
		where = append(where, model2.NewWhere("m.supplier_id", supplierID))
	}
	if code != "" {
		where = append(where, model2.NewWhereLike("m.code", code))
	}
	if title != "" {
		where = append(where, model2.NewWhereLike("m.title", title))
	}
	var count int64

	out, err := mManageMaterial.Materials(page, pageSize, &count, where...)

	if err != nil {
		return nil, err
	}
	list := make([]*MaterialInfo, 0)

	for _, v := range out {
		mManageMaterial.SetID(v.ManageMaterial.ManufacturerID)

		v.Stock -= v.FrozenStock
		v.Image.Image = v.Analysis(config.SettingInfo.Domain)

		list = append(list, &MaterialInfo{
			CommonIDString:     basic.CommonIDString{ID: v.GetEncodeID()},
			ManufacturerID:     mManageMaterial.GetEncodeID(),
			ManageMaterialInfo: v,
		})
	}
	return &basic.PageDataResponse{Data: list, Count: count}, nil
}

// Select 信息筛选
func (c *Material) Select() ([]*MaterialBasic, error) {
	mManageMaterial := model.NewManageMaterial()

	out, err := mManageMaterial.Basic()

	if err != nil {
		return nil, err
	}
	list := make([]*MaterialBasic, 0)

	for _, v := range out {
		mManageMaterial.ID = v.ID

		list = append(list, &MaterialBasic{
			CommonIDString:      basic.CommonIDString{ID: mManageMaterial.GetEncodeID()},
			ManageMaterialBasic: v,
		})
	}
	return list, nil
}

// Form 数据操作
func (c *Material) Form(params *MaterialParams) error {
	mManageMaterial := model.NewManageMaterial()

	if params.ID > 0 {
		mManageMaterial.ID = params.ID

		isExist, err := model2.First(mManageMaterial.ManageMaterial)

		if err != nil {
			return err
		} else if !isExist {
			return errors.New("操作错误，器材信息不存在")
		}
		if mManageMaterial.Code != params.Code {
			if isExist, err = params.isExistForCode(mManageMaterial, c.TenantID); err != nil {
				return err
			} else if isExist {
				return errors.New("操作错误，已存在此对应的器材编码")
			}
		}
		if mManageMaterial.TenantID != c.TenantID {
			return errors.New("操作错误，无权限操作")
		}
	}
	mManageMaterial.ManufacturerID = params.ManufacturerID
	mManageMaterial.Code = params.Code
	mManageMaterial.Price = params.Price
	mManageMaterial.Title = params.Title
	mManageMaterial.Unit = model2.ManageMaterialUnit(params.Unit)
	mManageMaterial.Remark = params.Remark

	if mManageMaterial.ID > 0 {
		mManageMaterial.UpdatedAt = time.Now()
		return model2.Updates(mManageMaterial.ManageMaterial, mManageMaterial.ManageMaterial)
	}
	return orm.GetDB().Transaction(func(tx *gorm.DB) error {
		if params.MaterialID <= 0 {
			isExist, err := params.isExistForCode(mManageMaterial, c.TenantID)

			if err != nil {
				return err
			} else if isExist {
				return errors.New("操作错误，已存在此对应的器材编码")
			}
			mManageMaterial.TenantID = c.TenantID

			if err = model2.Create(mManageMaterial.ManageMaterial, tx); err != nil {
				return err
			}
			params.MaterialID = mManageMaterial.ID
		} else {
			if params.SupplierID <= 0 {
				return errors.New("操作错误，未知的供应商信息")
			}
		}
		mManageMaterialSupplier := model.NewManageMaterialSupplier()

		var count int64

		err := model2.Count(mManageMaterialSupplier.ManageMaterialSupplier, &count, model2.NewWhere("material_id", params.MaterialID),
			model2.NewWhere("supplier_id", params.SupplierID))

		if err != nil {
			return err
		} else if count > 0 {
			return errors.New("操作错误，该器材已含有供应商信息")
		}
		mManageMaterialSupplier.MaterialID = params.MaterialID
		mManageMaterialSupplier.SupplierID = params.SupplierID
		mManageMaterialSupplier.Stock = params.Stock
		return model2.Create(mManageMaterialSupplier.ManageMaterialSupplier, tx)
	})

}

// Delete 删除操作
func (c *Material) Delete(id uint64) error {
	mManageMaterial := model.NewManageMaterial()
	mManageMaterial.ID = id
	return model2.Delete(mManageMaterial.ManageMaterial)
}

func NewMaterial() MaterialHandle {
	return func(session *service.Session) *Material {
		return &Material{session}
	}
}