jy-docs/jydocs-back/servers/userDoc.go

package servers

import (
	. "app.yhyue.com/moapp/jybase/api"
	"app.yhyue.com/moapp/jybase/common"
	"app.yhyue.com/moapp/jybase/go-xweb/httpsession"
	"app.yhyue.com/moapp/jybase/go-xweb/xweb"
	"app.yhyue.com/moapp/jypkg/common/src/qfw/util/jy"
	"encoding/json"
	"errors"
	"fmt"
	"jy-docs/config"
	"jy-docs/public"
	"jy-docs/rpc"
	"log"
	"time"
)

type UserDoc struct {
	*xweb.Action
	userList      xweb.Mapper `xweb:"/user/list"`           //用户列表
	collectAdd    xweb.Mapper `xweb:"/user/collect/add"`    //收藏文库
	collectRemove xweb.Mapper `xweb:"/user/collect/remove"` //取消收藏
	docBuy        xweb.Mapper `xweb:"/user/buy"`            //文库购买
}

// 用户文库列表
func (userDoc *UserDoc) UserList() {
	userId := common.ObjToString(userDoc.GetSession("userId"))
	rData, errMsg := func() (interface{}, error) {
		pageNumReq, _ := userDoc.GetInt("num")
		pageSizeReq, _ := userDoc.GetInt("size")
		sign, _ := userDoc.GetInt("sign") // 0兑换的 1收藏的 2回收站的
		pageNum, pageSize, _ := public.PageNumParse(pageNumReq, pageSizeReq, -1)
		if sign < 0 || sign > 2 {
			return nil, fmt.Errorf("请求参数异常")
		}
		collectList, total, err := rpc.GetUserDocs(userId, pageNum, pageSize, sign)
		if err != nil {
			return nil, err
		}
		return map[string]interface{}{
			"total": total,
			"list":  collectList,
		}, nil
	}()
	if errMsg != nil {
		log.Printf("%s UserDoc collectList err:%s\n", userId, errMsg.Error())
	}
	userDoc.ServeJson(NewResult(rData, errMsg))
}

func (userDoc *UserDoc) CollectAdd() {
	userId := common.ObjToString(userDoc.GetSession("userId"))
	rData, errMsg := func() (interface{}, error) {
		docId := userDoc.GetString("docId")
		if docId == "" {
			return nil, fmt.Errorf("参数异常")
		}
		err := rpc.SetUserCollect(userId, docId)
		if err != nil {
			return nil, err
		}
		return "success", nil
	}()
	if errMsg != nil {
		log.Printf("%s UserDoc collectAdd err:%s\n", userId, errMsg.Error())
	}
	userDoc.ServeJson(NewResult(rData, errMsg))
}

func (userDoc *UserDoc) CollectRemove() {
	userId := common.ObjToString(userDoc.GetSession("userId"))
	rData, errMsg := func() (interface{}, error) {
		docId := userDoc.GetString("docId")
		if docId == "" {
			return nil, fmt.Errorf("参数异常")
		}
		err := rpc.DelUserCollect(userId, docId)
		if err != nil {
			return nil, err
		}
		return "success", nil
	}()
	if errMsg != nil {
		log.Printf("%s UserDoc collectRemove err:%s\n", userId, errMsg.Error())
	}
	userDoc.ServeJson(NewResult(rData, errMsg))
}

func (userDoc *UserDoc) DocBuy() {
	// 加用户锁
	userInfo := public.GetUserBaseInfo(userDoc.Session())
	userId := userInfo.UserId
	pLock := public.GetNewDocBuyLock(fmt.Sprintf("%s", userId))
	pLock.Lock()
	defer pLock.Unlock()
	rData, errMsg := func() (interface{}, error) {
		docId := userDoc.GetString("docId")
		phone := userDoc.GetString("phone")
		payType, _ := userDoc.GetInt("payType") // 0-正常下载  1-原价下载 2-使用一次免费下载机会（会员免费文档 留资）
		if docId == "" {
			return nil, fmt.Errorf("参数异常")
		}
		var userPoint, docPoint int64 = 0, 0
		var err error
		usePoint := true    // 是否消耗剑鱼币  会员免费文档且当天100篇以内的或者使用免费下载机会的 不用扣积分
		useSLTimes := false // 使用留资机会的下载次数
		//查询文档所需积分及文档类型
		docInfo, isBuy, _, err := rpc.GetDocDetail(userId, docId, true)
		if err != nil {
			return nil, err
		}
		if isBuy {
			return nil, fmt.Errorf("已兑换,请勿重复操作")
		}
		// 获取用户身份
		docMember, err := getDocMemberStatus(userDoc.Session())
		if err != nil {
			return nil, err
		}
		docMemberStatus := docMember["docMemberStatus"].(bool)
		freeDownload := common.IntAll(docMember["free_download"])
		surplus, use := 0, 0 // 今日下载剩余次数,今日消耗次数
		payWay := "剑鱼币"
		if docMemberStatus {
			// 会员
			switch payType {
			case public.PayTypeNormal:
				if docInfo.ProductType == public.ProductTypeMemberFree {
					// 如果是会员免费 判断是否超出进入下载次数
					// 获取今日下载次数
					count, err2 := rpc.TodayCount(userId)

					if err2 != nil {
						return nil, err2
					}
					use = int(count)
					surplus = config.JyDocsAppConfig.DocMember.Times - use
					if surplus <= 0 {
						surplus = 0
						use = config.JyDocsAppConfig.DocMember.Times
						return map[string]interface{}{
							"status":  public.StatusMemberFreeExhaust,
							"surplus": surplus,
							"use":     use,
						}, nil
					}
					//  没有超过下载次数  下一步应该到转存 不用扣剑鱼币
					usePoint = false
					docPoint = docInfo.DocMemberPrice
					payWay = "会员免费特权"
				} else {
					// 精品文档
					docPoint = docInfo.DocMemberPrice // 会员价
				}
			case public.PayTypeFullPrice:
				docPoint = docInfo.Price
			default:
				return nil, errors.New("payType类型不匹配")
			}
		} else {
			switch payType {
			case public.PayTypeFreeSL:
				if freeDownload != public.FreeDownloadHasFreeTimes || docInfo.ProductType != public.ProductTypeMemberFree {
					return nil, fmt.Errorf("没有免费下载机会")
				}
				usePoint = false  // 免费下载的不扣剑鱼币
				useSLTimes = true // 后边要处理该字段
				docPoint = 0
				payWay = "免费下载特权"
			case public.PayTypeFullPrice:
				docPoint = docInfo.Price // 原价下的
			default:
				return nil, errors.New("payType类型不匹配")
			}
		}
		var serialNumber string
		if usePoint { // 扣积分
			//查询用户剩余积分
			userPoint, err = rpc.GetUserPointValue(userId)
			if err != nil {
				return nil, err
			}
			//积分够调扣积分
			if userPoint < docPoint {
				return nil, fmt.Errorf("剩余积分不足")
			}
			bytes, err := json.Marshal(map[string]interface{}{
				"name":    docInfo.DocName,
				"summary": docInfo.DocSummary,
				"img":     docInfo.PreviewImgId,
				"fType":   docInfo.DocFileType,
			})
			if err != nil {
				return nil, fmt.Errorf("文库异常")
			}
			serialNumber, err = rpc.SpendUserPoint(userId, docInfo.DocId, string(bytes), docPoint)
			if err != nil {
				return nil, err
			}
		}
		// 没有ossdocId 说明是还没有下过的 需要先获得地址
		if docInfo.OssDocId == "" && docInfo.Source == public.SourceDd {
			// 如果是精品 则需要先调购买接口
			if docInfo.ProductType == public.ProductTypePremium {
				_, err2 := rpc.PartUserBuy(docId, userInfo.MgoUserId, userInfo.Phone, userInfo.PositionId)
				if err2 != nil {
					return nil, fmt.Errorf("获取失败")
				}
			}
			// 如果是免费则直接调
			_, err := rpc.PartDocDownload(docId, userInfo.MgoUserId, userInfo.Phone, userInfo.PositionId)
			if err != nil {
				return nil, fmt.Errorf("获取失败")
			}
		}
		//转存文库
		err = rpc.PayDoc(userId, docId)
		if err != nil {
			return nil, err
		}
		if useSLTimes {
			public.Compatible.Update(userId, map[string]interface{}{
				"$set": M{
					"i_doc_free_download": 1,
				},
			})
			jy.ClearBigVipUserPower(fmt.Sprint(userInfo.PositionId))
		}
		//手机号采集
		go func() {
			if phone != "" {
				public.MQFW.Save("user_msg", map[string]interface{}{
					"s_userId":     userId,
					"s_phone":      phone,
					"i_phoneCheck": -1, //未验证
					"i_time":       time.Now().Unix(),
					"s_source":     "jydoc",
				})
			}
			rpc.DocStatistics(userId, docId, rpc.Down)
		}()
		return map[string]interface{}{
			"status":  0,
			"surplus": surplus,
			"use":     use,
			"code":    serialNumber,
			"balance": userPoint - docPoint,
			"payTime": time.Now().Unix(),
			"payWay":  payWay,
		}, nil
	}()
	if errMsg != nil {
		log.Printf("%s UserDoc docBuy err:%s\n", userId, errMsg.Error())
	}
	userDoc.ServeJson(NewResult(rData, errMsg))
}

func getDocMemberStatus(session *httpsession.Session) (map[string]interface{}, error) {
	mData := jy.GetBigVipUserBaseMsg(session, *config.Middleground)
	if mData != nil {
		vipStatus := mData.Data.Docs.Status
		return map[string]interface{}{
			"docMemberStatus": vipStatus > 0,
			"startTime":       mData.Data.Docs.StartDate,
			"endTime":         mData.Data.Docs.EndDate,
			"free_download":   mData.Data.Docs.FreeDownload,
		}, nil
	}
	return nil, errors.New("获取文库会员状态失败")
}