debrisProduct/internal/logic/miniProgram/miniprogram.go

package miniProgram

import (
	"context"
	"debrisProduct/internal/model"
	"debrisProduct/internal/service"
	"debrisProduct/utility"
	"sync"

	"github.com/gogf/gf/v2/crypto/gmd5"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/util/gconv"
	"github.com/gogf/gf/v2/util/gutil"
)

type (
	sMiniProgram struct {
		cacheMap                map[string]*model.MiniProgram
		industryItemMiniProgram map[string]map[string]*model.MiniProgram
		lock                    sync.RWMutex
		md5                     string
	}
)

func init() {
	var (
		sMp = &sMiniProgram{}
	)
	service.RegisterMiniProgram(sMp)
}

func (s *sMiniProgram) GetMiniProgramByCode(miniCode string) *model.MiniProgram {
	s.lock.RLock()
	defer s.lock.RUnlock()
	if v, ok := s.cacheMap[miniCode]; ok && v != nil {
		return v
	}
	return &model.MiniProgram{}
}

func (s *sMiniProgram) GetMiniProgramByCtx(ctx context.Context, miniCode string) *model.MiniProgram {
	s.lock.RLock()
	defer s.lock.RUnlock()
	if v, ok := s.cacheMap[miniCode]; ok && v != nil {
		mp := gutil.Copy(v).(*model.MiniProgram)
		if mpc := s.cacheMap[utility.GetAppidFromReferer(ctx)]; mpc != nil {
			mp.Appid = mpc.Appid
			mp.Appsecret = mpc.Appsecret
		}
		return mp
	}
	return &model.MiniProgram{}
}

func (s *sMiniProgram) GetMiniProgramByReferer(ctx context.Context) *model.MiniProgram {
	s.lock.RLock()
	defer s.lock.RUnlock()
	if v, ok := s.cacheMap[utility.GetAppidFromReferer(ctx)]; ok && v != nil {
		return gutil.Copy(v).(*model.MiniProgram)
	}
	return &model.MiniProgram{}
}

func (s *sMiniProgram) LoadMiniProgram(ctx context.Context) {
	res, _ := g.DB().GetAll(ctx, "SELECT a.name,a.code,a.industry_code,a.industry_item_code,a.appid,a.appsecret,a.point_version,b.value AS industryValue,b.name AS industryName FROM miniprogram a LEFT JOIN industry b ON a.industry_code = b.`code` order by a.id asc")
	if thisMd5, _ := gmd5.Encrypt(res.Json()); res.Len() > 0 && s.md5 != thisMd5 {
		var (
			cache                   = map[string]*model.MiniProgram{}
			industryItemMiniProgram = map[string]map[string]*model.MiniProgram{}
		)
		for _, m := range res.List() {
			appid := gconv.String(m["appid"])
			code := gconv.String(m["code"])
			mp := &model.MiniProgram{
				Code:             code,
				Name:             gconv.String(m["name"]),
				IndustryCode:     gconv.String(m["industry_code"]),
				IndustryItemCode: gconv.String(m["industry_item_code"]),
				Appid:            appid,
				Appsecret:        gconv.String(m["appsecret"]),
				IndustryName:     gconv.String(m["industryName"]),
				IndustryValue:    gconv.String(m["industryValue"]),
				PointVersion:     gconv.Int(m["point_version"]),
			}
			if code != "" {
				cache[code] = mp
			}
			if appid != "" {
				cache[appid] = mp
			}
			if industryItemMiniProgram[mp.IndustryCode] == nil {
				industryItemMiniProgram[mp.IndustryCode] = map[string]*model.MiniProgram{}
			}
			industryItemMiniProgram[mp.IndustryCode][mp.IndustryItemCode] = mp
		}
		s.lock.Lock()
		defer s.lock.Unlock()
		s.cacheMap = cache
		s.md5 = thisMd5
		s.industryItemMiniProgram = industryItemMiniProgram
		g.Log().Infof(ctx, "加载更新miniProgram配置")
	}
}

func (s *sMiniProgram) IsInExamine(ctx context.Context) bool {
	biz := service.BizCtx().Get(ctx)
	if biz == nil {
		return false
	}
	version := biz.Session.MustGet("version").String()
	if version == "" {
		return false
	}
	for _, v := range g.Config().MustGet(ctx, "examineVersion").Strings() {
		if v == version {
			return true
		}
	}
	for _, v := range g.Config(biz.MiniProgram.Code).MustGet(ctx, "examineVersion").Strings() {
		if v == version {
			return true
		}
	}
	return false
}

func (s *sMiniProgram) GetMiniProgramByIndustryItem(code, item string) *model.MiniProgram {
	s.lock.RLock()
	defer s.lock.RUnlock()
	if s.industryItemMiniProgram[code] != nil && s.industryItemMiniProgram[code][item] != nil {
		return s.industryItemMiniProgram[code][item]
	}
	return &model.MiniProgram{}
}