395 lines
15 KiB
Go
395 lines
15 KiB
Go
package playerconfigs
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
"gorm.io/gorm"
|
|
"stream.api/internal/database/model"
|
|
"stream.api/internal/modules/common"
|
|
)
|
|
|
|
type Module struct {
|
|
runtime *common.Runtime
|
|
}
|
|
|
|
func New(runtime *common.Runtime) *Module {
|
|
return &Module{runtime: runtime}
|
|
}
|
|
|
|
func (m *Module) ListPlayerConfigs(ctx context.Context, queryValue ListPlayerConfigsQuery) (*ListPlayerConfigsResult, error) {
|
|
var items []model.PlayerConfig
|
|
if err := m.runtime.DB().WithContext(ctx).Where("user_id = ?", queryValue.UserID).Order("is_default DESC").Order("created_at DESC").Find(&items).Error; err != nil {
|
|
m.runtime.Logger().Error("Failed to list player configs", "error", err)
|
|
return nil, status.Error(codes.Internal, "Failed to load player configs")
|
|
}
|
|
result := &ListPlayerConfigsResult{Items: make([]PlayerConfigView, 0, len(items))}
|
|
for i := range items {
|
|
result.Items = append(result.Items, PlayerConfigView{Config: &items[i]})
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func (m *Module) CreatePlayerConfig(ctx context.Context, cmd CreatePlayerConfigCommand) (*PlayerConfigView, error) {
|
|
name := strings.TrimSpace(cmd.Name)
|
|
if name == "" {
|
|
return nil, status.Error(codes.InvalidArgument, "Name is required")
|
|
}
|
|
item := &model.PlayerConfig{ID: uuid.New().String(), UserID: cmd.UserID, Name: name, Description: common.NullableTrimmedString(cmd.Description), Autoplay: cmd.Autoplay, Loop: cmd.Loop, Muted: cmd.Muted, ShowControls: model.BoolPtr(cmd.ShowControls), Pip: model.BoolPtr(cmd.Pip), Airplay: model.BoolPtr(cmd.Airplay), Chromecast: model.BoolPtr(cmd.Chromecast), IsActive: model.BoolPtr(cmd.IsActive == nil || *cmd.IsActive), IsDefault: cmd.IsDefault != nil && *cmd.IsDefault, EncrytionM3u8: model.BoolPtr(cmd.EncrytionM3U8 == nil || *cmd.EncrytionM3U8), LogoURL: common.NullableTrimmedString(cmd.LogoURL)}
|
|
if !common.PlayerConfigIsActive(item.IsActive) {
|
|
item.IsDefault = false
|
|
}
|
|
if err := m.runtime.DB().WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
lockedUser, err := common.LockUserForUpdate(ctx, tx, cmd.UserID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var configCount int64
|
|
if err := tx.WithContext(ctx).Model(&model.PlayerConfig{}).Where("user_id = ?", cmd.UserID).Count(&configCount).Error; err != nil {
|
|
return err
|
|
}
|
|
if err := common.PlayerConfigActionAllowed(lockedUser, configCount, "create"); err != nil {
|
|
return err
|
|
}
|
|
if item.IsDefault {
|
|
if err := common.UnsetDefaultPlayerConfigs(tx, cmd.UserID, ""); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return tx.Create(item).Error
|
|
}); err != nil {
|
|
if status.Code(err) != codes.Unknown {
|
|
return nil, err
|
|
}
|
|
m.runtime.Logger().Error("Failed to create player config", "error", err)
|
|
return nil, status.Error(codes.Internal, "Failed to save player config")
|
|
}
|
|
return &PlayerConfigView{Config: item}, nil
|
|
}
|
|
|
|
func (m *Module) UpdatePlayerConfig(ctx context.Context, cmd UpdatePlayerConfigCommand) (*PlayerConfigView, error) {
|
|
if strings.TrimSpace(cmd.ID) == "" {
|
|
return nil, status.Error(codes.NotFound, "Player config not found")
|
|
}
|
|
name := strings.TrimSpace(cmd.Name)
|
|
if name == "" {
|
|
return nil, status.Error(codes.InvalidArgument, "Name is required")
|
|
}
|
|
var item model.PlayerConfig
|
|
if err := m.runtime.DB().WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
lockedUser, err := common.LockUserForUpdate(ctx, tx, cmd.UserID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var configCount int64
|
|
if err := tx.WithContext(ctx).Model(&model.PlayerConfig{}).Where("user_id = ?", cmd.UserID).Count(&configCount).Error; err != nil {
|
|
return err
|
|
}
|
|
if err := tx.WithContext(ctx).Where("id = ? AND user_id = ?", cmd.ID, cmd.UserID).First(&item).Error; err != nil {
|
|
return err
|
|
}
|
|
action := "update"
|
|
wasActive := common.PlayerConfigIsActive(item.IsActive)
|
|
if cmd.IsActive != nil && *cmd.IsActive != wasActive {
|
|
action = "toggle-active"
|
|
}
|
|
if cmd.IsDefault != nil && *cmd.IsDefault {
|
|
action = "set-default"
|
|
}
|
|
if err := common.PlayerConfigActionAllowed(lockedUser, configCount, action); err != nil {
|
|
return err
|
|
}
|
|
item.Name = name
|
|
item.Description = common.NullableTrimmedString(cmd.Description)
|
|
item.Autoplay = cmd.Autoplay
|
|
item.Loop = cmd.Loop
|
|
item.Muted = cmd.Muted
|
|
item.ShowControls = model.BoolPtr(cmd.ShowControls)
|
|
item.Pip = model.BoolPtr(cmd.Pip)
|
|
item.Airplay = model.BoolPtr(cmd.Airplay)
|
|
item.Chromecast = model.BoolPtr(cmd.Chromecast)
|
|
if cmd.EncrytionM3U8 != nil {
|
|
item.EncrytionM3u8 = model.BoolPtr(*cmd.EncrytionM3U8)
|
|
}
|
|
if cmd.LogoURL != nil {
|
|
item.LogoURL = common.NullableTrimmedString(cmd.LogoURL)
|
|
}
|
|
if cmd.IsActive != nil {
|
|
item.IsActive = model.BoolPtr(*cmd.IsActive)
|
|
}
|
|
if cmd.IsDefault != nil {
|
|
item.IsDefault = *cmd.IsDefault
|
|
}
|
|
if !common.PlayerConfigIsActive(item.IsActive) {
|
|
item.IsDefault = false
|
|
}
|
|
if item.IsDefault {
|
|
if err := common.UnsetDefaultPlayerConfigs(tx, cmd.UserID, item.ID); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return tx.Save(&item).Error
|
|
}); err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, status.Error(codes.NotFound, "Player config not found")
|
|
}
|
|
if status.Code(err) != codes.Unknown {
|
|
return nil, err
|
|
}
|
|
m.runtime.Logger().Error("Failed to update player config", "error", err)
|
|
return nil, status.Error(codes.Internal, "Failed to save player config")
|
|
}
|
|
return &PlayerConfigView{Config: &item}, nil
|
|
}
|
|
|
|
func (m *Module) DeletePlayerConfig(ctx context.Context, cmd DeletePlayerConfigCommand) error {
|
|
if strings.TrimSpace(cmd.ID) == "" {
|
|
return status.Error(codes.NotFound, "Player config not found")
|
|
}
|
|
if err := m.runtime.DB().WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
lockedUser, err := common.LockUserForUpdate(ctx, tx, cmd.UserID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var configCount int64
|
|
if err := tx.WithContext(ctx).Model(&model.PlayerConfig{}).Where("user_id = ?", cmd.UserID).Count(&configCount).Error; err != nil {
|
|
return err
|
|
}
|
|
if err := common.PlayerConfigActionAllowed(lockedUser, configCount, "delete"); err != nil {
|
|
return err
|
|
}
|
|
res := tx.Where("id = ? AND user_id = ?", cmd.ID, cmd.UserID).Delete(&model.PlayerConfig{})
|
|
if res.Error != nil {
|
|
return res.Error
|
|
}
|
|
if res.RowsAffected == 0 {
|
|
return gorm.ErrRecordNotFound
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return status.Error(codes.NotFound, "Player config not found")
|
|
}
|
|
if status.Code(err) != codes.Unknown {
|
|
return err
|
|
}
|
|
m.runtime.Logger().Error("Failed to delete player config", "error", err)
|
|
return status.Error(codes.Internal, "Failed to delete player config")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Module) ListAdminPlayerConfigs(ctx context.Context, queryValue ListAdminPlayerConfigsQuery) (*ListAdminPlayerConfigsResult, error) {
|
|
if _, err := m.runtime.RequireAdmin(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
page, limit, offset := common.AdminPageLimitOffset(queryValue.Page, queryValue.Limit)
|
|
limitInt := int(limit)
|
|
search := strings.TrimSpace(common.ProtoStringValue(queryValue.Search))
|
|
userID := strings.TrimSpace(common.ProtoStringValue(queryValue.UserID))
|
|
db := m.runtime.DB().WithContext(ctx).Model(&model.PlayerConfig{})
|
|
if search != "" {
|
|
like := "%" + search + "%"
|
|
db = db.Where("name ILIKE ?", like)
|
|
}
|
|
if userID != "" {
|
|
db = db.Where("user_id = ?", userID)
|
|
}
|
|
var total int64
|
|
if err := db.Count(&total).Error; err != nil {
|
|
return nil, status.Error(codes.Internal, "Failed to list player configs")
|
|
}
|
|
var configs []model.PlayerConfig
|
|
if err := db.Order("created_at DESC").Offset(offset).Limit(limitInt).Find(&configs).Error; err != nil {
|
|
return nil, status.Error(codes.Internal, "Failed to list player configs")
|
|
}
|
|
items := make([]AdminPlayerConfigView, 0, len(configs))
|
|
for i := range configs {
|
|
payload, err := m.buildAdminPlayerConfig(ctx, &configs[i])
|
|
if err != nil {
|
|
return nil, status.Error(codes.Internal, "Failed to list player configs")
|
|
}
|
|
items = append(items, payload)
|
|
}
|
|
return &ListAdminPlayerConfigsResult{Items: items, Total: total, Page: page, Limit: limit}, nil
|
|
}
|
|
|
|
func (m *Module) GetAdminPlayerConfig(ctx context.Context, queryValue GetAdminPlayerConfigQuery) (*AdminPlayerConfigView, error) {
|
|
if _, err := m.runtime.RequireAdmin(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
if strings.TrimSpace(queryValue.ID) == "" {
|
|
return nil, status.Error(codes.NotFound, "Player config not found")
|
|
}
|
|
var item model.PlayerConfig
|
|
if err := m.runtime.DB().WithContext(ctx).Where("id = ?", queryValue.ID).First(&item).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, status.Error(codes.NotFound, "Player config not found")
|
|
}
|
|
return nil, status.Error(codes.Internal, "Failed to load player config")
|
|
}
|
|
payload, err := m.buildAdminPlayerConfig(ctx, &item)
|
|
if err != nil {
|
|
return nil, status.Error(codes.Internal, "Failed to load player config")
|
|
}
|
|
return &payload, nil
|
|
}
|
|
|
|
func (m *Module) CreateAdminPlayerConfig(ctx context.Context, cmd CreateAdminPlayerConfigCommand) (*AdminPlayerConfigView, error) {
|
|
if _, err := m.runtime.RequireAdmin(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
if msg := validateAdminPlayerConfigInput(cmd.UserID, cmd.Name); msg != "" {
|
|
return nil, status.Error(codes.InvalidArgument, msg)
|
|
}
|
|
var user model.User
|
|
if err := m.runtime.DB().WithContext(ctx).Where("id = ?", strings.TrimSpace(cmd.UserID)).First(&user).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, status.Error(codes.InvalidArgument, "User not found")
|
|
}
|
|
return nil, status.Error(codes.Internal, "Failed to save player config")
|
|
}
|
|
item := &model.PlayerConfig{ID: uuid.New().String(), UserID: user.ID, Name: strings.TrimSpace(cmd.Name), Description: common.NullableTrimmedStringPtr(cmd.Description), Autoplay: cmd.Autoplay, Loop: cmd.Loop, Muted: cmd.Muted, ShowControls: model.BoolPtr(cmd.ShowControls), Pip: model.BoolPtr(cmd.Pip), Airplay: model.BoolPtr(cmd.Airplay), Chromecast: model.BoolPtr(cmd.Chromecast), IsActive: model.BoolPtr(cmd.IsActive), IsDefault: cmd.IsDefault, EncrytionM3u8: model.BoolPtr(cmd.EncrytionM3U8 == nil || *cmd.EncrytionM3U8), LogoURL: common.NullableTrimmedStringPtr(cmd.LogoURL)}
|
|
if !common.BoolValue(item.IsActive) {
|
|
item.IsDefault = false
|
|
}
|
|
if err := m.runtime.DB().WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
if item.IsDefault {
|
|
if err := common.UnsetDefaultPlayerConfigs(tx, item.UserID, ""); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return tx.Create(item).Error
|
|
}); err != nil {
|
|
return nil, status.Error(codes.Internal, "Failed to save player config")
|
|
}
|
|
payload, err := m.buildAdminPlayerConfig(ctx, item)
|
|
if err != nil {
|
|
return nil, status.Error(codes.Internal, "Failed to save player config")
|
|
}
|
|
return &payload, nil
|
|
}
|
|
|
|
func (m *Module) UpdateAdminPlayerConfig(ctx context.Context, cmd UpdateAdminPlayerConfigCommand) (*AdminPlayerConfigView, error) {
|
|
if _, err := m.runtime.RequireAdmin(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
if strings.TrimSpace(cmd.ID) == "" {
|
|
return nil, status.Error(codes.NotFound, "Player config not found")
|
|
}
|
|
if msg := validateAdminPlayerConfigInput(cmd.UserID, cmd.Name); msg != "" {
|
|
return nil, status.Error(codes.InvalidArgument, msg)
|
|
}
|
|
var user model.User
|
|
if err := m.runtime.DB().WithContext(ctx).Where("id = ?", strings.TrimSpace(cmd.UserID)).First(&user).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, status.Error(codes.InvalidArgument, "User not found")
|
|
}
|
|
return nil, status.Error(codes.Internal, "Failed to save player config")
|
|
}
|
|
var item model.PlayerConfig
|
|
if err := m.runtime.DB().WithContext(ctx).Where("id = ?", cmd.ID).First(&item).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, status.Error(codes.NotFound, "Player config not found")
|
|
}
|
|
return nil, status.Error(codes.Internal, "Failed to save player config")
|
|
}
|
|
item.UserID = user.ID
|
|
item.Name = strings.TrimSpace(cmd.Name)
|
|
item.Description = common.NullableTrimmedStringPtr(cmd.Description)
|
|
item.Autoplay = cmd.Autoplay
|
|
item.Loop = cmd.Loop
|
|
item.Muted = cmd.Muted
|
|
item.ShowControls = model.BoolPtr(cmd.ShowControls)
|
|
item.Pip = model.BoolPtr(cmd.Pip)
|
|
item.Airplay = model.BoolPtr(cmd.Airplay)
|
|
item.Chromecast = model.BoolPtr(cmd.Chromecast)
|
|
item.IsActive = model.BoolPtr(cmd.IsActive)
|
|
item.IsDefault = cmd.IsDefault
|
|
if cmd.EncrytionM3U8 != nil {
|
|
item.EncrytionM3u8 = model.BoolPtr(*cmd.EncrytionM3U8)
|
|
}
|
|
if cmd.LogoURL != nil {
|
|
item.LogoURL = common.NullableTrimmedStringPtr(cmd.LogoURL)
|
|
}
|
|
if !common.BoolValue(item.IsActive) {
|
|
item.IsDefault = false
|
|
}
|
|
if err := m.runtime.DB().WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
if item.IsDefault {
|
|
if err := common.UnsetDefaultPlayerConfigs(tx, item.UserID, item.ID); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return tx.Save(&item).Error
|
|
}); err != nil {
|
|
return nil, status.Error(codes.Internal, "Failed to save player config")
|
|
}
|
|
payload, err := m.buildAdminPlayerConfig(ctx, &item)
|
|
if err != nil {
|
|
return nil, status.Error(codes.Internal, "Failed to save player config")
|
|
}
|
|
return &payload, nil
|
|
}
|
|
|
|
func (m *Module) DeleteAdminPlayerConfig(ctx context.Context, cmd DeleteAdminPlayerConfigCommand) error {
|
|
if _, err := m.runtime.RequireAdmin(ctx); err != nil {
|
|
return err
|
|
}
|
|
if strings.TrimSpace(cmd.ID) == "" {
|
|
return status.Error(codes.NotFound, "Player config not found")
|
|
}
|
|
res := m.runtime.DB().WithContext(ctx).Where("id = ?", cmd.ID).Delete(&model.PlayerConfig{})
|
|
if res.Error != nil {
|
|
return status.Error(codes.Internal, "Failed to delete player config")
|
|
}
|
|
if res.RowsAffected == 0 {
|
|
return status.Error(codes.NotFound, "Player config not found")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Module) buildAdminPlayerConfig(ctx context.Context, item *model.PlayerConfig) (AdminPlayerConfigView, error) {
|
|
if item == nil {
|
|
return AdminPlayerConfigView{}, nil
|
|
}
|
|
ownerEmail, err := m.loadAdminUserEmail(ctx, item.UserID)
|
|
if err != nil {
|
|
return AdminPlayerConfigView{}, err
|
|
}
|
|
var createdAt *string
|
|
if item.CreatedAt != nil {
|
|
formatted := item.CreatedAt.UTC().Format(time.RFC3339)
|
|
createdAt = &formatted
|
|
}
|
|
updated := item.UpdatedAt.UTC().Format(time.RFC3339)
|
|
updatedAt := &updated
|
|
return AdminPlayerConfigView{ID: item.ID, UserID: item.UserID, Name: item.Name, Description: item.Description, Autoplay: item.Autoplay, Loop: item.Loop, Muted: item.Muted, ShowControls: common.BoolValue(item.ShowControls), Pip: common.BoolValue(item.Pip), Airplay: common.BoolValue(item.Airplay), Chromecast: common.BoolValue(item.Chromecast), IsActive: common.BoolValue(item.IsActive), IsDefault: item.IsDefault, OwnerEmail: ownerEmail, CreatedAt: createdAt, UpdatedAt: updatedAt, EncrytionM3U8: common.BoolValue(item.EncrytionM3u8), LogoURL: common.NullableTrimmedString(item.LogoURL)}, nil
|
|
}
|
|
|
|
func (m *Module) loadAdminUserEmail(ctx context.Context, userID string) (*string, error) {
|
|
var user model.User
|
|
if err := m.runtime.DB().WithContext(ctx).Select("id, email").Where("id = ?", userID).First(&user).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, nil
|
|
}
|
|
return nil, err
|
|
}
|
|
return common.NullableTrimmedString(&user.Email), nil
|
|
}
|
|
|
|
func validateAdminPlayerConfigInput(userID, name string) string {
|
|
if strings.TrimSpace(userID) == "" {
|
|
return "User ID is required"
|
|
}
|
|
if strings.TrimSpace(name) == "" {
|
|
return "Name is required"
|
|
}
|
|
return ""
|
|
}
|