328 lines
7.9 KiB
Go
328 lines
7.9 KiB
Go
package service
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
"net/url"
|
||
|
||
"go-common/app/admin/ep/saga/conf"
|
||
"go-common/app/admin/ep/saga/model"
|
||
"go-common/app/admin/ep/saga/service/wechat"
|
||
"go-common/library/log"
|
||
|
||
"github.com/pkg/errors"
|
||
)
|
||
|
||
const qyWechatURL = "https://qyapi.weixin.qq.com"
|
||
|
||
// CollectWachatUsers send required wechat visible users stored in memcache by email
|
||
func (s *Service) CollectWachatUsers(c context.Context) (err error) {
|
||
var (
|
||
contactInfo *model.ContactInfo
|
||
userMap = make(map[string]model.RequireVisibleUser)
|
||
user string
|
||
)
|
||
|
||
if err = s.dao.RequireVisibleUsersRedis(c, &userMap); err != nil {
|
||
log.Error("get require visible user error(%v)", err)
|
||
return
|
||
}
|
||
|
||
for k, v := range userMap {
|
||
if contactInfo, err = s.dao.QueryUserByID(k); err == nil {
|
||
if contactInfo.VisibleSaga {
|
||
continue
|
||
}
|
||
}
|
||
user += v.UserName + " , " + v.NickName + "\n"
|
||
}
|
||
|
||
/*content := fmt.Sprintf("\n\n邮箱前缀 昵称\n\n%s", user)
|
||
for _, addr := range conf.Conf.Property.ReportRequiredVisible.AlertAddrs {
|
||
if err = mail.SendMail2(addr, "需添加的企业微信名单", content); err != nil {
|
||
return
|
||
}
|
||
}*/
|
||
if err = s.dao.DeleteRequireVisibleUsersRedis(c); err != nil {
|
||
log.Error("Delete require visible user error(%v)", err)
|
||
return
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
// SyncContacts sync the wechat contacts 更新企业微信列表（用户信息和saga信息）
|
||
func (s *Service) SyncContacts(c context.Context) (err error) {
|
||
var (
|
||
w = wechat.New(s.dao)
|
||
)
|
||
|
||
if err = w.SyncContacts(c); err != nil {
|
||
return
|
||
}
|
||
return
|
||
}
|
||
|
||
// QueryContacts query machine logs.
|
||
func (s *Service) QueryContacts(c context.Context, queryRequest *model.Pagination) (p *model.PaginateContact, err error) {
|
||
var (
|
||
total int64
|
||
contacts []*model.ContactInfo
|
||
)
|
||
fmt.Print(queryRequest.PageNum)
|
||
if total, contacts, err = s.dao.FindContacts(queryRequest.PageNum, queryRequest.PageSize); err != nil {
|
||
return
|
||
}
|
||
fmt.Print(queryRequest.PageNum)
|
||
p = &model.PaginateContact{
|
||
PageNum: queryRequest.PageNum,
|
||
PageSize: queryRequest.PageSize,
|
||
Total: total,
|
||
Contacts: contacts,
|
||
}
|
||
return
|
||
}
|
||
|
||
// QueryContactLogs query contact logs.
|
||
func (s *Service) QueryContactLogs(c context.Context, queryRequest *model.QueryContactLogRequest) (p *model.PaginateContactLog, err error) {
|
||
var (
|
||
total int64
|
||
machineLogs []*model.AboundContactLog
|
||
)
|
||
if total, machineLogs, err = s.dao.FindMachineLogs(queryRequest); err != nil {
|
||
return
|
||
}
|
||
p = &model.PaginateContactLog{
|
||
PageNum: queryRequest.PageNum,
|
||
PageSize: queryRequest.PageSize,
|
||
Total: total,
|
||
MachineLogs: machineLogs,
|
||
}
|
||
return
|
||
}
|
||
|
||
// Wechat ...
|
||
func (s *Service) Wechat() *wechat.Wechat {
|
||
return wechat.New(s.dao)
|
||
}
|
||
|
||
// CreateWechat ...
|
||
func (s *Service) CreateWechat(c context.Context, req *model.CreateChatReq, username string) (resp *model.CreateChatResp, err error) {
|
||
var (
|
||
token string
|
||
userIDs []string
|
||
ownerInfo *model.ContactInfo
|
||
w = wechat.New(s.dao)
|
||
)
|
||
u := qyWechatURL + "/cgi-bin/appchat/create"
|
||
params := url.Values{}
|
||
wechatInfo := &model.WechatCreateLog{
|
||
Name: req.Name,
|
||
Owner: req.Owner,
|
||
ChatID: req.ChatID,
|
||
Cuser: username,
|
||
Status: 1,
|
||
}
|
||
|
||
//获取企业token
|
||
if token, err = w.AccessToken(c, conf.Conf.Property.Wechat); err != nil {
|
||
return
|
||
}
|
||
params.Set("access_token", token)
|
||
|
||
//get owner and users id
|
||
if ownerInfo, err = s.dao.QueryUserByUserName(req.Owner); err != nil {
|
||
return
|
||
}
|
||
if userIDs, err = s.QueryUserIds(req.UserList); err != nil {
|
||
return
|
||
}
|
||
|
||
req.Owner = ownerInfo.UserID
|
||
req.UserList = userIDs
|
||
if err = s.dao.PostJSON(c, u, "", params, &resp, req); err != nil {
|
||
return
|
||
}
|
||
|
||
//add create wechat info to database
|
||
if err = s.dao.AddWechatCreateLog(wechatInfo); err != nil {
|
||
return
|
||
}
|
||
|
||
resp = &model.CreateChatResp{
|
||
ChatID: wechatInfo.ChatID,
|
||
}
|
||
return
|
||
}
|
||
|
||
// QueryUserIds ...
|
||
func (s *Service) QueryUserIds(userNames []string) (userIds []string, err error) {
|
||
var (
|
||
userName string
|
||
contactInfo *model.ContactInfo
|
||
)
|
||
if len(userNames) == 0 {
|
||
err = errors.Errorf("UserIds: userNames is empty!")
|
||
return
|
||
}
|
||
|
||
for _, userName = range userNames {
|
||
if contactInfo, err = s.dao.QueryUserByUserName(userName); err != nil {
|
||
err = errors.Wrapf(err, "UserIds: no such user (%s) in db, err (%s)", userName, err.Error())
|
||
return
|
||
}
|
||
|
||
log.Info("UserIds: username (%s), userid (%s)", userName, contactInfo.UserID)
|
||
if contactInfo.UserID != "" {
|
||
userIds = append(userIds, contactInfo.UserID)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// QueryWechatCreateLog ...
|
||
func (s *Service) QueryWechatCreateLog(c context.Context, req *model.Pagination, username string) (resp *model.CreateChatLogResp, err error) {
|
||
var (
|
||
logs []*model.WechatCreateLog
|
||
logsResp []*model.CreateChatLog
|
||
total int
|
||
wechatCreateInfo *model.WechatCreateLog
|
||
)
|
||
|
||
if logs, total, err = s.dao.QueryWechatCreateLog(true, req, wechatCreateInfo); err != nil {
|
||
return
|
||
}
|
||
for _, log := range logs {
|
||
createChatlog := &model.CreateChatLog{}
|
||
if log.Cuser == username {
|
||
createChatlog.Buttons = append(createChatlog.Buttons, "WECHAT_TEST")
|
||
}
|
||
createChatlog.WechatCreateLog = log
|
||
logsResp = append(logsResp, createChatlog)
|
||
}
|
||
resp = &model.CreateChatLogResp{
|
||
Total: total,
|
||
Pagination: req,
|
||
Logs: logsResp,
|
||
}
|
||
return
|
||
}
|
||
|
||
// WechatParams ...
|
||
func (s *Service) WechatParams(c context.Context, chatid string) (resp *model.GetChatResp, err error) {
|
||
var (
|
||
w = wechat.New(s.dao)
|
||
token string
|
||
)
|
||
|
||
if token, err = w.AccessToken(c, conf.Conf.Property.Wechat); err != nil {
|
||
return
|
||
}
|
||
|
||
u := qyWechatURL + "/cgi-bin/appchat/get"
|
||
params := url.Values{}
|
||
params.Set("access_token", token)
|
||
params.Set("chatid", chatid)
|
||
err = s.dao.WechatParams(c, u, params, &resp)
|
||
return
|
||
}
|
||
|
||
// SendGroupWechat ...
|
||
func (s *Service) SendGroupWechat(c context.Context, req *model.SendChatReq) (resp *model.ChatResp, err error) {
|
||
var (
|
||
token string
|
||
w = wechat.New(s.dao)
|
||
total int
|
||
getChatResp *model.GetChatResp
|
||
owner string
|
||
contentDB = req.Text.Content
|
||
)
|
||
u := qyWechatURL + "/cgi-bin/appchat/send"
|
||
params := url.Values{}
|
||
|
||
if token, err = w.AccessToken(c, conf.Conf.Property.Wechat); err != nil {
|
||
return
|
||
}
|
||
params.Set("access_token", token)
|
||
|
||
if err = s.dao.PostJSON(c, u, "", params, &resp, req); err != nil {
|
||
return
|
||
}
|
||
if len(contentDB) > model.MaxWechatLen {
|
||
contentDB = contentDB[:model.MaxWechatLen]
|
||
}
|
||
chatLog := &model.WechatChatLog{
|
||
ChatID: req.ChatID,
|
||
MsgType: req.MsgType,
|
||
Content: contentDB,
|
||
Safe: req.Safe,
|
||
Status: 1,
|
||
}
|
||
if err = s.dao.CreateChatLog(chatLog); err != nil {
|
||
return
|
||
}
|
||
|
||
info := &model.WechatCreateLog{
|
||
ChatID: req.ChatID,
|
||
}
|
||
if _, total, err = s.dao.QueryWechatCreateLog(false, nil, info); err != nil {
|
||
return
|
||
}
|
||
|
||
if total == 0 {
|
||
getChatResp, _ = s.WechatParams(c, req.ChatID)
|
||
owner = getChatResp.ChatInfo.Owner
|
||
contactInfo, _ := s.dao.QueryUserByID(owner)
|
||
wechatInfo := &model.WechatCreateLog{
|
||
Name: getChatResp.ChatInfo.Name,
|
||
Owner: contactInfo.UserName,
|
||
ChatID: req.ChatID,
|
||
Status: 2,
|
||
}
|
||
if err = s.dao.AddWechatCreateLog(wechatInfo); err != nil {
|
||
return
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// SendWechat ...
|
||
func (s *Service) SendWechat(c context.Context, req *model.SendMessageReq) (resp *model.ChatResp, err error) {
|
||
var (
|
||
w = wechat.New(s.dao)
|
||
)
|
||
err = w.PushMsg(c, req.Touser, req.Content)
|
||
return
|
||
}
|
||
|
||
// UpdateWechat ...
|
||
func (s *Service) UpdateWechat(c context.Context, req *model.UpdateChatReq) (resp *model.ChatResp, err error) {
|
||
var (
|
||
token string
|
||
w = wechat.New(s.dao)
|
||
)
|
||
u := qyWechatURL + "/cgi-bin/appchat/update"
|
||
params := url.Values{}
|
||
|
||
if token, err = w.AccessToken(c, conf.Conf.Property.Wechat); err != nil {
|
||
return
|
||
}
|
||
params.Set("access_token", token)
|
||
if err = s.dao.PostJSON(c, u, "", params, &resp, req); err != nil {
|
||
return
|
||
}
|
||
return
|
||
}
|
||
|
||
// SyncWechatContacts ...
|
||
func (s *Service) SyncWechatContacts(c context.Context) (message string, err error) {
|
||
var (
|
||
w = wechat.New(s.dao)
|
||
)
|
||
if err = w.AnalysisContacts(c); err != nil {
|
||
return
|
||
}
|
||
message = "同步完成"
|
||
return
|
||
}
|