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/lib"
	"ArmedPolice/serve/orm"
	"errors"
	"gorm.io/gorm"
	"time"
)

type Material struct{ *service.Session }

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

type (
	// MaterialInfo 基本信息
	MaterialInfo struct {
		basic.CommonIDString
		*model.ManageMaterialInfo
	}
	// MaterialParams 基本参数
	MaterialParams struct {
		ID, SupplierID             uint64
		Code, Title, Image, Remark string
		Unit                       int
	}
	// MaterialPurchaseInfo 采购信息
	MaterialPurchaseInfo struct {
		basic.CommonIDString
		*model.ManageMaterialPurchaseInfo
	}
)

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

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

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

	if err := model2.Count(iModel, &count, model2.NewWhere("title", c.Title),
		model2.NewWhere("supplier_id", c.SupplierID)); err != nil {
		return false, err
	}
	return count > 0, nil
}

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

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

	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
}

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.SupplierID != params.SupplierID {

		}
		if mManageMaterial.Code != params.Code {
			if isExist, err = params.isExistForCode(mManageMaterial); err != nil {
				return err
			} else if isExist {
				return errors.New("操作错误，当前供应商下已存在此编码")
			}
		}
		if mManageMaterial.Title != params.Title {
			if isExist, err = params.isExistForTitle(mManageMaterial); err != nil {
				return err
			} else if isExist {
				return errors.New("操作错误，当前供应商下已存在此名称")
			}
		}
	}
	mManageMaterial.SupplierID = params.SupplierID
	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)

	if err != nil {
		return err
	} else if isExist {
		return errors.New("操作错误，当前供应商下已存在此编码")
	}
	if isExist, err = params.isExistForTitle(mManageMaterial); 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)
}

// Purchase 采购信息
func (c *Material) Purchase(orderNo, supplierName, materialTitle string, page, pageSize int) (*basic.PageDataResponse, error) {
	mManageMaterialPurchase := model.NewManageMaterialPurchase()

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

	if orderNo != "" {
		where = append(where, model2.NewWhereLike("p.order_no", orderNo))
	}
	if supplierName != "" {
		where = append(where, model2.NewWhereLike("s.name", supplierName))
	}
	if materialTitle != "" {
		where = append(where, model2.NewWhereLike("m.title", materialTitle))
	}
	var count int64

	out, err := mManageMaterialPurchase.Purchases(page, pageSize, &count, where...)

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

	for _, v := range out {
		list = append(list, &MaterialPurchaseInfo{
			CommonIDString:             basic.CommonIDString{ID: v.GetEncodeID()},
			ManageMaterialPurchaseInfo: v,
		})
	}
	return &basic.PageDataResponse{Data: list, Count: count}, nil
}

// PurchaseLaunch 采购发起
func (c *Material) PurchaseLaunch(materialID uint64, price float64, number int, remark string) error {
	mManageMaterialPurchase := model.NewManageMaterialPurchase()
	mManageMaterialPurchase.UID = c.UID
	mManageMaterialPurchase.OrderNo = lib.OrderNo()
	mManageMaterialPurchase.MaterialID = materialID
	mManageMaterialPurchase.Price = price
	mManageMaterialPurchase.Number = number
	mManageMaterialPurchase.Remark = remark
	return model2.Create(mManageMaterialPurchase.ManageMaterialPurchase)
}

// PurchaseDelete 采购删除
func (c *Material) PurchaseDelete(id uint64) error {
	mManageMaterialPurchase := model.NewManageMaterialPurchase()
	mManageMaterialPurchase.ID = id
	return model2.Delete(mManageMaterialPurchase.ManageMaterialPurchase)
}

func (c *Material) Warehouse() {

}

// WarehouseLaunch 入库发起
func (c *Material) WarehouseLaunch(materialPurchaseID uint64, number int, remark string) error {
	mManageMaterialPurchase := model.NewManageMaterialPurchase()
	mManageMaterialPurchase.ID = materialPurchaseID

	isExist, err := model2.FirstWhere(mManageMaterialPurchase.ManageMaterialPurchase)

	if err != nil {
		return err
	} else if !isExist {
		return errors.New("操作错误，未找到相应的采购单")
	}
	mManageMaterialWarehouse := model.NewManageMaterialWarehouse()
	mManageMaterialWarehouse.UID = c.UID
	mManageMaterialWarehouse.MaterialPurchaseID = materialPurchaseID
	mManageMaterialWarehouse.Number = number
	mManageMaterialWarehouse.Remark = remark

	return orm.GetDB().Transaction(func(tx *gorm.DB) error {
		if err = model2.Create(mManageMaterialWarehouse.ManageMaterialWarehouse); err != nil {
			return err
		}
		// 同步库存
		mManageMaterial := model.NewManageMaterial()

		if err = model2.Updates(mManageMaterial.ManageMaterial, map[string]interface{}{
			"stock": gorm.Expr("stock + ?", number),
		}); err != nil {
			return err
		}
		return nil
	})
}

// WarehouseDelete 入库删除
func (c *Material) WarehouseDelete(id uint64) error {
	mManageMaterialWarehouse := model.NewManageMaterialWarehouse()
	mManageMaterialWarehouse.ID = id
	return model2.Delete(mManageMaterialWarehouse.ManageMaterialWarehouse)
}

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