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/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())
	if err := public.RequestValidation(userInfo.PositionId); err != nil {
		userDoc.ServeJson(NewResult(nil, err))
		return
	}
	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("已兑换,请勿重复操作")
		}
		// 获取用户身份
		mData := jy.GetBigVipUserBaseMsg(userDoc.Session(), *config.Middleground)
		if mData == nil || mData.Data == nil {
			return nil, fmt.Errorf("获取用户身份信息失败")
		}
		docMemberStatus := mData.Data.Docs.Status > 0
		freeDownload := mData.Data.Docs.FreeDownload
		surplus, douding, use := int64(0), int64(0), int64(0) // 今日下载剩余次数,,今日豆丁消耗次数,今日消耗次数
		var err2 error
		payWay := "剑鱼币"
		if docInfo.ProductType == public.ProductTypeMemberFree {
			// 如果是会员免费 判断是否超出进入下载次数
			// 获取今日下载次数
			douding, use, err2 = rpc.TodayCount(userId)
			if err2 != nil {
				return nil, err2
			}
			totalLimit := config.JyDocsAppConfig.DocMember.FreeDocLimit
			if docMemberStatus {
				totalLimit = config.JyDocsAppConfig.DocMember.Times
				surplus = totalLimit - use
			} else {
				surplus = totalLimit - douding
				if surplus <= 0 { // 免费用户出错误提示直接返回
					return nil, errors.New("免费文档下载次数达到限制")
				}
			}
			if surplus <= 0 {
				surplus = 0
				use = totalLimit
				return map[string]interface{}{
					"status":  public.StatusMemberFreeExhaust,
					"surplus": surplus,
					"use":     use,
				}, nil
			}
		}
		if docMemberStatus {
			// 会员
			switch payType {
			case public.PayTypeNormal:
				if docInfo.ProductType == public.ProductTypeMemberFree {
					//  没有超过下载次数  下一步应该到转存 不用扣剑鱼币
					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.ImgId,
				"fType":   docInfo.DocFileType,
				"source":  docInfo.Source,
			})
			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 {
			// 如果是精品文档 或者 是免费文档剑鱼文库会员超过10篇   则需要先调购买接口
			if docInfo.ProductType == int64(public.ProductTypePremium) || douding >= config.JyDocsAppConfig.DocMember.FreeDocLimit {
				buyType := common.If(docMemberStatus, public.DdUserBuyType0, public.DdUserBuyType1).(int)
				_, err2 := rpc.PartUserBuy(docId, userInfo.MgoUserId, userInfo.Phone, userInfo.PositionId, int64(buyType))
				if err2 != nil {
					log.Println("PartUserBuy 获取失败")
				}
			}
			// 下载接口
			_, err := rpc.PartDocDownload(docId, userInfo.MgoUserId, userInfo.Phone, userInfo.PositionId)
			if err != nil {
				log.Println("PartDocDownload 获取失败")
			}
		}
		//转存文库
		err = rpc.PayDoc(userId, docId)
		if err != nil {
			return nil, err
		}
		if useSLTimes {
			public.Compatible.Update(userId, map[string]interface{}{
				"$set": map[string]interface{}{
					"i_doc_free_download": int(1),
				},
			})
			config.Middleground.PowerCheckCenter.DelCheckRedis(public.AppID, 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)
		}()
		if payWay == "会员免费特权" {
			surplus = surplus - 1
			use = use + 1
		}
		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))
}