273 lines
7.2 KiB
Go
273 lines
7.2 KiB
Go
package http
|
|
|
|
import (
|
|
_ "embed"
|
|
"time"
|
|
|
|
"quyun/app/models"
|
|
"quyun/app/requests"
|
|
"quyun/database/fields"
|
|
"quyun/database/schemas/public/model"
|
|
"quyun/providers/ali"
|
|
"quyun/providers/wepay"
|
|
|
|
"github.com/go-pay/gopay/wechat/v3"
|
|
"github.com/gofiber/fiber/v3"
|
|
"github.com/pkg/errors"
|
|
"github.com/samber/lo"
|
|
log "github.com/sirupsen/logrus"
|
|
)
|
|
|
|
type ListQuery struct {
|
|
Keyword *string `query:"keyword"`
|
|
}
|
|
|
|
// @provider
|
|
type posts struct {
|
|
wepay *wepay.Client
|
|
oss *ali.OSSClient
|
|
}
|
|
|
|
// List posts
|
|
//
|
|
// @Router /posts [get]
|
|
// @Bind pagination query
|
|
// @Bind query query
|
|
// @Bind user local
|
|
func (ctl *posts) List(ctx fiber.Ctx, pagination *requests.Pagination, query *ListQuery, user *model.Users) (*requests.Pager, error) {
|
|
log.Infof("ok", pagination, query.Keyword, user.ID)
|
|
|
|
cond := models.Posts.BuildConditionWithKey(query.Keyword)
|
|
pager, err := models.Posts.List(ctx.Context(), pagination, cond, func(item model.Posts) model.Posts {
|
|
item.Assets = fields.ToJson([]fields.MediaAsset{})
|
|
item.Content = ""
|
|
return item
|
|
})
|
|
if err != nil {
|
|
log.WithError(err).Errorf("post list err: %v", err)
|
|
return nil, err
|
|
}
|
|
|
|
postIds := lo.Map(pager.Items.([]model.Posts), func(item model.Posts, _ int) int64 { return item.ID })
|
|
if len(postIds) > 0 {
|
|
items := lo.FilterMap(pager.Items.([]model.Posts), func(item model.Posts, _ int) (PostItem, bool) {
|
|
medias, err := models.Posts.GetMediaByIds(ctx.Context(), item.HeadImages.Data)
|
|
if err != nil {
|
|
log.Errorf("GetMediaByIds err: %v", err)
|
|
return PostItem{}, false
|
|
}
|
|
mediaUrls := lo.FilterMap(medias, func(item model.Medias, _ int) (string, bool) {
|
|
url, err := ctl.oss.GetSignedUrl(ctx.Context(), item.Path)
|
|
if err != nil {
|
|
log.WithError(err).Errorf("head image GetSignedUrl err: %v", err)
|
|
return "", false
|
|
}
|
|
|
|
return url, true
|
|
})
|
|
|
|
return PostItem{
|
|
ID: item.ID,
|
|
Title: item.Title,
|
|
Description: item.Description,
|
|
Price: item.Price,
|
|
Discount: item.Discount,
|
|
Views: item.Views,
|
|
Likes: item.Likes,
|
|
Tags: item.Tags.Data,
|
|
HeadImages: mediaUrls,
|
|
}, true
|
|
})
|
|
|
|
pager.Items = items
|
|
}
|
|
|
|
return pager, nil
|
|
}
|
|
|
|
type PostItem struct {
|
|
ID int64 `json:"id"`
|
|
Bought bool `json:"bought"`
|
|
Title string `json:"title"`
|
|
Description string `json:"description"`
|
|
Content string `json:"content"`
|
|
Price int64 `json:"price"`
|
|
Discount int16 `json:"discount"`
|
|
Views int64 `json:"views"`
|
|
Likes int64 `json:"likes"`
|
|
Tags []string `json:"tags"`
|
|
HeadImages []string `json:"head_images"`
|
|
}
|
|
|
|
// Show
|
|
//
|
|
// @Router /posts/:id/show [get]
|
|
// @Bind id path
|
|
// @Bind user local
|
|
func (ctl *posts) Show(ctx fiber.Ctx, id int64, user *model.Users) (*PostItem, error) {
|
|
log.Infof("Fetching post with ID: %d", id)
|
|
post, err := models.Posts.GetByID(ctx.Context(), id)
|
|
if err != nil {
|
|
log.WithError(err).Errorf("GetByID err: %v", err)
|
|
return nil, err
|
|
}
|
|
|
|
bought, err := models.Users.HasBought(ctx.Context(), user.ID, post.ID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
medias, err := models.Posts.GetMediaByIds(ctx.Context(), post.HeadImages.Data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
mediaUrls := lo.FilterMap(medias, func(item model.Medias, _ int) (string, bool) {
|
|
url, err := ctl.oss.GetSignedUrl(ctx.Context(), item.Path)
|
|
if err != nil {
|
|
return "", false
|
|
}
|
|
|
|
return url, true
|
|
})
|
|
|
|
return &PostItem{
|
|
ID: post.ID,
|
|
Title: post.Title,
|
|
Description: post.Description,
|
|
Content: post.Content,
|
|
Price: post.Price,
|
|
Discount: post.Discount,
|
|
Views: post.Views,
|
|
Likes: post.Likes,
|
|
Tags: post.Tags.Data,
|
|
HeadImages: mediaUrls,
|
|
Bought: bought,
|
|
}, nil
|
|
}
|
|
|
|
type PlayUrl struct {
|
|
Url string `json:"url"`
|
|
}
|
|
|
|
// Play
|
|
//
|
|
// @Router /posts/:id/play [get]
|
|
// @Bind id path
|
|
// @Bind user local
|
|
func (ctl *posts) Play(ctx fiber.Ctx, id int64, user *model.Users) (*PlayUrl, error) {
|
|
log.Infof("Fetching play URL for post ID: %d", id)
|
|
post, err := models.Posts.GetByID(ctx.Context(), id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
preview := false
|
|
bought, err := models.Users.HasBought(ctx.Context(), user.ID, post.ID)
|
|
if !bought || err != nil {
|
|
preview = true
|
|
}
|
|
|
|
for _, asset := range post.Assets.Data {
|
|
if asset.Type == "video/mp4" && asset.Metas != nil && asset.Metas.Short == preview {
|
|
media, err := models.Medias.GetByID(ctx.Context(), asset.Media)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
url, err := ctl.oss.GetSignedUrl(ctx.Context(), media.Path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PlayUrl{Url: url}, nil
|
|
}
|
|
}
|
|
return nil, errors.New("视频不存在")
|
|
}
|
|
|
|
// Mine posts
|
|
//
|
|
// @Router /posts/mine [get]
|
|
// @Bind pagination query
|
|
// @Bind query query
|
|
// @Bind user local
|
|
func (ctl *posts) Mine(ctx fiber.Ctx, pagination *requests.Pagination, query *ListQuery, user *model.Users) (*requests.Pager, error) {
|
|
log.Infof("Fetching posts for user with pagination: %+v and keyword: %v", pagination, query.Keyword)
|
|
|
|
cond := models.Posts.BuildConditionWithKey(query.Keyword)
|
|
pager, err := models.Users.PostList(ctx.Context(), 1, pagination, cond, func(item model.Posts) model.Posts {
|
|
item.Assets = fields.ToJson([]fields.MediaAsset{})
|
|
item.Content = ""
|
|
return item
|
|
})
|
|
if err != nil {
|
|
log.WithError(err).Errorf("post list err: %v", err)
|
|
return nil, err
|
|
}
|
|
|
|
postIds := lo.Map(pager.Items.([]model.Posts), func(item model.Posts, _ int) int64 { return item.ID })
|
|
if len(postIds) > 0 {
|
|
items := lo.FilterMap(pager.Items.([]model.Posts), func(item model.Posts, _ int) (PostItem, bool) {
|
|
medias, err := models.Posts.GetMediaByIds(ctx.Context(), item.HeadImages.Data)
|
|
if err != nil {
|
|
log.Errorf("GetMediaByIds err: %v", err)
|
|
return PostItem{}, false
|
|
}
|
|
mediaUrls := lo.FilterMap(medias, func(item model.Medias, _ int) (string, bool) {
|
|
url, err := ctl.oss.GetSignedUrl(ctx.Context(), item.Path)
|
|
if err != nil {
|
|
log.WithError(err).Errorf("head image GetSignedUrl err: %v", err)
|
|
return "", false
|
|
}
|
|
|
|
return url, true
|
|
})
|
|
|
|
return PostItem{
|
|
ID: item.ID,
|
|
Title: item.Title,
|
|
Description: item.Description,
|
|
Price: item.Price,
|
|
Discount: item.Discount,
|
|
Views: item.Views,
|
|
Likes: item.Likes,
|
|
Tags: item.Tags.Data,
|
|
HeadImages: mediaUrls,
|
|
}, true
|
|
})
|
|
|
|
pager.Items = items
|
|
}
|
|
return pager, nil
|
|
}
|
|
|
|
// Buy
|
|
//
|
|
// @Router /posts/:id/buy [post]
|
|
// @Bind id path
|
|
// @Bind user local
|
|
func (ctl *posts) Buy(ctx fiber.Ctx, id int64, user *model.Users) (*wechat.JSAPIPayParams, error) {
|
|
post, err := models.Posts.GetByID(ctx.Context(), id)
|
|
if err != nil {
|
|
return nil, errors.Wrapf(err, " failed to get post: %d", id)
|
|
}
|
|
|
|
// create order
|
|
order, err := models.Orders.Create(ctx.Context(), user.ID, post.ID)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "订单创建失败")
|
|
}
|
|
|
|
prePayResp, err := ctl.wepay.V3TransactionJsapi(ctx.Context(), func(bm *wepay.BodyMap) {
|
|
bm.
|
|
Expire(30 * time.Minute).
|
|
Description(post.Title).
|
|
OutTradeNo(order.OrderNo).
|
|
Payer(user.OpenID)
|
|
})
|
|
if err != nil {
|
|
log.Errorf("wepay.V3TransactionJsapi err: %v", err)
|
|
return nil, errors.Wrap(err, "微信支付失败")
|
|
}
|
|
|
|
return prePayResp.PaySignOfJSAPI()
|
|
}
|