hongze_yb/services/community/question.go

package community

import (
	"errors"
	"fmt"
	"hongze/hongze_yb/models/request"
	"hongze/hongze_yb/models/response"
	"hongze/hongze_yb/models/tables/research_group"
	"hongze/hongze_yb/models/tables/user_record"
	"hongze/hongze_yb/models/tables/yb_community_audio_listen_log"
	"hongze/hongze_yb/models/tables/yb_community_question"
	"hongze/hongze_yb/models/tables/yb_community_question_audio"
	"hongze/hongze_yb/services/user"
	"hongze/hongze_yb/services/wechat"
	"hongze/hongze_yb/utils"
	"strconv"
	"strings"
	"time"
)

// GetQuestionList 获取问答列表
func GetQuestionList(pageIndex, pageSize, onlyMine, varietyTagId, replyStatus, groupId int, userInfo user.UserInfo) (resp []*response.CommunityQuestionItem, err error) {
	condition := " is_deleted = 0"
	var pars []interface{}
	// 用户身份
	isResearcher, _, e := user.GetResearcherByUserInfo(userInfo)
	if e != nil {
		err = errors.New("获取用户身份失败 Err:" + e.Error())
		return
	}
	if onlyMine == 1 {
		if isResearcher {  //如果是研究员
			if replyStatus == 4  {  //分配给研究员未回答的问题
				condition += " and replier_user_id=? and reply_status = 2"
				pars = append(pars, userInfo.UserID)
			} else if replyStatus == 2 { //研究员提问的问题未分配或者未回答的问题
				condition += " and user_id=? and reply_status >0 and reply_status <3"
				pars = append(pars, userInfo.UserID)
			} else if replyStatus == 3 { //分配给研究员的已回答和研究员提问的被回答的问题
				condition += " and (replier_user_id=? or user_id=?) and reply_status =3"
				pars = append(pars, userInfo.UserID, userInfo.UserID)
			}else if replyStatus == 0 {  //分配给研究员或者研究员提问的所以问题
				condition += " and (replier_user_id=? or user_id=?)"
				pars = append(pars, userInfo.UserID, userInfo.UserID)
			}
		} else {
			condition += " and user_id=?"
			pars = append(pars, userInfo.UserID)
			if replyStatus == 2 {  // 普通用户未回答为待分配和未回答
				condition += " and reply_status >0 and reply_status <3"
			} else if replyStatus == 3{
				condition += " and reply_status = 3"
			}
		}
	}else{
		if replyStatus == 3 {
			condition += " and reply_status = 3"
		}
	}
	if varietyTagId > 0 {
		condition += " and variety_tag_id =?"
		pars = append(pars, varietyTagId)
	}
	if groupId > 0 {
		condition += " and research_group_second_id =?"
		pars = append(pars, groupId)
	}
	// 问题列表
	questionList, e := yb_community_question.GetPageListByCondition(condition, pars, pageIndex, pageSize)
	if e != nil {
		err = errors.New("获取问题列表失败 Err:" + e.Error())
		return
	}
	listLen := len(questionList)
	if listLen == 0 {
		return
	}
	idArr := make([]int, 0)
	for i := 0; i < listLen; i++ {
		idArr = append(idArr, questionList[i].CommunityQuestionID)
	}
	// 音频列表
	audioList, e := yb_community_question_audio.GetListByQuestrionIds(idArr)
	if e != nil {
		err = errors.New("获取音频列表失败 Err:" + e.Error())
		return
	}
	// 用户权限
	//authOk, permissionInfo, _, e := company.CheckBaseFiccPermission(userInfo.CompanyID, int(userInfo.UserID))
	//if e != nil {
	//	err = errors.New("获取用户权限失败 Err:" + e.Error())
	//	return
	//}

	userId := int(userInfo.UserID)
	resp = make([]*response.CommunityQuestionItem, 0)
	for _, v := range questionList {
		audios := make([]*response.CommunityQuestionAudioItem, 0)
		for _, a := range audioList {
			if a.CommunityQuestionID == v.CommunityQuestionID {
				audios = append(audios, &response.CommunityQuestionAudioItem{
					CommunityQuestionAudioID: a.CommunityQuestionAudioID,
					CommunityQuestionID:      a.CommunityQuestionID,
					AudioURL:                 a.AudioURL,
					AudioPlaySeconds:         a.AudioPlaySeconds,
					AudioSize:                a.AudioSize,
					Sort:                     a.Sort,
				})
			}
		}
		replierRank := fmt.Sprintf("弘则%s研究员", v.ResearchGroupFirstName)
		avatar := v.ReplierAvatar
		if avatar == "" {
			avatar = utils.HZ_DEFAULT_AVATAR
		}
		item := &response.CommunityQuestionItem{
			CommunityQuestionID:     v.CommunityQuestionID,
			UserId:                  v.UserID,
			QuestionContent:         v.QuestionContent,
			ReplierRealName:         v.ReplierRealName,
			ReplierRank:             replierRank,
			ReplierAvatar:           avatar,
			VarietyTagId:       v.VarietyTagID,
			VarietyTagName:     v.VarietyTagName,
			ResearchGroupSecondId:   v.ResearchGroupSecondID,
			ResearchGroupSecondName: v.ResearchGroupSecondName,
			IsRead:                  v.IsRead,
			ReplierUserID:           v.ReplierUserID,
			ReplierIsRead:           v.ReplierIsRead,
			ReplyStatus:             v.ReplyStatus,
			CreateTime:              v.CreateTime.Format(utils.FormatDateTime),
			ReplyTime:               v.ReplyTime.Format(utils.FormatDateTime),
			//AuthOk:                  authOk,
			//PermissionInfo:          permissionInfo,
			AudioList: audios,
		}
		if item.IsRead == 0 && item.UserId == userId {
			item.IsTop = 1
		}
		resp = append(resp, item)
	}
	return
}

// GetQuestionDetail 获取问答详情
func GetQuestionDetail(questionId int, userInfo user.UserInfo) (item *response.CommunityQuestionItem, errMsg string, err error) {
	detail, e := yb_community_question.GetItemById(questionId)
	errMsg = "获取失败"
	if e != nil {
		if e == utils.ErrNoRow {
			errMsg = "问题已被删除"
		}
		err = errors.New("获取问题详情失败 Err:" + e.Error())
		return
	}
	audioList, e := yb_community_question_audio.GetListByQuestionId(questionId)
	if e != nil {
		err = errors.New("获取问题音频失败 Err:" + e.Error())
		return
	}
	audios := make([]*response.CommunityQuestionAudioItem, 0)
	for _, a := range audioList {
		audios = append(audios, &response.CommunityQuestionAudioItem{
			CommunityQuestionAudioID: a.CommunityQuestionAudioID,
			CommunityQuestionID:      a.CommunityQuestionID,
			AudioURL:                 a.AudioURL,
			AudioPlaySeconds:         a.AudioPlaySeconds,
			AudioSize:                a.AudioSize,
			Sort:                     a.Sort,
		})
	}
	replierRank := fmt.Sprintf("弘则%s研究员", detail.ResearchGroupFirstName)
	// 用户权限
	//authOk, permissionInfo, _, e := company.CheckBaseFiccPermission(userInfo.CompanyID, int(userInfo.UserID))
	//if e != nil {
	//	err = errors.New("获取用户权限失败 Err:" + e.Error())
	//	return
	//}
	avatar := detail.ReplierAvatar
	if avatar == "" {
		avatar = utils.HZ_DEFAULT_AVATAR
	}
	item = &response.CommunityQuestionItem{
		CommunityQuestionID:     detail.CommunityQuestionID,
		UserId:                  detail.UserID,
		QuestionContent:         detail.QuestionContent,
		ReplierRealName:         detail.ReplierRealName,
		ReplierRank:             replierRank,
		ReplierAvatar:           detail.ReplierAvatar,
		VarietyTagId:       detail.VarietyTagID,
		VarietyTagName:     detail.VarietyTagName,
		ResearchGroupSecondId:   detail.ResearchGroupSecondID,
		ResearchGroupSecondName: detail.ResearchGroupSecondName,
		IsRead:                  detail.IsRead,
		ReplierIsRead:           detail.ReplierIsRead,
		ReplyStatus:             detail.ReplyStatus,
		CreateTime:              detail.CreateTime.Format(utils.FormatDateTime),
		ReplyTime:               detail.ReplyTime.Format(utils.FormatDateTime),
		//AuthOk:                  authOk,
		//PermissionInfo:          permissionInfo,
		AudioList:               audios,
	}
	errMsg = "获取成功"
	return
}

// CreateQuestion 新增问答
func CreateQuestion(userId int, mobile, realName, content string) (err error) {
	// 获取用户公众号openid, 获取不到则置空
	userRecord, e := user_record.GetByUserId(userId, utils.USER_RECORD_PLATFORM_RDDP)
	if e != nil && e != utils.ErrNoRow {
		err = errors.New("获取用户公众号openid失败 Err:" + e.Error())
		return
	}
	openid := ""
	if userRecord != nil {
		openid = userRecord.OpenID
	}
	item := &yb_community_question.YbCommunityQuestion{
		UserID:          userId,
		UserOpenid:      openid,
		Mobile:          mobile,
		RealName:        realName,
		QuestionContent: content,
		ReplyStatus:     1,
		IsRead:          1,
		ReplierIsRead:   1,
	}
	if e := item.Create(); e != nil {
		err = errors.New("新增问题失败 Err:" + e.Error())
	}
	return
}

// ReplyUserQuestion 回复问题
func ReplyUserQuestion(replierId, questionId int, audios []*request.ReplyReqAudioList) (errMsg string, err error) {
	item, e := yb_community_question.GetItemById(questionId)
	if e != nil {
		errMsg = "问答信息有误"
		err = errors.New("获取提问信息失败 Err:" + e.Error())
		return
	}
	if item.ReplyStatus < 2 {
		errMsg = "回复状态有误"
		err = errors.New("回复状态有误")
		return
	}
	if item.ReplyStatus == 3 {
		errMsg = "请勿重复提交"
		err = errors.New("问题已回复，请勿重复提交")
		return
	}
	if item.ReplierUserID != replierId {
		errMsg = "回复人不匹配"
		err = errors.New(fmt.Sprintf("回复人与分配人不匹配, 当前回复人ID: %d, 分配的回复人ID: %d", replierId, item.ReplierUserID))
		return
	}
	// 问题
	updateCols := make([]string, 0)
	updateCols = append(updateCols, "reply_status", "reply_time", "modify_time", "msg_send_status", "is_read")
	nowTime := time.Now().Local()
	item.ReplyStatus = 3
	item.ReplyTime = nowTime
	item.ModifyTime = nowTime
	item.MsgSendStatus = 2
	item.IsRead = 0
	// 音频
	audioList := make([]*yb_community_question_audio.YbCommunityQuestionAudio, 0)
	for _, v := range audios {
		audioList = append(audioList, &yb_community_question_audio.YbCommunityQuestionAudio{
			CommunityQuestionID: questionId,
			AudioURL:            v.AudioUrl,
			AudioPlaySeconds:    v.AudioPlaySeconds,
			AudioSize:           v.AudioSize,
			Sort:                v.Sort,
			CreateTime:          nowTime,
		})
	}
	if e := yb_community_question.UpdateQuestionAndAudioList(item, updateCols, audioList); e != nil {
		err = errors.New("UpdateQuestionAndAudioList Err:" + e.Error())
		return
	}
	// 推送回复消息给用户
	go wechat.SendQuestionReplyWxMsg(item.CommunityQuestionID, item.UserID, item.QuestionContent)
	return
}

// ReadQuestionReply 回复已读
func ReadQuestionReply(questionIds string, userInfo user.UserInfo) (err error) {
	if questionIds == "" {
		return
	}
	questionIdArr := make([]int, 0)
	questionIdStrArr := strings.Split(questionIds, ",")
	for _, v := range questionIdStrArr {
		i, _ := strconv.Atoi(v)
		questionIdArr = append(questionIdArr, i)
	}
	if len(questionIdArr) == 0 {
		return
	}
	isResearcher, _, e := user.GetResearcherByUserInfo(userInfo)
	if e != nil {
		err = errors.New("获取用户身份失败 Err:" + e.Error())
		return
	}
	if isResearcher {
		// 设置分配给研究员的问答已读
		e = yb_community_question.UpdateReplierRead(int(userInfo.UserID), questionIdArr)
		if e != nil {
			err = errors.New("更新问答已读失败 Err:" + e.Error())
			return
		}
		// 设置研究员提问的问答已读
		e = yb_community_question.UpdateUserRead(int(userInfo.UserID), questionIdArr)
	} else {
		// 设置普通用户的问答已读
		e = yb_community_question.UpdateUserRead(int(userInfo.UserID), questionIdArr)
	}
	if e != nil {
		err = errors.New("更新问答已读失败 Err:" + e.Error())
	}
	return
}

// GetQuestionListTotal 获取问答列表数量统计
func GetQuestionListTotal(userInfo user.UserInfo) (resp *response.CommunityQuestionListTotal, err error) {
	isResearcher, _, e := user.GetResearcherByUserInfo(userInfo)
	if e != nil {
		err = errors.New("获取用户身份失败 Err:" + e.Error())
		return
	}
	condition := " is_deleted = 0"
	var pars []interface{}
	if isResearcher {
		condition += " and (replier_user_id=? or user_id=?)"
		pars = append(pars, userInfo.UserID, userInfo.UserID)
	} else {
		condition += " and user_id=?"
		pars = append(pars, userInfo.UserID)
	}
	countList, e := yb_community_question.GetQuestionListCount(condition, pars)
	if e != nil {
		err = errors.New("获取回复人问题统计失败 Err:" + e.Error())
		return
	}
	resp = new(response.CommunityQuestionListTotal)
	var distribute, wait, replied, total int
	for _, v := range countList {
		total += v.Total
		if isResearcher {
			if v.UserId == userInfo.UserID {
				if v.ReplyStatus == 1 || v.ReplyStatus == 2 {  //研究员提问的待分配的问题
					wait += v.Total
				}
			}
			if v.ReplierUserId == userInfo.UserID  && v.ReplyStatus == 2{ //分配给研究员的未回答的问题
				distribute += v.Total
			}
			if v.ReplyStatus == 3 {
				replied += v.Total
			}
		}else{
			if v.ReplyStatus == 1 || v.ReplyStatus == 2 {  //未分配和未回答的数量
				wait += v.Total
			}else if v.ReplyStatus == 3 {  //已回答的数量
				replied += v.Total
			}
		}

	}
	if isResearcher {
		resp.Distribute = distribute
	}
	resp.Wait = wait
	resp.Replied = replied
	resp.Total = total

	return
}

// GetMyQuestionUnread 获取我的未读数
func GetMyQuestionUnread(userInfo user.UserInfo) (total int, err error) {
	isResearcher, _, e := user.GetResearcherByUserInfo(userInfo)
	if e != nil {
		err = errors.New("获取用户身份失败 Err:" + e.Error())
		return
	}
	condition := " is_deleted = 0"
	var pars []interface{}
	if isResearcher {
		condition += " and ((replier_user_id=? and replier_is_read=0) or (user_id=? and is_read=0))"
		pars = append(pars, userInfo.UserID, userInfo.UserID)
	} else {
		condition += " and user_id=? and is_read=0"
		pars = append(pars, userInfo.UserID)
	}
	num, e := yb_community_question.GetUnreadNum(condition, pars)
	if e != nil {
		err = errors.New("获取我的未读数失败 Err:" + e.Error())
		return
	}
	total = int(num)
	return
}

// GetResearchGroupTree 获取研究方向分组
func GetResearchGroupTree() (respList []*response.ResearchGroupItem, err error) {
	respList = make([]*response.ResearchGroupItem, 0)
	list, e := research_group.GetResearchGroupList()
	if e != nil {
		err = errors.New("获取研究方向分组失败, Err:" + e.Error())
		return
	}
	listLen := len(list)
	if listLen == 0 {
		return
	}
	// 分类
	firstList := make([]*response.ResearchGroupItem, 0)
	secondList := make([]*response.ResearchGroupItem, 0)
	for i := 0; i < listLen; i++ {
		item := new(response.ResearchGroupItem)
		item.ResearchGroupId = list[i].ResearchGroupID
		item.ResearchGroupName = list[i].ResearchGroupName
		item.ParentId = list[i].ParentID
		item.ChartPermissionId = list[i].ChartPermissionID
		item.Sort = list[i].Sort
		if list[i].ParentID == 0 {
			firstList = append(firstList, item)
		} else {
			secondList = append(secondList, item)
		}
	}
	if len(firstList) == 0 {
		return
	}
	// 匹配子分类
	for _, p := range firstList {
		children := make([]*response.ResearchGroupItem, 0)
		for _, child := range secondList {
			if p.ResearchGroupId == child.ParentId {
				children = append(children, child)
			}
		}
		p.Children = children
	}
	respList = firstList
	return
}

// AddAudioListenLog 添加用户点击音频日志
func AddAudioListenLog(userInfo user.UserInfo, audioId int, sourceAgent int) (err error)  {
	//1. 查询音频是否存在
	audio, err := yb_community_question_audio.GetByAudioId(audioId)
	if err != nil && err != utils.ErrNoRow {
		err = errors.New("查询音频信息失败 Err:" + err.Error())
		return
	}
	if err == utils.ErrNoRow {
		err = errors.New("音频不存在")
		return
	}
	if audio == nil {
		err = errors.New("音频不存在")
		return
	}
	//3. 添加点击日志
	item := &yb_community_audio_listen_log.YbCommunityAudioListenLog{
		CommunityQuestionAudioID: audio.CommunityQuestionAudioID,
		CommunityQuestionID:      audio.CommunityQuestionID,
		UserID:                   int(userInfo.UserID),
		SourceAgent:              sourceAgent,
	}
	if err = item.Create(); err != nil {
		err = errors.New("新增点击日志失败 Err:" + err.Error())
		return
	}
	return
}