mirror of
https://github.com/songquanpeng/message-pusher.git
synced 2024-05-03 08:45:04 +08:00
264 lines
6.2 KiB
Go
264 lines
6.2 KiB
Go
package channel
|
|
|
|
import (
|
|
"message-pusher/common"
|
|
"message-pusher/model"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
type TokenStoreItem interface {
|
|
Key() string
|
|
Token() string
|
|
Refresh()
|
|
IsFilled() bool
|
|
IsShared() bool
|
|
}
|
|
|
|
type tokenStore struct {
|
|
Map map[string]*TokenStoreItem
|
|
Mutex sync.RWMutex
|
|
ExpirationSeconds int
|
|
}
|
|
|
|
var s tokenStore
|
|
|
|
func channel2item(channel_ *model.Channel) TokenStoreItem {
|
|
switch channel_.Type {
|
|
case model.TypeWeChatTestAccount:
|
|
item := &WeChatTestAccountTokenStoreItem{
|
|
AppID: channel_.AppId,
|
|
AppSecret: channel_.Secret,
|
|
}
|
|
return item
|
|
case model.TypeWeChatCorpAccount:
|
|
corpId, agentId, err := parseWechatCorpAccountAppId(channel_.AppId)
|
|
if err != nil {
|
|
common.SysError(err.Error())
|
|
return nil
|
|
}
|
|
item := &WeChatCorpAccountTokenStoreItem{
|
|
CorpId: corpId,
|
|
AgentSecret: channel_.Secret,
|
|
AgentId: agentId,
|
|
}
|
|
return item
|
|
case model.TypeLarkApp:
|
|
item := &LarkAppTokenStoreItem{
|
|
AppID: channel_.AppId,
|
|
AppSecret: channel_.Secret,
|
|
}
|
|
return item
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func channels2items(channels []*model.Channel) []TokenStoreItem {
|
|
var items []TokenStoreItem
|
|
for _, channel_ := range channels {
|
|
item := channel2item(channel_)
|
|
if item != nil {
|
|
items = append(items, item)
|
|
}
|
|
}
|
|
return items
|
|
}
|
|
|
|
func TokenStoreInit() {
|
|
s.Map = make(map[string]*TokenStoreItem)
|
|
// https://developers.weixin.qq.com/doc/offiaccount/Basic_Information/Get_access_token.html
|
|
// https://developer.work.weixin.qq.com/document/path/91039
|
|
s.ExpirationSeconds = 2 * 55 * 60 // 2 hours - 5 minutes
|
|
go func() {
|
|
channels, err := model.GetTokenStoreChannels()
|
|
if err != nil {
|
|
common.FatalLog(err.Error())
|
|
}
|
|
items := channels2items(channels)
|
|
s.Mutex.RLock()
|
|
for i := range items {
|
|
// s.Map[item.Key()] = &item // This is wrong, you are getting the address of a local variable!
|
|
s.Map[items[i].Key()] = &items[i]
|
|
}
|
|
s.Mutex.RUnlock()
|
|
for {
|
|
s.Mutex.RLock()
|
|
var tmpMap = make(map[string]*TokenStoreItem)
|
|
for k, v := range s.Map {
|
|
tmpMap[k] = v
|
|
}
|
|
s.Mutex.RUnlock()
|
|
for k := range tmpMap {
|
|
(*tmpMap[k]).Refresh()
|
|
}
|
|
s.Mutex.RLock()
|
|
// we shouldn't directly replace the old map with the new map, cause the old map's keys may already change
|
|
for k := range s.Map {
|
|
v, okay := tmpMap[k]
|
|
if okay {
|
|
s.Map[k] = v
|
|
}
|
|
}
|
|
sleepDuration := common.Max(s.ExpirationSeconds, 60)
|
|
s.Mutex.RUnlock()
|
|
time.Sleep(time.Duration(sleepDuration) * time.Second)
|
|
}
|
|
}()
|
|
}
|
|
|
|
// TokenStoreAddItem It's okay to add an incomplete item.
|
|
func TokenStoreAddItem(item TokenStoreItem) {
|
|
if !item.IsFilled() {
|
|
return
|
|
}
|
|
item.Refresh()
|
|
s.Mutex.RLock()
|
|
s.Map[item.Key()] = &item
|
|
s.Mutex.RUnlock()
|
|
}
|
|
|
|
func TokenStoreRemoveItem(item TokenStoreItem) {
|
|
s.Mutex.RLock()
|
|
delete(s.Map, item.Key())
|
|
s.Mutex.RUnlock()
|
|
}
|
|
|
|
func TokenStoreAddUser(user *model.User) {
|
|
channels, err := model.GetTokenStoreChannelsByUserId(user.Id)
|
|
if err != nil {
|
|
common.SysError(err.Error())
|
|
return
|
|
}
|
|
items := channels2items(channels)
|
|
for i := range items {
|
|
TokenStoreAddItem(items[i])
|
|
}
|
|
}
|
|
|
|
// TokenStoreRemoveUser
|
|
// user must be filled.
|
|
// It's okay to delete a user that don't have an item here.
|
|
func TokenStoreRemoveUser(user *model.User) {
|
|
channels, err := model.GetTokenStoreChannelsByUserId(user.Id)
|
|
if err != nil {
|
|
common.SysError(err.Error())
|
|
return
|
|
}
|
|
items := channels2items(channels)
|
|
for i := range items {
|
|
if items[i].IsShared() {
|
|
continue
|
|
}
|
|
TokenStoreRemoveItem(items[i])
|
|
}
|
|
}
|
|
|
|
func checkTokenStoreChannelType(channelType string) bool {
|
|
return channelType == model.TypeWeChatTestAccount || channelType == model.TypeWeChatCorpAccount || channelType == model.TypeLarkApp
|
|
}
|
|
|
|
func TokenStoreAddChannel(channel *model.Channel) {
|
|
if !checkTokenStoreChannelType(channel.Type) {
|
|
return
|
|
}
|
|
item := channel2item(channel)
|
|
if item != nil {
|
|
// Do not check IsShared here, cause its useless
|
|
TokenStoreAddItem(item)
|
|
}
|
|
}
|
|
|
|
func TokenStoreRemoveChannel(channel *model.Channel) {
|
|
if !checkTokenStoreChannelType(channel.Type) {
|
|
return
|
|
}
|
|
item := channel2item(channel)
|
|
if item != nil && !item.IsShared() {
|
|
TokenStoreRemoveItem(item)
|
|
}
|
|
}
|
|
|
|
func TokenStoreUpdateChannel(newChannel *model.Channel, oldChannel *model.Channel) {
|
|
if oldChannel.Type != model.TypeWeChatTestAccount && oldChannel.Type != model.TypeWeChatCorpAccount {
|
|
return
|
|
}
|
|
// Why so complicated? Because the given channel maybe incomplete.
|
|
if oldChannel.Type == model.TypeWeChatTestAccount {
|
|
// Only keep changed parts
|
|
if newChannel.AppId == oldChannel.AppId {
|
|
newChannel.AppId = ""
|
|
}
|
|
if newChannel.Secret == oldChannel.Secret {
|
|
newChannel.Secret = ""
|
|
}
|
|
oldItem := WeChatTestAccountTokenStoreItem{
|
|
AppID: oldChannel.AppId,
|
|
AppSecret: oldChannel.Secret,
|
|
}
|
|
// Yeah, it's a deep copy.
|
|
newItem := oldItem
|
|
// This means the user updated those fields.
|
|
if newChannel.AppId != "" {
|
|
newItem.AppID = newChannel.AppId
|
|
}
|
|
if newChannel.Secret != "" {
|
|
newItem.AppSecret = newChannel.Secret
|
|
}
|
|
if !oldItem.IsShared() {
|
|
TokenStoreRemoveItem(&oldItem)
|
|
}
|
|
TokenStoreAddItem(&newItem)
|
|
return
|
|
}
|
|
if oldChannel.Type == model.TypeWeChatCorpAccount {
|
|
// Only keep changed parts
|
|
if newChannel.AppId == oldChannel.AppId {
|
|
newChannel.AppId = ""
|
|
}
|
|
if newChannel.Secret == oldChannel.Secret {
|
|
newChannel.Secret = ""
|
|
}
|
|
corpId, agentId, err := parseWechatCorpAccountAppId(oldChannel.AppId)
|
|
if err != nil {
|
|
common.SysError(err.Error())
|
|
return
|
|
}
|
|
oldItem := WeChatCorpAccountTokenStoreItem{
|
|
CorpId: corpId,
|
|
AgentSecret: oldChannel.Secret,
|
|
AgentId: agentId,
|
|
}
|
|
// Yeah, it's a deep copy.
|
|
newItem := oldItem
|
|
// This means the user updated those fields.
|
|
if newChannel.AppId != "" {
|
|
corpId, agentId, err := parseWechatCorpAccountAppId(oldChannel.AppId)
|
|
if err != nil {
|
|
common.SysError(err.Error())
|
|
return
|
|
}
|
|
newItem.CorpId = corpId
|
|
newItem.AgentId = agentId
|
|
}
|
|
if newChannel.Secret != "" {
|
|
newItem.AgentSecret = newChannel.Secret
|
|
}
|
|
if !oldItem.IsShared() {
|
|
TokenStoreRemoveItem(&oldItem)
|
|
}
|
|
TokenStoreAddItem(&newItem)
|
|
return
|
|
}
|
|
}
|
|
|
|
func TokenStoreGetToken(key string) string {
|
|
s.Mutex.RLock()
|
|
defer s.Mutex.RUnlock()
|
|
item, ok := s.Map[key]
|
|
if ok {
|
|
return (*item).Token()
|
|
}
|
|
common.SysError("token for " + key + " is blank!")
|
|
return ""
|
|
}
|