ArmedPolice/app/controller/manage/equipment.go

package manage

import (
	model2 "ArmedPolice/app/common/model"
	"ArmedPolice/app/controller/basic"
	"ArmedPolice/app/model"
	"ArmedPolice/app/service"
	"ArmedPolice/config"
	"errors"
	"time"
)

type Equipment struct{ *service.Session }

type EquipmentHandle func(session *service.Session) *Equipment

type (
	// EquipmentInfo 装备信息
	EquipmentInfo struct {
		basic.CommonIDString
		Code      string           `json:"code"`
		Title     string           `json:"title"`
		Image     string           `json:"image"`
		CreatedAt time.Time        `json:"created_at"`
		Children  []*EquipmentInfo `json:"children"`
	}
	// EquipmentDetail 装备详细信息
	EquipmentDetail struct {
		basic.CommonIDString
		*model2.ManageEquipment
		Image     string                     `json:"image"`
		Materials []*EquipmentMaterialDetail `json:"materials"`
	}
	// EquipmentMaterialDetail 装备器材信息
	EquipmentMaterialDetail struct {
		*model.ManageEquipmentMaterialInfo
		ID string `json:"id"`
	}
	// EquipmentParams 装备参数信息
	EquipmentParams struct {
		ID                                 uint64
		Code, Title, Image, Config, Remark string
	}
)

func (c *EquipmentParams) isExist(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
}

func (c *Equipment) tree(src []*model2.ManageEquipment, parentID uint64) []*EquipmentInfo {
	out := make([]*EquipmentInfo, 0)

	for _, v := range src {
		if v.ParentID == parentID {
			out = append(out, &EquipmentInfo{
				CommonIDString: basic.CommonIDString{ID: v.GetEncodeID()},
				Code:           v.Code,
				Title:          v.Title,
				Image:          v.Analysis(config.SettingInfo.Domain),
				CreatedAt:      v.CreatedAt,
				Children:       c.tree(src, v.ID),
			})
		}
	}
	return out
}

// List 列表信息
func (c *Equipment) List(parentID uint64, title string, page, pageSize int) ([]*EquipmentInfo, error) {
	mManageEquipment := model.NewManageEquipment()

	out := make([]*model2.ManageEquipment, 0)

	where := []*model2.ModelWhereOrder{
		&model2.ModelWhereOrder{
			Order: model2.NewOrder("id", model2.OrderModeToDesc),
		},
	}
	if parentID > 0 {
		where = append(where, &model2.ModelWhereOrder{
			Where: model2.NewWhere("parentID", parentID),
		})
	}
	if title != "" {
		where = append(where, &model2.ModelWhereOrder{
			Where: model2.NewWhereLike("title", title),
		})
	}
	if err := model2.ScanFields(mManageEquipment.ManageEquipment, &out, []string{"id", "code", "title", "image", "created_at"},
		where...); err != nil {
		return nil, err
	}

	return c.tree(out, 0), nil
}

// Detail 详细信息
func (c *Equipment) Detail(id uint64) (*EquipmentDetail, error) {
	mManageEquipment := model.NewManageEquipment()
	mManageEquipment.ID = id

	isExist, err := model2.FirstWhere(mManageEquipment.ManageEquipment)

	if err != nil {
		return nil, err
	} else if !isExist {
		return nil, errors.New("操作错误，数据不存在")
	}
	out := &EquipmentDetail{
		CommonIDString:  basic.CommonIDString{ID: mManageEquipment.GetEncodeID()},
		ManageEquipment: mManageEquipment.ManageEquipment,
		Image:           mManageEquipment.Analysis(config.SettingInfo.Domain),
		Materials:       make([]*EquipmentMaterialDetail, 0),
	}
	mManageEquipmentMaterial := model.NewManageEquipmentMaterial()

	materials := make([]*model.ManageEquipmentMaterialInfo, 0)

	if materials, err = mManageEquipmentMaterial.Materials(id); err != nil {
		return nil, err
	}

	for _, v := range materials {
		mManageEquipmentMaterial.ID = v.ID

		out.Materials = append(out.Materials, &EquipmentMaterialDetail{
			ManageEquipmentMaterialInfo: v,
			ID:                          mManageEquipmentMaterial.GetEncodeID(),
		})
	}
	return out, nil
}

// Form 数据处理
func (c *Equipment) Form(params *EquipmentParams) error {
	mManageEquipment := model.NewManageEquipment()

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

		isExist, err := model2.FirstWhere(mManageEquipment.ManageEquipment)

		if err != nil {
			return err
		} else if !isExist {
			return errors.New("操作错误，装备信息不存在")
		}

		if params.Code != mManageEquipment.Code {
			if isExist, err = params.isExist(mManageEquipment.ManageEquipment, c.TenantID); err != nil {
				return err
			} else if isExist {
				return errors.New("操作错误，已存在相应的装备信息")
			}
		}
	}
	mManageEquipment.Code = params.Code
	mManageEquipment.Title = params.Title
	mManageEquipment.Image.Image = params.Image
	mManageEquipment.Config = params.Config
	mManageEquipment.Remark = params.Remark

	if mManageEquipment.ID > 0 {
		mManageEquipment.UpdatedAt = time.Now()
		return model2.Updates(mManageEquipment.ManageEquipment, mManageEquipment.ManageEquipment)
	}
	// 查询装备信息是否存在
	if isExist, err := params.isExist(mManageEquipment.ManageEquipment, c.TenantID); err != nil {
		return err
	} else if isExist {
		return errors.New("操作错误，已存在相应的装备信息")
	}
	mManageEquipment.TenantID = c.TenantID
	return model2.Create(mManageEquipment.ManageEquipment)
}

// Delete 删除操作
func (c *Equipment) Delete(id uint64) error {
	mManageEquipment := model.NewManageEquipment()
	mManageEquipment.ID = id

	if err := model2.Delete(mManageEquipment.ManageEquipment); err != nil {
		return err
	}
	return nil
}

func NewEquipment() EquipmentHandle {
	return func(session *service.Session) *Equipment {
		return &Equipment{session}
	}
}