hongze_yb/services/voice_broadcast.go

package services

import (
	"encoding/json"
	"errors"
	"fmt"
	"hongze/hongze_yb/global"
	"hongze/hongze_yb/models/response"
	admin2 "hongze/hongze_yb/models/tables/admin"
	"hongze/hongze_yb/models/tables/company_product"
	"hongze/hongze_yb/models/tables/sys_role_admin"
	"hongze/hongze_yb/models/tables/voice_broadcast"
	"hongze/hongze_yb/models/tables/voice_broadcast_statistics"
	"hongze/hongze_yb/models/tables/voice_section"
	"hongze/hongze_yb/services/user"
	"hongze/hongze_yb/services/wechat"
	"hongze/hongze_yb/utils"
	"time"
)

func GetVoiceBroadcastList(pageindex, pagesize, sectionId, broadcastId int, userInfo user.UserInfo) (list []response.Broadcast, err error) {
	if broadcastId == 0 {
		if sectionId == 0 {
			broadList, e := voice_broadcast.GetBroadcast(pageindex, pagesize)
			if e != nil {
				e = errors.New("获取语音播报列表失败 Err:" + e.Error())
			}
			for _, item := range broadList {
				var respItem response.Broadcast
				respItem = response.Broadcast{
					BroadcastId:      item.BroadcastId,
					BroadcastName:    item.BroadcastName,
					SectionId:        item.SectionId,
					SectionName:      item.SectionName,
					VarietyId:        item.VarietyId,
					VarietyName:      item.VarietyName,
					AuthorId:         item.AuthorId,
					Author:           item.Author,
					ImgUrl:           item.ImgUrl,
					VoiceUrl:         item.VoiceUrl,
					VoicePlaySeconds: item.VoicePlaySeconds,
					VoiceSize:        item.VoiceSize,
					CreateTime:       item.CreateTime,
					IsAuthor:         false,
				}
				if int(userInfo.UserID) == item.AuthorId {
					respItem.IsAuthor = true
					// 是否可以推送消息
					if item.MsgState == 0 {
						respItem.CouldSendMsg = true
					}
				}
				list = append(list, respItem)

			}
			err = e
			return
		}
		broadList, e := voice_broadcast.GetBroadcastByCondition(pageindex, pagesize, sectionId)
		if e != nil {
			e = errors.New("获取语音播报列表失败 Err:" + e.Error())
		}
		for _, item := range broadList {
			var respItem response.Broadcast
			respItem = response.Broadcast{
				BroadcastId:      item.BroadcastId,
				BroadcastName:    item.BroadcastName,
				SectionId:        item.SectionId,
				SectionName:      item.SectionName,
				VarietyId:        item.VarietyId,
				VarietyName:      item.VarietyName,
				AuthorId:         item.AuthorId,
				Author:           item.Author,
				ImgUrl:           item.ImgUrl,
				VoiceUrl:         item.VoiceUrl,
				VoicePlaySeconds: item.VoicePlaySeconds,
				VoiceSize:        item.VoiceSize,
				CreateTime:       item.CreateTime,
				IsAuthor:         false,
			}
			if int(userInfo.UserID) == item.AuthorId {
				respItem.IsAuthor = true
				// 是否可以推送消息
				if item.MsgState == 0 {
					respItem.CouldSendMsg = true
				}
			}
			list = append(list, respItem)

		}
		err = e
		return
	} else {
		broadList, e := voice_broadcast.GetBroadcastByIdAndPage(pageindex, pagesize, broadcastId)
		if e != nil {
			e = errors.New("获取语音播报列表失败 Err:" + e.Error())
		}
		for _, item := range broadList {
			var respItem response.Broadcast
			respItem = response.Broadcast{
				BroadcastId:      item.BroadcastId,
				BroadcastName:    item.BroadcastName,
				SectionId:        item.SectionId,
				SectionName:      item.SectionName,
				VarietyId:        item.VarietyId,
				VarietyName:      item.VarietyName,
				AuthorId:         item.AuthorId,
				Author:           item.Author,
				ImgUrl:           item.ImgUrl,
				VoiceUrl:         item.VoiceUrl,
				VoicePlaySeconds: item.VoicePlaySeconds,
				VoiceSize:        item.VoiceSize,
				CreateTime:       item.CreateTime,
				IsAuthor:         false,
			}
			if int(userInfo.UserID) == item.AuthorId {
				respItem.IsAuthor = true
			}
			list = append(list, respItem)

		}
		err = e
		return
	}
}

// GetVoiceAdminByUserInfo 判断当前用户是否为语音管理员
func GetVoiceAdminByUserInfo(userInfo user.UserInfo) (ok bool, adminInfo *admin2.Admin, err error) {
	mobile := userInfo.Mobile
	var email string
	if mobile == "" {
		// 用户有可能是通过邮箱登录
		email = userInfo.Email
		if email == "" {
			return
		}
	}

	if userInfo.CompanyID != 16 {
		return
	}
	if mobile != "" {
		adminInfo, err = admin2.GetAdminByMobile(mobile)
		if err != nil {
			if err == utils.ErrNoRow {
				err = nil
				return
			}
			return
		}
	} else {
		adminInfo, err = admin2.GetAdminByEmail(email)
		if err != nil {
			if err == utils.ErrNoRow {
				err = nil
				return
			}
			return
		}
	}

	if adminInfo.Enabled != 1 {
		return
	}
	_, err = sys_role_admin.GetVoiceAdmin(int(adminInfo.AdminID))
	if err != nil && err != utils.ErrNoRow {
		return
	}

	if err == utils.ErrNoRow {
		ok = false
		return
	}
	ok = true

	return
}

func AddBroadcastRecord(userinfo user.UserInfo, source, broadcastId int) {
	var err error
	defer func() {
		if err != nil {
			global.LOG.Critical(fmt.Sprintf("AddBroadcastLog: userId=%d, err:%s", userinfo.UserID, err.Error()))
		}
	}()
	companyProduct, err := company_product.GetByCompany2ProductId(userinfo.CompanyID, 1)
	if err != nil {
		return
	}
	broadcast, err := voice_broadcast.GetBroadcastById(broadcastId)
	if err != nil {
		return
	}
	voiceBroadcastStatistics := voice_broadcast_statistics.VoiceBroadcastStatistics{
		CompanyId:     companyProduct.CompanyID,
		CompanyName:   companyProduct.CompanyName,
		UserId:        int(userinfo.UserID),
		RealName:      userinfo.RealName,
		Mobile:        userinfo.Mobile,
		Email:         userinfo.Email,
		CompanyStatus: companyProduct.Status,
		Source:        source,
		BroadcastId:   broadcastId,
		BroadcastName: broadcast.BroadcastName,
		SectionId:     broadcast.SectionId,
		SectionName:   broadcast.SectionName,
		VarietyId:     broadcast.VarietyId,
		VarietyName:   broadcast.VarietyName,
		AuthorId:      broadcast.AuthorId,
		Author:        broadcast.Author,
		PublishTime:   broadcast.CreateTime,
		CreateTime:    time.Now().Format(utils.FormatDateTime),
	}
	err = voiceBroadcastStatistics.AddBroadcastStatistics()
	if err != nil {
		return
	}
	return
}

// SendBroadcastMsg 推送语音播报消息
func SendBroadcastMsg(broadcastId, userId int) (errMsg string, err error) {
	broadcast, e := voice_broadcast.GetBroadcastById(broadcastId)
	if e != nil {
		errMsg = "推送失败, 语音播报信息有误"
		err = errors.New("获取语音播报信息失败, Err: " + e.Error())
		return
	}
	if broadcast.AuthorId != userId {
		errMsg = "仅语音播报创建人可推送"
		err = errors.New("仅语音播报创建人可推送")
		return
	}
	if broadcast.MsgState != 0 {
		errMsg = "请勿重复推送"
		err = errors.New("请勿重复推送")
		return
	}
	// 更新语音播报信息
	updateCols := []string{"MsgState", "MsgTime"}
	broadcast.MsgState = 1
	broadcast.MsgTime = time.Now().Format(utils.FormatDateTime)
	if e = broadcast.Update(updateCols); e != nil {
		errMsg = "更新语音播报失败"
		err = errors.New("更新语音播报失败")
		return
	}
	// 推送模板消息
	go func() {
		_ = wechat.SendVoiceBroadcastWxMsg(broadcast.BroadcastId, broadcast.SectionName, broadcast.BroadcastName)
	}()
	// 推送客群消息
	go func() {
		_ = SendVoiceBroadcastToThs(broadcast)
	}()
	return
}

// VoiceBroadcastShareImgPars 语音播报分享图参数
type VoiceBroadcastShareImgPars struct {
	BackgroundImg string `json:"background_img"`
	Title         string `json:"title"`
	CreateTime    string `json:"create_time"`
}

// UpdateVoiceBroadcastImgUrl 更新历史语音播报分享图
func UpdateVoiceBroadcastImgUrl() (err error) {
	defer func() {
		if err != nil {
			fmt.Println(err.Error())
		}
	}()
	// 获取语音播报列表
	list, e := voice_broadcast.GetBroadcastList()
	if e != nil {
		err = errors.New("获取语音播报列表失败")
		return
	}
	// 获取语音播报板块分享图
	sectionList, e := voice_section.GetVoiceSection()
	if e != nil {
		err = errors.New("获取语音播报列表失败")
		return
	}
	sectionMap := make(map[int]string, 0)
	sectionNameMap := make(map[int]string, 0)
	for _, s := range sectionList {
		sectionMap[s.SectionId] = s.ImgUrl
		sectionNameMap[s.SectionId] = s.SectionName
	}
	// 生成语音分享图并更新
	listLen := len(list)
	fmt.Println("待更新数:", listLen)
	updateCols := []string{"ImgUrl"}
	for i := 0; i < listLen; i++ {
		item := list[i]
		fmt.Println("正在更新-Id:", item.BroadcastId)
		imgUrl := sectionMap[item.SectionId]
		if imgUrl == "" {
			fmt.Println("背景图为空-Id:", item.BroadcastId)
			continue
		}
		sectionName := sectionNameMap[item.SectionId]
		timeDate := item.CreateTime[0:10]
		pars := VoiceBroadcastShareImgPars{
			BackgroundImg: imgUrl,
			Title:         sectionName,
			CreateTime:    timeDate,
		}
		parsByte, e := json.Marshal(pars)
		if e != nil {
			err = errors.New("分享图参数有误")
			return
		}
		shareImg, e := GetDynamicShareImg(VoiceBroadcastShareImgSource, string(parsByte))
		//fmt.Println(shareImg)
		if e != nil {
			err = errors.New("生成分享图失败")
			return
		}
		item.ImgUrl = shareImg
		if e = item.Update(updateCols); e != nil {
			err = errors.New("更新语音播报失败")
			return
		}
		fmt.Println("更新成功-Id:", item.BroadcastId)
	}
	return
}