317 lines
8.0 KiB
Go
317 lines
8.0 KiB
Go
package medias
|
|
|
|
import (
|
|
"bufio"
|
|
"context"
|
|
"database/sql"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"time"
|
|
|
|
"backend/database/models/qvyun/public/model"
|
|
"backend/database/models/qvyun/public/table"
|
|
"backend/pkg/media_store"
|
|
"backend/pkg/path"
|
|
"backend/pkg/pg"
|
|
"backend/providers/storage"
|
|
|
|
. "github.com/go-jet/jet/v2/postgres"
|
|
"github.com/grafov/m3u8"
|
|
"github.com/pkg/errors"
|
|
"github.com/samber/lo"
|
|
"github.com/sirupsen/logrus"
|
|
hashids "github.com/speps/go-hashids/v2"
|
|
"github.com/spf13/cast"
|
|
)
|
|
|
|
// @provider:except
|
|
type Service struct {
|
|
db *sql.DB
|
|
hashIds *hashids.HashID
|
|
storageConfig *storage.Config
|
|
log *logrus.Entry `inject:"false"`
|
|
}
|
|
|
|
func (svc *Service) Prepare() error {
|
|
svc.log = logrus.WithField("module", "medias.service")
|
|
return nil
|
|
}
|
|
|
|
// GetMediaByHash
|
|
func (svc *Service) GetMediaByHash(ctx context.Context, tenantId int64, hash string) (*model.Medias, error) {
|
|
log := svc.log.WithField("method", "GetMediaByHash")
|
|
|
|
tbl := table.Medias
|
|
stmt := tbl.
|
|
SELECT(tbl.AllColumns).
|
|
WHERE(
|
|
tbl.Hash.EQ(String(hash)).AND(
|
|
tbl.TenantID.EQ(Int(tenantId)),
|
|
),
|
|
)
|
|
log.Debug(stmt.DebugSql())
|
|
|
|
var m model.Medias
|
|
if err := stmt.QueryContext(ctx, svc.db, &m); err != nil {
|
|
return nil, errors.Wrapf(err, "get media by hash %s failed", hash)
|
|
}
|
|
|
|
return &m, nil
|
|
}
|
|
|
|
// GetByID
|
|
func (svc *Service) GetMediaByID(ctx context.Context, tenantId, userId, id int64) (*model.Medias, error) {
|
|
log := svc.log.WithField("method", "GetMediaByID")
|
|
|
|
tbl := table.Medias
|
|
stmt := tbl.SELECT(tbl.AllColumns).WHERE(
|
|
tbl.ID.EQ(Int(id)).AND(
|
|
tbl.TenantID.EQ(Int(tenantId)),
|
|
),
|
|
)
|
|
log.Debug(stmt.DebugSql())
|
|
|
|
var m model.Medias
|
|
if err := stmt.QueryContext(ctx, svc.db, &m); err != nil {
|
|
return nil, errors.Wrap(err, "query media by id")
|
|
}
|
|
return &m, nil
|
|
}
|
|
|
|
func (svc *Service) ModelToListItem(ctx context.Context, m *model.Medias) *ListItem {
|
|
return &ListItem{
|
|
ID: m.ID,
|
|
Hash: m.Hash,
|
|
Title: m.Title,
|
|
Description: m.Description,
|
|
Duration: m.Duration,
|
|
Price: m.Price,
|
|
Discount: m.Discount,
|
|
Resources: m.Resources,
|
|
CreatedAt: m.CreatedAt,
|
|
UpdatedAt: m.UpdatedAt,
|
|
}
|
|
}
|
|
|
|
// List
|
|
func (svc *Service) List(ctx context.Context, tenantId, userId int64, filter *ListFilter) ([]ListItem, error) {
|
|
log := svc.log.WithField("method", "List")
|
|
|
|
boughtIDs, err := svc.GetUserBoughtMedias(ctx, tenantId, userId)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "get user bought medias")
|
|
}
|
|
|
|
tbl := table.Medias
|
|
stmt := tbl.
|
|
SELECT(tbl.AllColumns).
|
|
WHERE(tbl.TenantID.EQ(Int(tenantId))).
|
|
ORDER_BY(tbl.ID.DESC())
|
|
|
|
if filter.Title != nil && *filter.Title != "" {
|
|
stmt = stmt.WHERE(tbl.Title.LIKE(String("%" + *filter.Title + "%")))
|
|
}
|
|
|
|
if filter.Bought != nil && *filter.Bought {
|
|
if len(boughtIDs) > 0 {
|
|
stmt = stmt.
|
|
WHERE(tbl.ID.IN(lo.Map(boughtIDs, func(item int64, _ int) Expression {
|
|
return Int(item)
|
|
})...))
|
|
}
|
|
} else {
|
|
stmt = stmt.WHERE(tbl.Publish.EQ(Bool(true)))
|
|
}
|
|
|
|
if filter.OffsetID > 0 {
|
|
if filter.Action == 0 {
|
|
stmt = stmt.WHERE(tbl.ID.GT(Int(filter.OffsetID)))
|
|
}
|
|
|
|
if filter.Action == 1 {
|
|
stmt = stmt.WHERE(tbl.ID.LT(Int(filter.OffsetID)))
|
|
stmt = stmt.LIMIT(10)
|
|
}
|
|
} else {
|
|
stmt = stmt.LIMIT(10)
|
|
}
|
|
log.Debug(stmt.DebugSql())
|
|
|
|
var dest []model.Medias
|
|
if err := stmt.QueryContext(ctx, svc.db, &dest); err != nil {
|
|
return nil, errors.Wrap(err, "query medias")
|
|
}
|
|
|
|
items := lo.Map(dest, func(m model.Medias, _ int) ListItem {
|
|
item := ListItem{
|
|
ID: m.ID,
|
|
Hash: m.Hash,
|
|
Title: m.Title,
|
|
Description: m.Description,
|
|
Duration: m.Duration,
|
|
Price: m.Price,
|
|
Discount: m.Discount,
|
|
Resources: m.Resources,
|
|
CreatedAt: m.CreatedAt,
|
|
UpdatedAt: m.UpdatedAt,
|
|
Bought: lo.Contains(boughtIDs, m.ID),
|
|
}
|
|
return item
|
|
})
|
|
|
|
return items, nil
|
|
}
|
|
|
|
// GetUserBoughtMedias
|
|
func (svc *Service) GetUserBoughtMedias(ctx context.Context, tenant int64, userID int64) ([]int64, error) {
|
|
log := svc.log.WithField("method", "GetUserBoughtMedias")
|
|
|
|
tbl := table.UserMedias
|
|
stmt := tbl.
|
|
SELECT(tbl.MediaID).
|
|
WHERE(
|
|
tbl.TenantID.EQ(Int(tenant)).AND(
|
|
tbl.UserID.EQ(Int(userID)),
|
|
),
|
|
)
|
|
log.Debug(stmt.Sql())
|
|
|
|
var mediaIDs []int64
|
|
if err := stmt.QueryContext(ctx, svc.db, &mediaIDs); err != nil {
|
|
return nil, errors.Wrap(err, "query user bought medias")
|
|
}
|
|
|
|
return mediaIDs, nil
|
|
}
|
|
|
|
// HasUserBought
|
|
func (svc *Service) HasUserBought(ctx context.Context, tenantId, userId, mediaId int64) (bool, error) {
|
|
log := svc.log.WithField("method", "HasUserBought")
|
|
|
|
tbl := table.UserMedias
|
|
stmt := tbl.
|
|
SELECT(COUNT(tbl.MediaID).AS("cnt")).
|
|
WHERE(
|
|
tbl.TenantID.EQ(Int(tenantId)).AND(
|
|
tbl.UserID.EQ(Int(userId)).AND(
|
|
tbl.MediaID.EQ(Int(mediaId)),
|
|
),
|
|
),
|
|
)
|
|
log.Debug(stmt.DebugSql())
|
|
|
|
var m struct {
|
|
Cnt int64
|
|
}
|
|
if err := stmt.QueryContext(ctx, svc.db, &m); err != nil {
|
|
return false, errors.Wrap(err, "query user bought media")
|
|
}
|
|
|
|
return m.Cnt > 0, nil
|
|
}
|
|
|
|
// Upsert
|
|
func (svc *Service) Upsert(ctx context.Context, tenantId int64, item media_store.VideoInfo) error {
|
|
log := svc.log.WithField("method", "Upsert")
|
|
|
|
resources := pg.MediaResources{}
|
|
if path.DirExists(filepath.Join(svc.storageConfig.Path, item.Hash, pg.MediaTypeVideo.String())) {
|
|
resources = append(resources, pg.MediaTypeVideo)
|
|
}
|
|
|
|
if path.DirExists(filepath.Join(svc.storageConfig.Path, item.Hash, pg.MediaTypeAudio.String())) {
|
|
resources = append(resources, pg.MediaTypeAudio)
|
|
}
|
|
|
|
if path.DirExists(filepath.Join(svc.storageConfig.Path, item.Hash, pg.MediaTypePdf.String())) {
|
|
resources = append(resources, pg.MediaTypePdf)
|
|
}
|
|
|
|
tbl := table.Medias
|
|
stmt := tbl.
|
|
INSERT(tbl.TenantID, tbl.Hash, tbl.Title, tbl.Price, tbl.Duration, tbl.Resources, tbl.Publish).
|
|
VALUES(Int(tenantId), String(item.Hash), String(item.Name), Int(item.Price()), Int(item.Duration), Json(resources.MustValue()), Bool(true)).
|
|
ON_CONFLICT(tbl.Hash).
|
|
DO_UPDATE(
|
|
SET(
|
|
tbl.Title.SET(String(item.Name)),
|
|
tbl.Price.SET(Int(item.Price())),
|
|
tbl.Resources.SET(Json(resources.MustValue())),
|
|
tbl.Duration.SET(Int(item.Duration)),
|
|
tbl.Publish.SET(Bool(true)),
|
|
tbl.UpdatedAt.SET(TimestampT(time.Now())),
|
|
),
|
|
)
|
|
log.Debug(stmt.DebugSql())
|
|
|
|
if _, err := stmt.ExecContext(ctx, svc.db); err != nil {
|
|
return errors.Wrapf(err, "upsert media: %s %s", item.Hash, item.Name)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// get video m3u8
|
|
func (svc *Service) GetM3U8(ctx context.Context, tenantId int64, types pg.MediaType, hash string, bought bool) (m3u8.Playlist, error) {
|
|
log := svc.log.WithField("method", "GetM3U8")
|
|
indexPath := filepath.Join(svc.storageConfig.Path, hash, types.String(), "index.m3u8")
|
|
log.Infof("m3u8 path: %s", indexPath)
|
|
|
|
f, err := os.Open(indexPath)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "open index file")
|
|
}
|
|
|
|
p, listType, err := m3u8.DecodeFrom(bufio.NewReader(f), true)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "decode index file")
|
|
}
|
|
|
|
if listType != m3u8.MEDIA {
|
|
return nil, errors.New("Invalid media file")
|
|
}
|
|
|
|
media, ok := p.(*m3u8.MediaPlaylist)
|
|
if !ok {
|
|
return nil, errors.New("Invalid media playlist")
|
|
}
|
|
media.Segments = lo.Filter(media.Segments, func(seg *m3u8.MediaSegment, _ int) bool {
|
|
return seg != nil
|
|
})
|
|
|
|
if !bought {
|
|
duration := 0
|
|
for i, seg := range media.Segments {
|
|
duration += int(seg.Duration)
|
|
if duration >= 55 {
|
|
media.Segments = media.Segments[:i]
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
for _, seg := range media.Segments {
|
|
// remove seg.URI ext, only keep the name
|
|
name, ext := path.SplitNameExt(seg.URI)
|
|
nameId, err := cast.ToInt64E(name)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "cast index to int64")
|
|
}
|
|
|
|
// get video info
|
|
hashID, err := svc.hashIds.EncodeInt64([]int64{nameId})
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "encode hash id")
|
|
}
|
|
seg.URI = fmt.Sprintf("%s/%s.%s", types, hashID, ext)
|
|
}
|
|
|
|
return media, nil
|
|
}
|
|
|
|
// GetSegmentPath
|
|
func (svc *Service) GetSegmentPath(ctx context.Context, t pg.MediaType, hash string, segment int64) string {
|
|
return filepath.Join(svc.storageConfig.Path, hash, t.String(), fmt.Sprintf("%d.ts", segment))
|
|
}
|