egg_app/app/hdl/friend_circle/hdl_friend_circle.go

package friend_circle

import (
	"applet/app/db"
	"applet/app/db/im/model"
	"applet/app/e"
	"applet/app/md/friend_circles"
	"applet/app/svc"
	svc2 "applet/app/svc/friend_circle"
	"applet/app/utils"
	"code.fnuoos.com/EggPlanet/egg_system_rules.git/md"
	svc3 "code.fnuoos.com/EggPlanet/egg_system_rules.git/svc"
	es2 "code.fnuoos.com/EggPlanet/egg_system_rules.git/utils/es"
	"code.fnuoos.com/go_rely_warehouse/zyos_go_es.git/es"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/olivere/elastic/v7"
	"strconv"
	"time"
)

// MySelfList
// @Summary      朋友圈-我的朋友圈列表
// @Tags         朋友圈
// @Description  我的朋友圈列表
// @Accept       json
// @Produce      json
// @param Authorization header string true "验证参数Bearer和token空格拼接"
// @Param    req    body	friend_circles.MySelfListReq 	true  "签名上传url"
// @Success      200   {object}   friend_circles.MySelfListResp				"返回数据"
// @Failure      400   {object}   md.Response              	"具体错误"
// @Router        /api/v1/circleFriends/mySelfList [POST]
func MySelfList(c *gin.Context) {
	var args friend_circles.MySelfListReq
	err := c.ShouldBindJSON(&args)
	if err != nil {
		err = svc.HandleValidateErr(err)
		err1 := err.(e.E)
		e.OutErr(c, err1.Code, err1.Error())
		return
	}
	resp, err := svc2.MySelfList(c, args)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	resp.Page = args.Page
	resp.PageSize = args.PageSize
	e.OutSuc(c, resp, nil)
}

// IsCanPublish
// @Summary      朋友圈-是否可以发布朋友圈
// @Tags         朋友圈
// @Description  是否可以发布朋友圈
// @Accept       json
// @Produce      json
// @param Authorization header string true "验证参数Bearer和token空格拼接"
// @Success      200   {string}  				"success"
// @Failure      400   {object}   md.Response              	"具体错误"
// @Router       /api/v1/circleFriends/isCanPublish [GET]
func IsCanPublish(c *gin.Context) {
	isCan, err := svc2.IsCanPublish(c)
	if err != nil {
		fmt.Println("IsPublish:::::", err.Error())
	}
	resp := friend_circles.IsCanCommentResp{IsCan: isCan}
	e.OutSuc(c, resp, nil)
}

// Publish
// @Summary      朋友圈-发布朋友圈
// @Tags         朋友圈
// @Description  发布朋友圈
// @Accept       json
// @Produce      json
// @param Authorization header string true "验证参数Bearer和token空格拼接"
// @Param    req    body	friend_circles.PublishReq 	true  "请求参数"
// @Success      200   {string}  				"success"
// @Failure      400   {object}   md.Response              	"具体错误"
// @Router       /api/v1/circleFriends/publish [POST]
func Publish(c *gin.Context) {
	var req friend_circles.PublishReq
	if err1 := c.ShouldBindJSON(&req); err1 != nil {
		e.OutErr(c, e.ERR_INVALID_ARGS, err1.Error())
		return
	}
	isCan, err := svc2.IsCanPublish(c)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	if !isCan {
		e.OutErr(c, e.ERR, "当前不允许发朋友圈")
		return
	}

	user := svc.GetUser(c)
	var imUser model.User
	_, err = db.DbIm.Where("phone_number = ?", user.Phone).Get(&imUser)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}

	//插入es记录
	now := time.Now()
	createDocRet, err := es.CreateDoc(md.EggFriendCircleEsIndex, strconv.FormatInt(user.Id, 10)+"_"+utils.Int64ToStr(now.Unix()), md.EggFriendCircleEs{
		Uid:         user.Id,
		ImUid:       imUser.Id,
		Kind:        1,
		Content:     req.Content,
		Image:       utils.SerializeStr(req.ImageList),
		Video:       req.Video,
		LikesNums:   0,
		ShareNums:   0,
		CommentNums: 0,
		State:       1,
		IsTopUp:     2,
		IsPraise:    2,
		CreatedAt:   now.Format("2006-01-02 15:04:05"),
		UpdatedAt:   now.Format("2006-01-02 15:04:05"),
	})

	fmt.Printf("CreateDoc ==> %+v \n\n", createDocRet)
	// 更新发朋友圈次数
	year, week := time.Now().ISOWeek()
	yearStr := utils.IntToStr(year)
	weekStr := utils.IntToStr(week)
	index := es2.GetAppointIndexFromAlias(yearStr, weekStr)
	id := fmt.Sprintf("%d%d_%d", year, week, user.Id)
	_, err = es.FirstDoc(index, id)
	if err != nil {
		if err.Error() != "elastic: Error 404 (Not Found)" {
			e.OutErr(c, e.ERR, err.Error())
			return
		} else {
			m := md.EggEnergyUserEggScoreEs{
				Uid:                    user.Id,
				SendCircleOfFriendNums: 1,
			}
			newCreateDoc, err := es.CreateDoc(index, id, &m)
			if err != nil {
				e.OutErr(c, e.ERR_DB_ORM, err.Error())
				return
			}
			fmt.Printf("newCreateDoc ==> %+v \n\n", newCreateDoc)
		}
	} else {
		script := elastic.NewScript("ctx._source.send_circle_of_friend_nums += params.inc").Param("inc", 1)
		_, err = es.EsClient.Update().
			Index(index).
			Id(id).
			Script(script).
			Do(context.Background())
		if err != nil {
			e.OutErr(c, e.ERR, err.Error())
			return
		}
	}
	e.OutSuc(c, "success", nil)
}

// RecommendList
// @Summary      朋友圈-推荐列表
// @Tags         朋友圈
// @Description  我的朋友圈列表
// @Accept       json
// @Produce      json
// @param Authorization header string true "验证参数Bearer和token空格拼接"
// @Param    req    body	friend_circles.RecommendListReq 	true  "签名上传url"
// @Success      200   {object}   friend_circles.RecommendListResp				"返回数据"
// @Failure      400   {object}   md.Response              	"具体错误"
// @Router        /api/v1/circleFriends/recommendList [POST]
func RecommendList(c *gin.Context) {
	var req friend_circles.RecommendListReq
	err := c.ShouldBindJSON(&req)
	if err != nil {
		err = svc.HandleValidateErr(err)
		err1 := err.(e.E)
		e.OutErr(c, err1.Code, err1.Error())
		return
	}
	resp, err := svc2.GetRecommendList(req)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	e.OutSuc(c, resp, nil)
}

// CommentList
// @Summary      朋友圈-评论列表
// @Tags         朋友圈
// @Description  评论列表
// @Accept       json
// @Produce      json
// @param Authorization header string true "验证参数Bearer和token空格拼接"
// @Param    circle_index_id    query	 string 	true  "朋友圈文档记录"
// @Param    req    body	friend_circles.CommentListReq 	true  "请求参数"
// @Success      200   {string}  				"success"
// @Failure      400   {object}   md.Response              	"具体错误"
// @Router       /api/v1/circleFriends/commentList [POST]
func CommentList(c *gin.Context) {
	var req friend_circles.CommentListReq
	if err1 := c.ShouldBindJSON(&req); err1 != nil {
		e.OutErr(c, e.ERR_INVALID_ARGS, err1.Error())
		return
	}
	//查找朋友圈记录
	doc, err := es.FirstDoc(md.EggFriendCircleEsIndex, req.CircleIndexId)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}
	if !doc.Found { // 表示没找到数据
		e.OutErr(c, e.ERR_NOT_FAN, "朋友圈文档记录不存在")
		return
	}

	resp, err := svc2.CommentList(req)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	e.OutSuc(c, resp, nil)
}

// CommentDetail
// @Summary      朋友圈-评论详情
// @Tags         朋友圈
// @Description  评论详情
// @Accept       json
// @Produce      json
// @param Authorization header string true "验证参数Bearer和token空格拼接"
// @Param    comment_index_id    query	 string 	true  "评论文档记录"
// @Success      200   {string}  				"success"
// @Failure      400   {object}   md.Response              	"具体错误"
// @Router       /api/v1/circleFriends/commentDetail [GET]
func CommentDetail(c *gin.Context) {
	var req friend_circles.CommentDetailReq
	if err1 := c.ShouldBindJSON(&req); err1 != nil {
		e.OutErr(c, e.ERR_INVALID_ARGS, err1.Error())
		return
	}

	//查找评论记录
	boolQuery := elastic.NewBoolQuery()
	boolQuery.Must(elastic.NewTermQuery("_id", req.CommentIndexId))
	searchResult, err := es.EsClient.Search().
		Index(md.EggFriendCircleCommentEsAlias).
		Query(boolQuery).
		Pretty(true).
		Do(context.Background())
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	var doc md.EggFriendCircleCommentEs
	// 检查是否有结果
	if searchResult.Hits.TotalHits.Value != 0 {
		err = json.Unmarshal(searchResult.Hits.Hits[0].Source, &doc)
		if err != nil {
			e.OutErr(c, e.ERR, err.Error())
			return
		}
	} else {
		e.OutErr(c, e.ERR_NOT_FAN, "评论文档记录不存在")
		return
	}

	resp, err := svc2.CommentDetail(req)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	resp.CircleIndexId = doc.CircleId
	e.OutSuc(c, resp, nil)
}

// Delete
// @Summary      朋友圈-删除朋友圈
// @Tags         朋友圈
// @Description  删除朋友圈
// @Accept       json
// @Produce      json
// @param Authorization header string true "验证参数Bearer和token空格拼接"
// @Param    req    body	friend_circles.EggFriendCircleDelReq 	true  "请求参数"
// @Success      200   {string}  				"success"
// @Failure      400   {object}   md.Response              	"具体错误"
// @Router       /api/v1/circleFriends/delete [DELETE]
func Delete(c *gin.Context) {
	var req friend_circles.EggFriendCircleDelReq
	err := c.ShouldBindJSON(&req)
	if err != nil {
		err = svc.HandleValidateErr(err)
		err1 := err.(e.E)
		e.OutErr(c, err1.Code, err1.Error())
		return
	}

	user := svc.GetUser(c)
	aliasName := md.EggFriendCircleEsAlias
	// 1.判断是否是自己文章
	doc, err := es.FirstDoc(md.EggFriendCircleEsIndex, req.CircleIndexId)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}
	if !doc.Found { // 表示没找到数据
		e.OutErr(c, e.ERR_NOT_FAN, "朋友圈文档记录不存在")
		return
	}
	var docInfo md.EggFriendCircleEs
	utils.Unserialize(doc.Source, &docInfo)
	if docInfo.Uid != user.Id {
		e.OutErr(c, e.ERR, errors.New("不允许删除别人的朋友圈"))
		return
	}

	// 2.删除文章
	deleteDocRet, err := es.DeleteDoc(aliasName, req.CircleIndexId)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	fmt.Printf("CreateDoc ==> %+v \n\n", deleteDocRet)

	// 3.将评论id推入mq
	err = svc2.DelFriendCircleComment(req.CircleIndexId)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	e.OutSuc(c, "success", nil)
}

// Share
// @Summary      朋友圈-分享后朋友圈分享数(增加)
// @Tags         朋友圈
// @Description  分享后朋友圈分享数(增加)
// @Accept       json
// @Produce      json
// @param Authorization header string true "验证参数Bearer和token空格拼接"
// @Param    req    body	friend_circles.EggFriendCircleShareReq 	true  "请求参数"
// @Success      200   {string}  				"success"
// @Failure      400   {object}   md.Response              	"具体错误"
// @Router       /api/v1/circleFriends/share [POST]
func Share(c *gin.Context) {
	var req friend_circles.EggFriendCircleShareReq
	err := c.ShouldBindJSON(&req)
	if err != nil {
		err = svc.HandleValidateErr(err)
		err1 := err.(e.E)
		e.OutErr(c, err1.Code, err1.Error())
		return
	}

	script := elastic.NewScript("ctx._source.share_nums += params.inc").Param("inc", 1)
	aliasName := md.EggFriendCircleEsAlias
	_, err = es.EsClient.Update().
		Index(aliasName).
		Id(req.CircleIndexId).
		Script(script).
		Do(context.Background())
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	e.OutSuc(c, "success", nil)
}

// Like
// @Summary      朋友圈-点赞朋友圈
// @Tags         朋友圈
// @Description  点赞朋友圈
// @Accept       json
// @Produce      json
// @param Authorization header string true "验证参数Bearer和token空格拼接"
// @Param    req    body	friend_circles.EggFriendCircleLikeReq 	true  "请求参数"
// @Success      200   {string}  				"success"
// @Failure      400   {object}   md.Response              	"具体错误"
// @Router       /api/v1/circleFriends/like [POST]
func Like(c *gin.Context) {
	var req friend_circles.EggFriendCircleLikeReq
	err := c.ShouldBindJSON(&req)
	if err != nil {
		err = svc.HandleValidateErr(err)
		err1 := err.(e.E)
		e.OutErr(c, err1.Code, err1.Error())
		return
	}
	user := svc.GetUser(c)

	likeEsIndex := svc3.GetEggFriendCircleLikeEsIndex(user.Id)
	likeId := svc3.GetEggFriendCircleLikeEsIndexId(user.Id, req.CircleIndexId)
	// 判断是否已经点赞过
	query := elastic.NewBoolQuery().
		Must(
			elastic.NewTermQuery("_id", likeId),
		)
	searchResult, err := es.EsClient.Search().Index(likeEsIndex).
		Query(query).
		Size(0). // 只关心总数，不实际返回文档
		Do(context.Background())
	if err != nil {
		return
	}
	total := searchResult.TotalHits()
	if int(total) > 0 {
		e.OutSuc(c, "success", nil)
		return
	}

	var imUser model.User
	_, err = db.DbIm.Where("phone_number = ?", user.Phone).Get(&imUser)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}

	// 新增点赞信息
	now := time.Now()
	m := md.EggFriendCircleLikeEs{
		Uid:       user.Id,
		ImUid:     imUser.Id,
		CircleId:  req.CircleIndexId,
		CreatedAt: now.Format("2006-01-02 15:04:05"),
		UpdatedAt: now.Format("2006-01-02 15:04:05"),
	}
	createDocRet, err := es.CreateDoc(likeEsIndex, likeId, &m)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	fmt.Printf("CreateDoc ==> %+v \n\n", createDocRet)

	// 增加文章点赞数
	script := elastic.NewScript("ctx._source.likes_nums += params.inc").Param("inc", 1)
	aliasName := md.EggFriendCircleEsAlias
	_, err = es.EsClient.Update().
		Index(aliasName).
		Id(req.CircleIndexId).
		Script(script).
		Do(context.Background())
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	e.OutSuc(c, "success", nil)
}

// CancelLike
// @Summary      朋友圈-取消点赞朋友圈
// @Tags         朋友圈
// @Description  取消点赞朋友圈
// @Accept       json
// @Produce      json
// @param Authorization header string true "验证参数Bearer和token空格拼接"
// @Param    req    body	friend_circles.EggFriendCircleCancelLikeReq 	true  "请求参数"
// @Success      200   {string}  				"success"
// @Failure      400   {object}   md.Response              	"具体错误"
// @Router       /api/v1/circleFriends/cancelLike [POST]
func CancelLike(c *gin.Context) {
	// 减少文章点赞数
	var req friend_circles.EggFriendCircleCancelLikeReq
	err := c.ShouldBindJSON(&req)
	if err != nil {
		err = svc.HandleValidateErr(err)
		err1 := err.(e.E)
		e.OutErr(c, err1.Code, err1.Error())
		return
	}
	user := svc.GetUser(c)

	// 删除点赞信息
	likeEsIndex := svc3.GetEggFriendCircleLikeEsIndex(user.Id)
	likeId := svc3.GetEggFriendCircleLikeEsIndexId(user.Id, req.CircleIndexId)
	deleteDocRet, err := es.DeleteDoc(likeEsIndex, likeId)
	if err != nil {
		if err.Error() == "elastic: Error 404 (Not Found)" {
			e.OutErr(c, e.ERR_BAD_REQUEST, errors.New("点赞已取消,请勿重复请求").Error())
			return
		}
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	fmt.Printf("DeleteDoc ==> %+v \n\n", deleteDocRet)

	// 减少文章点赞数
	script := elastic.NewScript("ctx._source.likes_nums -= params.inc").Param("inc", 1)
	aliasName := md.EggFriendCircleEsAlias
	_, err = es.EsClient.Update().
		Index(aliasName).
		Id(req.CircleIndexId).
		Script(script).
		Do(context.Background())
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	e.OutSuc(c, "success", nil)
}