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"
	"errors"
	"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
		*model.ManageMaterialInfo
	}
	// MaterialParams 基本参数
	MaterialParams struct {
		ID, ManufacturerID         uint64
		Code, Title, Image, Remark string
		Unit                       int
	}
)

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)

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

	for _, v := range out {
		v.Image.Image = v.Analysis(config.SettingInfo.Domain)
		list = append(list, &MaterialInfo{
			CommonIDString:     basic.CommonIDString{ID: v.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("操作错误，已存在此对应的器材编码")
			}
		}
	}
	mManageMaterial.ManufacturerID = params.ManufacturerID
	mManageMaterial.Code = params.Code
	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)
	}
	isExist, err := params.isExistForCode(mManageMaterial, c.TenantID)

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

// 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}
	}
}