pm/services/aftersale/type.go

package aftersale

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

var ASType models.ASType

const cacheKey = "aftersale_type_cache"

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

func GetTypeListByCache() ([]*models.ASType, error) {
	res, err := redis.Get(cacheKey)
	var typeList []*models.ASType
	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(ASType.TableName(), where)
}

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

func AddType(form form.ASTypeAdd) (int64, error) {
	typeMap := map[string]interface{}{
		"type_name": form.TypeName,
		"pid":       form.PID,
		"`show`":    form.Show,
	}
	if form.PID == 0 {
		if form.WarrantyPeriod == 0 {
			return 0, errors.New("请填写保修年限")
		}
		typeMap["warranty_period"] = form.WarrantyPeriod
	} else {
		typeMap["warranty_period"] = 0
	}

	typeID, err := db.InsertOne(ASType.TableName(), typeMap)
	redis.Del(cacheKey)
	if err != nil {
		return 0, nil
	}
	return typeID, nil
}

func EditType(form form.ASTypeAdd, 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,
		"`show`":    form.Show,
	}
	if form.PID == 0 {
		if form.WarrantyPeriod == 0 {
			return 0, errors.New("请填写保修年限")
		}
		typeMap["warranty_period"] = form.WarrantyPeriod
		typeMap["repair_days"] = form.RepairDays
	} else {
		typeMap["warranty_period"] = 0
	}
	redis.Del(cacheKey)
	return db.Update(ASType.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
}