jy-docs/jydocs-back/public/db.go

package public

import (
	"app.yhyue.com/moapp/jybase/common"
	"app.yhyue.com/moapp/jybase/encrypt"
	"app.yhyue.com/moapp/jybase/mongodb"
	"app.yhyue.com/moapp/jybase/redis"
	"app.yhyue.com/moapp/message/model"
	"encoding/json"
	"fmt"
	"github.com/nsqio/go-nsq"
	"log"
	"time"
)

var (
	DbConf       *dbConf
	MQFW         mongodb.MongodbSim
	Mgo_Log      mongodb.MongodbSim
	NSQ_Producer *nsq.Producer
)

type dbConf struct {
	Mongodb struct {
		Main *mgoConf
		Log  *mgoConf
	}
	Redis struct {
		Main *redisConf
	}
	NsqConfig *NsqConfig
}

type mgoConf struct {
	Address         string
	Size            int
	DbName          string
	ReplSet         string
	UserName        string
	Password        string
	Collection      string
	Collection_back string
}

type NsqConfig struct {
	Address string
	AppName string
}
type redisConf struct {
	Address string
}

func init() {
	common.ReadConfig("./db.json", &DbConf)
	if DbConf != nil {
		if DbConf.Mongodb.Main != nil {
			log.Println("初始化 mongodb main")
			MQFW = mongodb.MongodbSim{
				MongodbAddr: DbConf.Mongodb.Main.Address,
				Size:        DbConf.Mongodb.Main.Size,
				DbName:      DbConf.Mongodb.Main.DbName,
				ReplSet:     DbConf.Mongodb.Main.ReplSet,
			}
			MQFW.InitPool()
		}
		if DbConf.Mongodb.Log != nil {
			log.Println("初始化 mongodb log")
			Mgo_Log = mongodb.MongodbSim{
				MongodbAddr: DbConf.Mongodb.Log.Address,
				Size:        DbConf.Mongodb.Log.Size,
				DbName:      DbConf.Mongodb.Log.DbName,
				ReplSet:     DbConf.Mongodb.Log.ReplSet,
				UserName:    DbConf.Mongodb.Log.UserName,
				Password:    DbConf.Mongodb.Log.Password,
			}
			Mgo_Log.InitPool()
		}
		//初始化redis
		if DbConf.Redis.Main != nil {
			log.Println("初始化 redis")
			redis.InitRedisBySize(DbConf.Redis.Main.Address, 100, 30, 300)
		}
		if DbConf.NsqConfig != nil {
			log.Println("初始化 nsq")
			var NsqErr error
			NSQ_Producer, NsqErr = nsq.NewProducer(DbConf.NsqConfig.Address, nsq.NewConfig())
			if NsqErr != nil {
				log.Printf("初始化 nsq 异常 %v\n", NsqErr)
			}
		}
	}
}

//分享打开文库赚积分
func OpenShareJydoc(fromId, openId, docId string) {
	fromId = encrypt.SE.Decode4Hex(fromId)
	if fromId == "" || openId == fromId || openId == "" || docId == "" {
		return
	}
	//判断是否是合法用户
	if MQFW.Count("user", map[string]interface{}{
		"_id": mongodb.StringTOBsonId(fromId),
	}) == 0 {
		log.Printf("%s分享%s打开%s 未找到用户\n", fromId, openId, docId)
		return
	}
	key := fmt.Sprintf("integral_article_%s_%s_%s", docId, fromId, openId)
	if redis.Incr("other", key) == 1 {
		_ = redis.SetExpire("other", key, 24*60*60)
		pushErr := func() error {
			b, _ := json.Marshal(&model.Message{
				E_code:   "jydocs_doc_open",
				E_userId: fromId,
				E_time:   time.Now().Unix(),
				E_app:    DbConf.NsqConfig.AppName,
			})
			if err := NSQ_Producer.Publish("jy_event", b); err != nil {
				log.Printf("消息发布异常%v\n", err)
				return err
			}
			return nil
		}()
		if pushErr != nil {
			log.Printf("%s分享%s打开%s Publish nsq队列 异常%v\n", fromId, openId, docId, pushErr)
		} else {
			log.Printf("%s分享%s打开%s Publish nsq队列 成功\n", fromId, openId, docId)
			redis.Put("other", fmt.Sprintf("integral_article_%s_%s", fromId, docId), 1, 60*60*24)
		}
	}
}