620 lines
18 KiB
Go
620 lines
18 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
"google.golang.org/protobuf/types/known/timestamppb"
|
|
"gorm.io/gorm"
|
|
appv1 "stream.api/internal/api/proto/app/v1"
|
|
"stream.api/internal/database/model"
|
|
"stream.api/internal/dto"
|
|
"stream.api/internal/middleware"
|
|
)
|
|
|
|
func (s *appServices) requireAdmin(ctx context.Context) (*middleware.AuthResult, error) {
|
|
result, err := s.authenticate(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if result.User == nil || result.User.Role == nil || strings.ToUpper(strings.TrimSpace(*result.User.Role)) != "ADMIN" {
|
|
return nil, status.Error(codes.PermissionDenied, "Admin access required")
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func (s *appServices) ensurePlanExists(ctx context.Context, planID *string) error {
|
|
if planID == nil {
|
|
return nil
|
|
}
|
|
trimmed := strings.TrimSpace(*planID)
|
|
if trimmed == "" {
|
|
return nil
|
|
}
|
|
var count int64
|
|
if err := s.db.WithContext(ctx).Model(&model.Plan{}).Where("id = ?", trimmed).Count(&count).Error; err != nil {
|
|
return status.Error(codes.Internal, "Failed to validate plan")
|
|
}
|
|
if count == 0 {
|
|
return status.Error(codes.InvalidArgument, "Plan not found")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *appServices) saveAdminVideoAdConfig(ctx context.Context, tx *gorm.DB, video *model.Video, userID string, adTemplateID *string) error {
|
|
if video == nil || adTemplateID == nil {
|
|
return nil
|
|
}
|
|
|
|
trimmed := strings.TrimSpace(*adTemplateID)
|
|
if trimmed == "" {
|
|
if err := tx.WithContext(ctx).Model(&model.Video{}).Where("id = ?", video.ID).Update("ad_id", nil).Error; err != nil {
|
|
return err
|
|
}
|
|
video.AdID = nil
|
|
return nil
|
|
}
|
|
|
|
var template model.AdTemplate
|
|
if err := tx.WithContext(ctx).Select("id").Where("id = ? AND user_id = ?", trimmed, userID).First(&template).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return errors.New("Ad template not found")
|
|
}
|
|
return err
|
|
}
|
|
|
|
if err := tx.WithContext(ctx).Model(&model.Video{}).Where("id = ?", video.ID).Update("ad_id", template.ID).Error; err != nil {
|
|
return err
|
|
}
|
|
video.AdID = &template.ID
|
|
return nil
|
|
}
|
|
|
|
func adminPageLimitOffset(pageValue int32, limitValue int32) (int32, int32, int) {
|
|
page := pageValue
|
|
if page < 1 {
|
|
page = 1
|
|
}
|
|
limit := limitValue
|
|
if limit <= 0 {
|
|
limit = 20
|
|
}
|
|
if limit > 100 {
|
|
limit = 100
|
|
}
|
|
offset := int((page - 1) * limit)
|
|
return page, limit, offset
|
|
}
|
|
|
|
func buildAdminJob(job *model.Job) *appv1.AdminJob {
|
|
if job == nil {
|
|
return nil
|
|
}
|
|
agentID := strconv.FormatInt(*job.AgentID, 10)
|
|
return &appv1.AdminJob{
|
|
Id: job.ID,
|
|
Status: string(*job.Status),
|
|
Priority: int32(*job.Priority),
|
|
UserId: *job.UserID,
|
|
Name: job.ID,
|
|
TimeLimit: *job.TimeLimit,
|
|
InputUrl: *job.InputURL,
|
|
OutputUrl: *job.OutputURL,
|
|
TotalDuration: *job.TotalDuration,
|
|
CurrentTime: *job.CurrentTime,
|
|
Progress: *job.Progress,
|
|
AgentId: &agentID,
|
|
Logs: *job.Logs,
|
|
Config: *job.Config,
|
|
Cancelled: *job.Cancelled,
|
|
RetryCount: int32(*job.RetryCount),
|
|
MaxRetries: int32(*job.MaxRetries),
|
|
CreatedAt: timestamppb.New(*job.CreatedAt),
|
|
UpdatedAt: timestamppb.New(*job.UpdatedAt),
|
|
VideoId: stringPointerOrNil(*job.VideoID),
|
|
}
|
|
}
|
|
|
|
func buildAdminAgent(agent *dto.AgentWithStats) *appv1.AdminAgent {
|
|
if agent == nil || agent.Agent == nil {
|
|
return nil
|
|
}
|
|
return &appv1.AdminAgent{
|
|
Id: agent.ID,
|
|
Name: agent.Name,
|
|
Platform: agent.Platform,
|
|
Backend: agent.Backend,
|
|
Version: agent.Version,
|
|
Capacity: agent.Capacity,
|
|
Status: string(agent.Status),
|
|
Cpu: agent.CPU,
|
|
Ram: agent.RAM,
|
|
LastHeartbeat: timestamppb.New(agent.LastHeartbeat),
|
|
CreatedAt: timestamppb.New(agent.CreatedAt),
|
|
UpdatedAt: timestamppb.New(agent.UpdatedAt),
|
|
}
|
|
}
|
|
|
|
func normalizeAdminRoleValue(value string) string {
|
|
role := strings.ToUpper(strings.TrimSpace(value))
|
|
if role == "" {
|
|
return "USER"
|
|
}
|
|
return role
|
|
}
|
|
|
|
func isValidAdminRoleValue(role string) bool {
|
|
switch normalizeAdminRoleValue(role) {
|
|
case "USER", "ADMIN", "BLOCK":
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func (s *appServices) buildAdminUser(ctx context.Context, user *model.User) (*appv1.AdminUser, error) {
|
|
if user == nil {
|
|
return nil, nil
|
|
}
|
|
|
|
payload := &appv1.AdminUser{
|
|
Id: user.ID,
|
|
Email: user.Email,
|
|
Username: nullableTrimmedString(user.Username),
|
|
Avatar: nullableTrimmedString(user.Avatar),
|
|
Role: nullableTrimmedString(user.Role),
|
|
PlanId: nullableTrimmedString(user.PlanID),
|
|
StorageUsed: user.StorageUsed,
|
|
CreatedAt: timeToProto(user.CreatedAt),
|
|
UpdatedAt: timestamppb.New(user.UpdatedAt.UTC()),
|
|
WalletBalance: 0,
|
|
}
|
|
|
|
videoCount, err := s.loadAdminUserVideoCount(ctx, user.ID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
payload.VideoCount = videoCount
|
|
|
|
walletBalance, err := model.GetWalletBalance(ctx, s.db, user.ID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
payload.WalletBalance = walletBalance
|
|
|
|
planName, err := s.loadAdminPlanName(ctx, user.PlanID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
payload.PlanName = planName
|
|
|
|
return payload, nil
|
|
}
|
|
|
|
func (s *appServices) buildAdminUserDetail(ctx context.Context, user *model.User, subscription *model.PlanSubscription) (*appv1.AdminUserDetail, error) {
|
|
payload, err := s.buildAdminUser(ctx, user)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
referral, err := s.buildAdminUserReferralInfo(ctx, user)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &appv1.AdminUserDetail{
|
|
User: payload,
|
|
Subscription: toProtoPlanSubscription(subscription),
|
|
Referral: referral,
|
|
}, nil
|
|
}
|
|
|
|
func (s *appServices) buildAdminUserReferralInfo(ctx context.Context, user *model.User) (*appv1.AdminUserReferralInfo, error) {
|
|
if user == nil {
|
|
return nil, nil
|
|
}
|
|
|
|
var referrer *appv1.ReferralUserSummary
|
|
if user.ReferredByUserID != nil && strings.TrimSpace(*user.ReferredByUserID) != "" {
|
|
loadedReferrer, err := s.loadReferralUserSummary(ctx, strings.TrimSpace(*user.ReferredByUserID))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
referrer = loadedReferrer
|
|
}
|
|
|
|
bps := effectiveReferralRewardBps(user.ReferralRewardBps)
|
|
referral := &appv1.AdminUserReferralInfo{
|
|
Referrer: referrer,
|
|
ReferralEligible: referralUserEligible(user),
|
|
EffectiveRewardPercent: referralRewardBpsToPercent(bps),
|
|
RewardOverridePercent: func() *float64 {
|
|
if user.ReferralRewardBps == nil {
|
|
return nil
|
|
}
|
|
value := referralRewardBpsToPercent(*user.ReferralRewardBps)
|
|
return &value
|
|
}(),
|
|
ShareLink: s.buildReferralShareLink(user.Username),
|
|
RewardGranted: referralRewardProcessed(user),
|
|
RewardGrantedAt: timeToProto(user.ReferralRewardGrantedAt),
|
|
RewardPaymentId: nullableTrimmedString(user.ReferralRewardPaymentID),
|
|
RewardAmount: user.ReferralRewardAmount,
|
|
}
|
|
return referral, nil
|
|
}
|
|
|
|
func (s *appServices) buildAdminVideo(ctx context.Context, video *model.Video) (*appv1.AdminVideo, error) {
|
|
if video == nil {
|
|
return nil, nil
|
|
}
|
|
|
|
statusValue := stringValue(video.Status)
|
|
if statusValue == "" {
|
|
statusValue = "ready"
|
|
}
|
|
jobID, err := s.loadLatestVideoJobID(ctx, video.ID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
payload := &appv1.AdminVideo{
|
|
Id: video.ID,
|
|
UserId: video.UserID,
|
|
Title: video.Title,
|
|
Description: nullableTrimmedString(video.Description),
|
|
Url: video.URL,
|
|
Status: strings.ToLower(statusValue),
|
|
Size: video.Size,
|
|
Duration: video.Duration,
|
|
Format: video.Format,
|
|
CreatedAt: timeToProto(video.CreatedAt),
|
|
UpdatedAt: timestamppb.New(video.UpdatedAt.UTC()),
|
|
ProcessingStatus: nullableTrimmedString(video.ProcessingStatus),
|
|
JobId: jobID,
|
|
}
|
|
|
|
ownerEmail, err := s.loadAdminUserEmail(ctx, video.UserID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
payload.OwnerEmail = ownerEmail
|
|
|
|
adTemplateID, adTemplateName, err := s.loadAdminVideoAdTemplateDetails(ctx, video)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
payload.AdTemplateId = adTemplateID
|
|
payload.AdTemplateName = adTemplateName
|
|
|
|
return payload, nil
|
|
}
|
|
|
|
func (s *appServices) buildAdminPayment(ctx context.Context, payment *model.Payment) (*appv1.AdminPayment, error) {
|
|
if payment == nil {
|
|
return nil, nil
|
|
}
|
|
|
|
payload := &appv1.AdminPayment{
|
|
Id: payment.ID,
|
|
UserId: payment.UserID,
|
|
PlanId: nullableTrimmedString(payment.PlanID),
|
|
Amount: payment.Amount,
|
|
Currency: normalizeCurrency(payment.Currency),
|
|
Status: normalizePaymentStatus(payment.Status),
|
|
Provider: strings.ToUpper(stringValue(payment.Provider)),
|
|
TransactionId: nullableTrimmedString(payment.TransactionID),
|
|
InvoiceId: payment.ID,
|
|
CreatedAt: timeToProto(payment.CreatedAt),
|
|
UpdatedAt: timestamppb.New(payment.UpdatedAt.UTC()),
|
|
}
|
|
|
|
userEmail, err := s.loadAdminUserEmail(ctx, payment.UserID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
payload.UserEmail = userEmail
|
|
|
|
planName, err := s.loadAdminPlanName(ctx, payment.PlanID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
payload.PlanName = planName
|
|
|
|
termMonths, paymentMethod, expiresAt, walletAmount, topupAmount, err := s.loadAdminPaymentSubscriptionDetails(ctx, payment.ID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
payload.TermMonths = termMonths
|
|
payload.PaymentMethod = paymentMethod
|
|
payload.ExpiresAt = expiresAt
|
|
payload.WalletAmount = walletAmount
|
|
payload.TopupAmount = topupAmount
|
|
|
|
return payload, nil
|
|
}
|
|
|
|
func (s *appServices) loadAdminUserVideoCount(ctx context.Context, userID string) (int64, error) {
|
|
var videoCount int64
|
|
if err := s.db.WithContext(ctx).Model(&model.Video{}).Where("user_id = ?", userID).Count(&videoCount).Error; err != nil {
|
|
return 0, err
|
|
}
|
|
return videoCount, nil
|
|
}
|
|
|
|
func (s *appServices) loadAdminUserEmail(ctx context.Context, userID string) (*string, error) {
|
|
var user model.User
|
|
if err := s.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 nullableTrimmedString(&user.Email), nil
|
|
}
|
|
|
|
func (s *appServices) loadReferralUserSummary(ctx context.Context, userID string) (*appv1.ReferralUserSummary, error) {
|
|
if strings.TrimSpace(userID) == "" {
|
|
return nil, nil
|
|
}
|
|
var user model.User
|
|
if err := s.db.WithContext(ctx).Select("id, email, username").Where("id = ?", userID).First(&user).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, nil
|
|
}
|
|
return nil, err
|
|
}
|
|
return &appv1.ReferralUserSummary{
|
|
Id: user.ID,
|
|
Email: user.Email,
|
|
Username: nullableTrimmedString(user.Username),
|
|
}, nil
|
|
}
|
|
|
|
func (s *appServices) loadAdminPlanName(ctx context.Context, planID *string) (*string, error) {
|
|
if planID == nil || strings.TrimSpace(*planID) == "" {
|
|
return nil, nil
|
|
}
|
|
var plan model.Plan
|
|
if err := s.db.WithContext(ctx).Select("id, name").Where("id = ?", *planID).First(&plan).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, nil
|
|
}
|
|
return nil, err
|
|
}
|
|
return nullableTrimmedString(&plan.Name), nil
|
|
}
|
|
|
|
func (s *appServices) loadAdminVideoAdTemplateDetails(ctx context.Context, video *model.Video) (*string, *string, error) {
|
|
if video == nil {
|
|
return nil, nil, nil
|
|
}
|
|
adTemplateID := nullableTrimmedString(video.AdID)
|
|
if adTemplateID == nil {
|
|
return nil, nil, nil
|
|
}
|
|
adTemplateName, err := s.loadAdminAdTemplateName(ctx, *adTemplateID)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
return adTemplateID, adTemplateName, nil
|
|
}
|
|
|
|
func (s *appServices) loadAdminAdTemplateName(ctx context.Context, adTemplateID string) (*string, error) {
|
|
var template model.AdTemplate
|
|
if err := s.db.WithContext(ctx).Select("id, name").Where("id = ?", adTemplateID).First(&template).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, nil
|
|
}
|
|
return nil, err
|
|
}
|
|
return nullableTrimmedString(&template.Name), nil
|
|
}
|
|
|
|
func (s *appServices) loadLatestVideoJobID(ctx context.Context, videoID string) (*string, error) {
|
|
videoID = strings.TrimSpace(videoID)
|
|
if videoID == "" {
|
|
return nil, nil
|
|
}
|
|
|
|
var job model.Job
|
|
if err := s.db.WithContext(ctx).
|
|
Where("config::jsonb ->> 'video_id' = ?", videoID).
|
|
Order("created_at DESC").
|
|
First(&job).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, nil
|
|
}
|
|
return nil, err
|
|
}
|
|
return stringPointerOrNil(job.ID), nil
|
|
}
|
|
|
|
func (s *appServices) loadAdminPaymentSubscriptionDetails(ctx context.Context, paymentID string) (*int32, *string, *string, *float64, *float64, error) {
|
|
var subscription model.PlanSubscription
|
|
if err := s.db.WithContext(ctx).Where("payment_id = ?", paymentID).Order("created_at DESC").First(&subscription).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, nil, nil, nil, nil, nil
|
|
}
|
|
return nil, nil, nil, nil, nil, err
|
|
}
|
|
termMonths := subscription.TermMonths
|
|
paymentMethod := nullableTrimmedString(&subscription.PaymentMethod)
|
|
expiresAt := subscription.ExpiresAt.UTC().Format(time.RFC3339)
|
|
walletAmount := subscription.WalletAmount
|
|
topupAmount := subscription.TopupAmount
|
|
return &termMonths, paymentMethod, nullableTrimmedString(&expiresAt), &walletAmount, &topupAmount, nil
|
|
}
|
|
|
|
func (s *appServices) loadAdminPlanUsageCounts(ctx context.Context, planID string) (int64, int64, int64, error) {
|
|
var userCount int64
|
|
if err := s.db.WithContext(ctx).Model(&model.User{}).Where("plan_id = ?", planID).Count(&userCount).Error; err != nil {
|
|
return 0, 0, 0, err
|
|
}
|
|
|
|
var paymentCount int64
|
|
if err := s.db.WithContext(ctx).Model(&model.Payment{}).Where("plan_id = ?", planID).Count(&paymentCount).Error; err != nil {
|
|
return 0, 0, 0, err
|
|
}
|
|
|
|
var subscriptionCount int64
|
|
if err := s.db.WithContext(ctx).Model(&model.PlanSubscription{}).Where("plan_id = ?", planID).Count(&subscriptionCount).Error; err != nil {
|
|
return 0, 0, 0, err
|
|
}
|
|
|
|
return userCount, paymentCount, subscriptionCount, nil
|
|
}
|
|
|
|
func validateAdminPlanInput(name, cycle string, price float64, storageLimit int64, uploadLimit int32) string {
|
|
if strings.TrimSpace(name) == "" {
|
|
return "Name is required"
|
|
}
|
|
if strings.TrimSpace(cycle) == "" {
|
|
return "Cycle is required"
|
|
}
|
|
if price < 0 {
|
|
return "Price must be greater than or equal to 0"
|
|
}
|
|
if storageLimit <= 0 {
|
|
return "Storage limit must be greater than 0"
|
|
}
|
|
if uploadLimit <= 0 {
|
|
return "Upload limit must be greater than 0"
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func validateAdminAdTemplateInput(userID, name, vastTagURL, adFormat string, duration *int64) string {
|
|
if strings.TrimSpace(userID) == "" {
|
|
return "User ID is required"
|
|
}
|
|
if strings.TrimSpace(name) == "" || strings.TrimSpace(vastTagURL) == "" {
|
|
return "Name and VAST URL are required"
|
|
}
|
|
format := normalizeAdFormat(adFormat)
|
|
if format == "mid-roll" && (duration == nil || *duration <= 0) {
|
|
return "Duration is required for mid-roll templates"
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func validateAdminPlayerConfigInput(userID, name string) string {
|
|
if strings.TrimSpace(userID) == "" {
|
|
return "User ID is required"
|
|
}
|
|
if strings.TrimSpace(name) == "" {
|
|
return "Name is required"
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (s *appServices) unsetAdminDefaultTemplates(ctx context.Context, tx *gorm.DB, userID, excludeID string) error {
|
|
query := tx.WithContext(ctx).Model(&model.AdTemplate{}).Where("user_id = ?", userID)
|
|
if excludeID != "" {
|
|
query = query.Where("id <> ?", excludeID)
|
|
}
|
|
return query.Update("is_default", false).Error
|
|
}
|
|
|
|
func (s *appServices) unsetAdminDefaultPlayerConfigs(ctx context.Context, tx *gorm.DB, userID, excludeID string) error {
|
|
query := tx.WithContext(ctx).Model(&model.PlayerConfig{}).Where("user_id = ?", userID)
|
|
if excludeID != "" {
|
|
query = query.Where("id <> ?", excludeID)
|
|
}
|
|
return query.Update("is_default", false).Error
|
|
}
|
|
|
|
func (s *appServices) buildAdminPlan(ctx context.Context, plan *model.Plan) (*appv1.AdminPlan, error) {
|
|
if plan == nil {
|
|
return nil, nil
|
|
}
|
|
|
|
userCount, paymentCount, subscriptionCount, err := s.loadAdminPlanUsageCounts(ctx, plan.ID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
payload := &appv1.AdminPlan{
|
|
Id: plan.ID,
|
|
Name: plan.Name,
|
|
Description: nullableTrimmedString(plan.Description),
|
|
Features: append([]string(nil), plan.Features...),
|
|
Price: plan.Price,
|
|
Cycle: plan.Cycle,
|
|
StorageLimit: plan.StorageLimit,
|
|
UploadLimit: plan.UploadLimit,
|
|
DurationLimit: plan.DurationLimit,
|
|
QualityLimit: plan.QualityLimit,
|
|
IsActive: boolValue(plan.IsActive),
|
|
UserCount: userCount,
|
|
PaymentCount: paymentCount,
|
|
SubscriptionCount: subscriptionCount,
|
|
}
|
|
return payload, nil
|
|
}
|
|
|
|
func (s *appServices) buildAdminAdTemplate(ctx context.Context, item *model.AdTemplate) (*appv1.AdminAdTemplate, error) {
|
|
if item == nil {
|
|
return nil, nil
|
|
}
|
|
|
|
payload := &appv1.AdminAdTemplate{
|
|
Id: item.ID,
|
|
UserId: item.UserID,
|
|
Name: item.Name,
|
|
Description: nullableTrimmedString(item.Description),
|
|
VastTagUrl: item.VastTagURL,
|
|
AdFormat: stringValue(item.AdFormat),
|
|
Duration: item.Duration,
|
|
IsActive: boolValue(item.IsActive),
|
|
IsDefault: item.IsDefault,
|
|
CreatedAt: timeToProto(item.CreatedAt),
|
|
UpdatedAt: timeToProto(item.UpdatedAt),
|
|
}
|
|
|
|
ownerEmail, err := s.loadAdminUserEmail(ctx, item.UserID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
payload.OwnerEmail = ownerEmail
|
|
|
|
return payload, nil
|
|
}
|
|
|
|
func (s *appServices) buildAdminPlayerConfig(ctx context.Context, item *model.PlayerConfig) (*appv1.AdminPlayerConfig, error) {
|
|
if item == nil {
|
|
return nil, nil
|
|
}
|
|
|
|
payload := &appv1.AdminPlayerConfig{
|
|
Id: item.ID,
|
|
UserId: item.UserID,
|
|
Name: item.Name,
|
|
Description: nullableTrimmedString(item.Description),
|
|
Autoplay: item.Autoplay,
|
|
Loop: item.Loop,
|
|
Muted: item.Muted,
|
|
ShowControls: boolValue(item.ShowControls),
|
|
Pip: boolValue(item.Pip),
|
|
Airplay: boolValue(item.Airplay),
|
|
Chromecast: boolValue(item.Chromecast),
|
|
IsActive: boolValue(item.IsActive),
|
|
IsDefault: item.IsDefault,
|
|
CreatedAt: timeToProto(item.CreatedAt),
|
|
UpdatedAt: timeToProto(&item.UpdatedAt),
|
|
EncrytionM3U8: boolValue(item.EncrytionM3u8),
|
|
LogoUrl: nullableTrimmedString(item.LogoURL),
|
|
}
|
|
|
|
ownerEmail, err := s.loadAdminUserEmail(ctx, item.UserID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
payload.OwnerEmail = ownerEmail
|
|
|
|
return payload, nil
|
|
}
|