pm/services/aftersale/issue.go

package aftersale

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

var ASIssue models.ASIssue

const cacheIssueKey = "aftersale_issue_cache"

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

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

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

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

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

func AddIssue(form form.ASIssueAdd) (int64, error) {
	if CheckIssueDuplicate(form.IssueName) {
		return 0, errors.New("问题已存在")
	}
	issueMap := map[string]interface{}{
		"issue_name": form.IssueName,
	}
	issueID, err := db.InsertOne(ASIssue.TableName(), issueMap)
	redis.Del(cacheKey)
	if err != nil {
		return 0, nil
	}
	return issueID, nil
}

func EditIssue(form form.ASIssueAdd, id int) (int64, error) {
	typeInfo, _ := GetIssueOne(map[string]interface{}{"id": id}, nil, nil)
	if typeInfo.IssueName != form.IssueName && CheckDuplicate(form.IssueName) {
		return 0, errors.New("类别已存在")
	}
	issueMap := map[string]interface{}{
		"issue_name": form.IssueName,
	}
	redis.Del(cacheKey)
	return db.Update(ASIssue.TableName(), map[string]interface{}{"id": id}, issueMap)
}

func CheckIssueDuplicate(name string) bool {
	issueInfo, err := GetIssueOne(map[string]interface{}{"issue_name": name}, nil, nil)
	return issueInfo != nil && err == nil
}