pm/services/material/item/type.go

package item

import (
	"errors"
	"zhiyuan/models"
	"zhiyuan/pkg/app"
	"zhiyuan/pkg/db"
	"zhiyuan/pkg/redis"
	"zhiyuan/pkg/utils"
	"zhiyuan/services/form"
)

var MatItemType models.MatItemType

const cacheKey = "material_item_type_cache"

func GetTypeList(where map[string]interface{}, fields []string, page app.Page, retVal interface{}) ([]*models.MatItemType, error) {
	if page.PageNum > 0 && page.PageSize > 0 {
		where["_limit"] = db.GetOffset(uint(page.PageNum), uint(page.PageSize))
	}
	return MatItemType.GetMulti(where, fields, retVal)
}

func GetTypeListByCache() ([]*models.MatItemType, error) {
	res, err := redis.Get(cacheKey)
	var typeList []*models.MatItemType
	if err != nil {
		typeList, err = GetTypeList(nil, nil, app.Page{}, nil)
		if err != nil {
			return nil, err
		}
		redis.Set(cacheKey, typeList, 3600)
	} else {
		utils.JsonDecode(res).To(&typeList)
	}
	return typeList, nil
}

func GetTypeMapByCache() map[int]string {
	orderTypeMap := make(map[int]string)
	if orderTypeList, err := GetTypeListByCache(); err == nil {
		for _, v := range orderTypeList {
			orderTypeMap[v.ID] = v.TypeName
		}
	}
	return orderTypeMap
}

func CountType(where map[string]interface{}) (int64, error) {
	return db.Count(MatItemType.TableName(), where)
}

func GetTypeOne(where map[string]interface{}, fields []string, dest interface{}) (*models.MatItemType, error) {
	return MatItemType.GetOne(where, fields, dest)
}

func AddType(form form.MaterialItemTypeAdd) (int64, error) {
	typeMap := map[string]interface{}{
		"type_name": form.TypeName,
		"pid":       form.PID,
		"category":  form.Category,
	}
	typeID, err := db.InsertOne(MatItemType.TableName(), typeMap)
	redis.Del(cacheKey)
	if err != nil {
		return 0, nil
	}
	return typeID, nil
}

func EditType(form form.MaterialItemTypeAdd, id int) (int64, error) {
	typeInfo, _ := GetTypeOne(map[string]interface{}{"id": id}, nil, nil)
	if typeInfo.TypeName != form.TypeName && CheckDuplicate(form.TypeName) {
		return 0, errors.New("类别已存在")
	}
	typeMap := map[string]interface{}{
		"type_name": form.TypeName,
		"pid":       form.PID,
		"category":  form.Category,
	}
	redis.Del(cacheKey)
	return db.Update(MatItemType.TableName(), map[string]interface{}{"id": id}, typeMap)
}

func CheckDuplicate(name string) bool {
	typeInfo, err := GetTypeOne(map[string]interface{}{"type_name": name}, nil, nil)
	return typeInfo != nil && err == nil
}