391 lines
12 KiB
Go
391 lines
12 KiB
Go
//go:build ignore
|
|
// +build ignore
|
|
|
|
package admin
|
|
|
|
import (
|
|
"errors"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/google/uuid"
|
|
"gorm.io/gorm"
|
|
|
|
// "stream.api/internal/database/model"
|
|
"stream.api/internal/database/model"
|
|
"stream.api/pkg/response"
|
|
)
|
|
|
|
type AdminAdTemplatePayload struct {
|
|
ID string `json:"id"`
|
|
UserID string `json:"user_id"`
|
|
Name string `json:"name"`
|
|
Description string `json:"description"`
|
|
VastTagURL string `json:"vast_tag_url"`
|
|
AdFormat string `json:"ad_format"`
|
|
Duration *int64 `json:"duration,omitempty"`
|
|
IsActive bool `json:"is_active"`
|
|
IsDefault bool `json:"is_default"`
|
|
OwnerEmail string `json:"owner_email,omitempty"`
|
|
CreatedAt string `json:"created_at"`
|
|
UpdatedAt string `json:"updated_at"`
|
|
}
|
|
|
|
type SaveAdminAdTemplateRequest struct {
|
|
UserID string `json:"user_id" binding:"required"`
|
|
Name string `json:"name" binding:"required"`
|
|
Description string `json:"description"`
|
|
VASTTagURL string `json:"vast_tag_url" binding:"required"`
|
|
AdFormat string `json:"ad_format"`
|
|
Duration *int64 `json:"duration"`
|
|
IsActive *bool `json:"is_active"`
|
|
IsDefault *bool `json:"is_default"`
|
|
}
|
|
|
|
func normalizeAdminAdFormat(value string) string {
|
|
switch strings.TrimSpace(strings.ToLower(value)) {
|
|
case "mid-roll", "post-roll":
|
|
return strings.TrimSpace(strings.ToLower(value))
|
|
default:
|
|
return "pre-roll"
|
|
}
|
|
}
|
|
|
|
func unsetAdminDefaultTemplates(tx *gorm.DB, userID, excludeID string) error {
|
|
query := tx.Model(&model.AdTemplate{}).Where("user_id = ?", userID)
|
|
if excludeID != "" {
|
|
query = query.Where("id <> ?", excludeID)
|
|
}
|
|
return query.Update("is_default", false).Error
|
|
}
|
|
|
|
func validateAdminAdTemplateRequest(req *SaveAdminAdTemplateRequest) string {
|
|
if strings.TrimSpace(req.UserID) == "" {
|
|
return "User ID is required"
|
|
}
|
|
if strings.TrimSpace(req.Name) == "" || strings.TrimSpace(req.VASTTagURL) == "" {
|
|
return "Name and VAST URL are required"
|
|
}
|
|
format := normalizeAdminAdFormat(req.AdFormat)
|
|
if format == "mid-roll" && (req.Duration == nil || *req.Duration <= 0) {
|
|
return "Duration is required for mid-roll templates"
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (h *Handler) buildAdminAdTemplatePayload(ctx *gin.Context, item model.AdTemplate, ownerEmail string) AdminAdTemplatePayload {
|
|
return AdminAdTemplatePayload{
|
|
ID: item.ID,
|
|
UserID: item.UserID,
|
|
Name: item.Name,
|
|
Description: adminStringValue(item.Description),
|
|
VastTagURL: item.VastTagURL,
|
|
AdFormat: adminStringValue(item.AdFormat),
|
|
Duration: item.Duration,
|
|
IsActive: adminBoolValue(item.IsActive, true),
|
|
IsDefault: item.IsDefault,
|
|
OwnerEmail: ownerEmail,
|
|
CreatedAt: adminFormatTime(item.CreatedAt),
|
|
UpdatedAt: adminFormatTime(item.UpdatedAt),
|
|
}
|
|
}
|
|
|
|
// @Summary List All Ad Templates
|
|
// @Description Get paginated list of all ad templates across users (admin only)
|
|
// @Tags admin
|
|
// @Produce json
|
|
// @Param page query int false "Page" default(1)
|
|
// @Param limit query int false "Limit" default(20)
|
|
// @Param user_id query string false "Filter by user ID"
|
|
// @Param search query string false "Search by name"
|
|
// @Success 200 {object} response.Response
|
|
// @Failure 401 {object} response.Response
|
|
// @Failure 403 {object} response.Response
|
|
// @Router /admin/ad-templates [get]
|
|
// @Security BearerAuth
|
|
func (h *Handler) ListAdTemplates(c *gin.Context) {
|
|
ctx := c.Request.Context()
|
|
page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
|
|
if page < 1 {
|
|
page = 1
|
|
}
|
|
limit, _ := strconv.Atoi(c.DefaultQuery("limit", "20"))
|
|
if limit <= 0 {
|
|
limit = 20
|
|
}
|
|
if limit > 100 {
|
|
limit = 100
|
|
}
|
|
offset := (page - 1) * limit
|
|
|
|
search := strings.TrimSpace(c.Query("search"))
|
|
userID := strings.TrimSpace(c.Query("user_id"))
|
|
|
|
db := h.db.WithContext(ctx).Model(&model.AdTemplate{})
|
|
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 {
|
|
response.Error(c, http.StatusInternalServerError, "Failed to list ad templates")
|
|
return
|
|
}
|
|
|
|
var templates []model.AdTemplate
|
|
if err := db.Order("created_at DESC").Offset(offset).Limit(limit).Find(&templates).Error; err != nil {
|
|
h.logger.Error("Failed to list ad templates", "error", err)
|
|
response.Error(c, http.StatusInternalServerError, "Failed to list ad templates")
|
|
return
|
|
}
|
|
|
|
ownerIDs := map[string]bool{}
|
|
for _, t := range templates {
|
|
ownerIDs[t.UserID] = true
|
|
}
|
|
ownerEmails := map[string]string{}
|
|
if len(ownerIDs) > 0 {
|
|
ids := make([]string, 0, len(ownerIDs))
|
|
for id := range ownerIDs {
|
|
ids = append(ids, id)
|
|
}
|
|
var users []struct{ ID, Email string }
|
|
h.db.WithContext(ctx).Table("\"user\"").Select("id, email").Where("id IN ?", ids).Find(&users)
|
|
for _, u := range users {
|
|
ownerEmails[u.ID] = u.Email
|
|
}
|
|
}
|
|
|
|
result := make([]AdminAdTemplatePayload, 0, len(templates))
|
|
for _, t := range templates {
|
|
result = append(result, h.buildAdminAdTemplatePayload(c, t, ownerEmails[t.UserID]))
|
|
}
|
|
|
|
response.Success(c, gin.H{
|
|
"templates": result,
|
|
"total": total,
|
|
"page": page,
|
|
"limit": limit,
|
|
})
|
|
}
|
|
|
|
// @Summary Get Ad Template Detail
|
|
// @Description Get ad template detail (admin only)
|
|
// @Tags admin
|
|
// @Produce json
|
|
// @Param id path string true "Ad Template ID"
|
|
// @Success 200 {object} response.Response
|
|
// @Router /admin/ad-templates/{id} [get]
|
|
// @Security BearerAuth
|
|
func (h *Handler) GetAdTemplate(c *gin.Context) {
|
|
id := strings.TrimSpace(c.Param("id"))
|
|
if id == "" {
|
|
response.Error(c, http.StatusNotFound, "Ad template not found")
|
|
return
|
|
}
|
|
|
|
var item model.AdTemplate
|
|
if err := h.db.WithContext(c.Request.Context()).Where("id = ?", id).First(&item).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
response.Error(c, http.StatusNotFound, "Ad template not found")
|
|
return
|
|
}
|
|
response.Error(c, http.StatusInternalServerError, "Failed to load ad template")
|
|
return
|
|
}
|
|
|
|
ownerEmail := ""
|
|
var user model.User
|
|
if err := h.db.WithContext(c.Request.Context()).Select("id, email").Where("id = ?", item.UserID).First(&user).Error; err == nil {
|
|
ownerEmail = user.Email
|
|
}
|
|
|
|
response.Success(c, gin.H{"template": h.buildAdminAdTemplatePayload(c, item, ownerEmail)})
|
|
}
|
|
|
|
// @Summary Create Ad Template
|
|
// @Description Create an ad template for any user (admin only)
|
|
// @Tags admin
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param request body SaveAdminAdTemplateRequest true "Ad template payload"
|
|
// @Success 201 {object} response.Response
|
|
// @Router /admin/ad-templates [post]
|
|
// @Security BearerAuth
|
|
func (h *Handler) CreateAdTemplate(c *gin.Context) {
|
|
var req SaveAdminAdTemplateRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
response.Error(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
if msg := validateAdminAdTemplateRequest(&req); msg != "" {
|
|
response.Error(c, http.StatusBadRequest, msg)
|
|
return
|
|
}
|
|
|
|
ctx := c.Request.Context()
|
|
var user model.User
|
|
if err := h.db.WithContext(ctx).Where("id = ?", strings.TrimSpace(req.UserID)).First(&user).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
response.Error(c, http.StatusBadRequest, "User not found")
|
|
return
|
|
}
|
|
response.Error(c, http.StatusInternalServerError, "Failed to save ad template")
|
|
return
|
|
}
|
|
|
|
item := &model.AdTemplate{
|
|
ID: uuid.New().String(),
|
|
UserID: user.ID,
|
|
Name: strings.TrimSpace(req.Name),
|
|
Description: adminStringPtr(req.Description),
|
|
VastTagURL: strings.TrimSpace(req.VASTTagURL),
|
|
AdFormat: model.StringPtr(normalizeAdminAdFormat(req.AdFormat)),
|
|
Duration: req.Duration,
|
|
IsActive: model.BoolPtr(req.IsActive == nil || *req.IsActive),
|
|
IsDefault: req.IsDefault != nil && *req.IsDefault,
|
|
}
|
|
if !adminBoolValue(item.IsActive, true) {
|
|
item.IsDefault = false
|
|
}
|
|
|
|
if err := h.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
if item.IsDefault {
|
|
if err := unsetAdminDefaultTemplates(tx, item.UserID, ""); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return tx.Create(item).Error
|
|
}); err != nil {
|
|
h.logger.Error("Failed to create ad template", "error", err)
|
|
response.Error(c, http.StatusInternalServerError, "Failed to save ad template")
|
|
return
|
|
}
|
|
|
|
response.Created(c, gin.H{"template": h.buildAdminAdTemplatePayload(c, *item, user.Email)})
|
|
}
|
|
|
|
// @Summary Update Ad Template
|
|
// @Description Update an ad template for any user (admin only)
|
|
// @Tags admin
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param id path string true "Ad Template ID"
|
|
// @Param request body SaveAdminAdTemplateRequest true "Ad template payload"
|
|
// @Success 200 {object} response.Response
|
|
// @Router /admin/ad-templates/{id} [put]
|
|
// @Security BearerAuth
|
|
func (h *Handler) UpdateAdTemplate(c *gin.Context) {
|
|
id := strings.TrimSpace(c.Param("id"))
|
|
if id == "" {
|
|
response.Error(c, http.StatusNotFound, "Ad template not found")
|
|
return
|
|
}
|
|
|
|
var req SaveAdminAdTemplateRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
response.Error(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
if msg := validateAdminAdTemplateRequest(&req); msg != "" {
|
|
response.Error(c, http.StatusBadRequest, msg)
|
|
return
|
|
}
|
|
|
|
ctx := c.Request.Context()
|
|
var user model.User
|
|
if err := h.db.WithContext(ctx).Where("id = ?", strings.TrimSpace(req.UserID)).First(&user).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
response.Error(c, http.StatusBadRequest, "User not found")
|
|
return
|
|
}
|
|
response.Error(c, http.StatusInternalServerError, "Failed to save ad template")
|
|
return
|
|
}
|
|
|
|
var item model.AdTemplate
|
|
if err := h.db.WithContext(ctx).Where("id = ?", id).First(&item).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
response.Error(c, http.StatusNotFound, "Ad template not found")
|
|
return
|
|
}
|
|
response.Error(c, http.StatusInternalServerError, "Failed to save ad template")
|
|
return
|
|
}
|
|
|
|
item.UserID = user.ID
|
|
item.Name = strings.TrimSpace(req.Name)
|
|
item.Description = adminStringPtr(req.Description)
|
|
item.VastTagURL = strings.TrimSpace(req.VASTTagURL)
|
|
item.AdFormat = model.StringPtr(normalizeAdminAdFormat(req.AdFormat))
|
|
item.Duration = req.Duration
|
|
if req.IsActive != nil {
|
|
item.IsActive = model.BoolPtr(*req.IsActive)
|
|
}
|
|
if req.IsDefault != nil {
|
|
item.IsDefault = *req.IsDefault
|
|
}
|
|
if !adminBoolValue(item.IsActive, true) {
|
|
item.IsDefault = false
|
|
}
|
|
|
|
if err := h.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
if item.IsDefault {
|
|
if err := unsetAdminDefaultTemplates(tx, item.UserID, item.ID); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return tx.Save(&item).Error
|
|
}); err != nil {
|
|
h.logger.Error("Failed to update ad template", "error", err)
|
|
response.Error(c, http.StatusInternalServerError, "Failed to save ad template")
|
|
return
|
|
}
|
|
|
|
response.Success(c, gin.H{"template": h.buildAdminAdTemplatePayload(c, item, user.Email)})
|
|
}
|
|
|
|
// @Summary Delete Ad Template (Admin)
|
|
// @Description Delete any ad template by ID (admin only)
|
|
// @Tags admin
|
|
// @Produce json
|
|
// @Param id path string true "Ad Template ID"
|
|
// @Success 200 {object} response.Response
|
|
// @Failure 404 {object} response.Response
|
|
// @Router /admin/ad-templates/{id} [delete]
|
|
// @Security BearerAuth
|
|
func (h *Handler) DeleteAdTemplate(c *gin.Context) {
|
|
id := c.Param("id")
|
|
|
|
err := h.db.WithContext(c.Request.Context()).Transaction(func(tx *gorm.DB) error {
|
|
if err := tx.Where("ad_template_id = ?", id).Delete(&model.VideoAdConfig{}).Error; err != nil {
|
|
return err
|
|
}
|
|
res := tx.Where("id = ?", id).Delete(&model.AdTemplate{})
|
|
if res.Error != nil {
|
|
return res.Error
|
|
}
|
|
if res.RowsAffected == 0 {
|
|
return gorm.ErrRecordNotFound
|
|
}
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
if err == gorm.ErrRecordNotFound {
|
|
response.Error(c, http.StatusNotFound, "Ad template not found")
|
|
return
|
|
}
|
|
h.logger.Error("Failed to delete ad template", "error", err)
|
|
response.Error(c, http.StatusInternalServerError, "Failed to delete ad template")
|
|
return
|
|
}
|
|
|
|
response.Success(c, gin.H{"message": "Ad template deleted"})
|
|
}
|