root/huangguo_server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source 
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
root
2026-09-15 13:57:10 +08:00
co-authored by Claude Opus 5
commit 8679200f41
1897 changed files with 257900 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
web/api/updownloadctrl/updownloadCtrl.go
+697
View File
@@ -0,0 +1,697 @@
package updownloadctrl
import (
"bytes"
"encoding/base64"
"encoding/json"
"fmt"
"io"
"mime"
"net/http"
"path"
"path/filepath"
"strconv"
"strings"
"time"
"91porn-server/common"
"91porn-server/common/constant"
"91porn-server/common/crypt"
"91porn-server/common/log"
"91porn-server/common/m3u8"
"91porn-server/common/stderr"
"91porn-server/models/commod"
"91porn-server/models/l/operatorlgmod"
"91porn-server/models/v/sourcemod"
"91porn-server/models/v/vidmod"
"91porn-server/web/service/updownloadser"
"91porn-server/web/service/vidser"
"91porn-server/web/webg"
"github.com/gin-gonic/gin"
)
const Retries = 3 //重试3次
// buffer bytes.Buffer
var interval = []int64{5, 15, 30, 60} //通知时间间隔
// Upload doc
// @Summary 文件管理 - 表单上传文件
// @Description 表单上传文件 用于上传视频对应的封面图
// @Tags WEB-uploaddown
// @Accept mpfd,json
// @Produce json,html
// @Param upload formData file true "文件"
// @Param id formData string true "文件ID"
// @Success 200 {string} json "{"msg": "success" "data":{"coverImg":"xxxxxxxxxx.jpg"}}"
// @Failure 400 {string} json "{"msg": "操作失败"}"
// @Router /web/vid/upload [post]
func Upload(c *gin.Context) {
headers, err := c.FormFile("upload")
if err != nil {
log.Warn("request multipart wrong ", log.E(err))
common.ServeJSON(c, stderr.ErrUploadError, err.Error())
return
}
id := c.PostForm("id")
if id == "" {
common.ServeJSON(c, stderr.ErrUploadError, "id is required")
return
}
f, err := headers.Open()
if err != nil {
log.Warn("headers Open file wrong ", log.E(err))
common.ServeJSON(c, stderr.ErrUploadError, err.Error())
return
}
ext := strings.TrimLeft(filepath.Ext(headers.Filename), ".")
byteData, err := io.ReadAll(f)
f.Close()
if err != nil {
log.Warn("request multipart wrong ", log.E(err))
common.ServeJSON(c, stderr.ErrUploadError, err.Error())
return
}
fileData := base64.StdEncoding.EncodeToString(byteData)
resp, err := updownloadser.SendVidCover2FS(id, ext, fileData)
if err != nil {
log.Warn("file upload wrong ", log.E(err))
common.ServeJSON(c, stderr.ErrUploadError, err.Error())
return
}
if resp.Code == http.StatusOK {
common.ServeJSON(c, stderr.Success, resp.Data)
return
}
common.ServeJSON(c, stderr.ErrUploadError, "")
}
// UploadVideo doc
// @Summary 文件管理 - 上传视频
// @Description 上传视频
// @Tags WEB-uploaddown
// @Accept mpfd,json
// @Produce json,html
// @Param upload formData file true "文件类型"
// @Success 200 {string} json "{"msg": "success" "data":""}"
// @Failure 400 {string} json "{"msg": "fail"}"
// @Router /web/vid/uploadVideo [post]
func UploadVideo(c *gin.Context) {
var mime_type = []string{"video/x-flv", "video/mp4", "application/x-mpegURL", "video/MP2T", "video/3gpp", "video/x-msvideo", "video/x-ms-wmv"}
var isVideo bool
var resp vidmod.AwsResport
vidres := vidmod.WenUploadRes{}
var httpErr error
headers, err := c.FormFile("upload")
if err != nil {
log.Warn("request multipart wrong ", log.E(err))
common.ServeJSON(c, stderr.ErrUploadError, err.Error())
return
}
f, err := headers.Open()
if err != nil {
log.Warn("headers Open file wrong ", log.E(err))
common.ServeJSON(c, stderr.ErrUploadError, err.Error())
return
}
defer func() { _ = f.Close() }()
mtype := mime.TypeByExtension(strings.ToLower(filepath.Ext(headers.Filename)))
for _, v := range mime_type {
if mtype == v {
isVideo = true
break
}
}
if !isVideo {
common.ServeJSON(c, stderr.ErrMimeType, "")
return
}
byteData, _ := io.ReadAll(f)
md5 := crypt.ByteToMd5(byteData)
fileData := base64.StdEncoding.EncodeToString(byteData)
resp, httpErr = updownloadser.SendFile2FS(common.UUID(), fileData, 1, 1)
if httpErr != nil {
log.Warn("file upload wrong ", log.E(httpErr))
common.ServeJSON(c, stderr.ErrUploadError, httpErr.Error())
return
}
if resp.Code == http.StatusOK {
vidres.SourceID = resp.Data.VID
vidres.SourceURL = resp.Data.VideoURI
vidres.Size = int(headers.Size)
vidres.MD5 = md5
fileName := strconv.FormatInt(time.Now().Unix(), 10) + common.RandStrRandr(8) + path.Ext(headers.Filename)
vidres.Filename = fileName
vidres.MimeType = mtype
common.ServeJSON(c, stderr.Success, vidres)
return
}
common.ServeJSON(c, stderr.ErrUploadError, "")
}
// UploadDotStream doc
// @Summary 文件管理 - 流式断点续传文件
// @Description 流式断点续传
// @Tags uploaddown
// @Accept mpfd,json
// @Produce json,html
// @Param id formData string true "文件ID 文件MD5做ID"
// @Param chunkNumber formData string true "第几片视频"
// @Param totalChunks formData string true "视频总片数"
// @Success 200 {string} json "{"msg": "success" "data":{"id":"5d8a2af58747044ca077f358","videoUri":"xxxxxxx.m3u8"} }"
// @Failure 400 {string} json "{"msg": "fail"}"
// @Router /vid/uploadDotStream [post]
func UploadDotStream(c *gin.Context) {
var id, pos, totalPos, size string
var cnt int64
id = c.PostForm("id")
pos = c.PostForm("chunkNumber")
totalPos = c.PostForm("totalChunks")
size = c.PostForm("totalSize")
var mime_type = []string{"video/x-flv", "video/mp4", "application/x-mpegURL", "video/MP2T", "video/3gpp", "video/x-msvideo", "video/x-ms-wmv"}
var isVideo bool
var resp vidmod.AwsResport
vidres := vidmod.WenUploadRes{}
if id == "" || pos == "" || totalPos == "" {
common.ServeJSON(c, stderr.ErrParamError, "upload args error")
return
}
posint, _ := strconv.ParseInt(pos, 10, 32)
total, _ := strconv.ParseInt(totalPos, 10, 32)
var httpErr error
headers, err := c.FormFile("upload")
if err != nil || headers.Filename == "" || headers.Size == 0 {
log.Warn("request multipart wrong ", log.E(err))
common.ServeJSON(c, stderr.ErrUploadError, err)
return
}
f, err := headers.Open()
if err != nil {
log.Warn("headers Open file wrong ", log.E(err))
common.ServeJSON(c, stderr.ErrUploadError, err)
return
}
defer func() {
_ = f.Close()
}()
mtype := mime.TypeByExtension(strings.ToLower(filepath.Ext(headers.Filename)))
for _, v := range mime_type {
if mtype == v {
isVideo = true
break
}
}
if !isVideo {
common.ServeJSON(c, stderr.ErrMimeType, "")
return
}
var buffer bytes.Buffer
_, err = buffer.ReadFrom(f)
if err != nil {
log.Warn("headers Open file wrong ", log.E(err))
common.ServeJSON(c, stderr.ErrUploadError, err)
return
}
fileData := base64.StdEncoding.EncodeToString(buffer.Bytes())
for cnt < Retries {
resp, httpErr = updownloadser.SendFile2FS(id, fileData, posint, total)
if httpErr == nil {
break
}
time.Sleep(time.Second)
log.Warn("retry to upload file to file-server", log.Any("重试次数", cnt), log.E(httpErr))
cnt++
}
if httpErr != nil {
log.Warn("file upload wrong ", log.E(httpErr))
common.ServeJSON(c, stderr.ErrUploadError, nil)
return
}
if resp.Code != http.StatusOK {
common.ServeJSON(c, stderr.ErrUploadError, "")
return
}
vidres.Size, _ = strconv.Atoi(size)
vidres.SourceID = resp.Data.VID
vidres.SourceURL = resp.Data.VideoURI
fileName := strconv.FormatInt(time.Now().Unix(), 10) + common.RandStrRandr(8) + path.Ext(headers.Filename)
vidres.Filename = fileName
vidres.MimeType = mtype
common.ServeJSON(c, stderr.Success, vidres)
}
// UploadDotJson doc
// @Summary 文件管理 - API断点续传文件
// @Description API断点续传
// @Tags uploaddown
// @Accept mpfd,json
// @Produce json,html
// @Param id formData string true "taskId 文件MD5做ID"
// @Param pos formData integer true "第几片视频"
// @Param totalPos formData integer true "视频总片数"
// @Param data formData string true "数据内容"
// @Success 200 {string} json "{"msg": "success" "data":{"id":"5d8a2af58747044ca077f358","videoUri":"xxxxxxx.m3u8"} }"
// @Failure 400 {string} json "{"msg": "fail"}"
// @Router /vid/uploadDotJson [post]
func UploadDotJson(c *gin.Context) {
var cnt int
var resp vidmod.AwsResport
vidres := vidmod.WenUploadRes{}
var httpErr error
var args struct {
ID string `form:"id" json:"id" binding:"required"` //taskId
POS int64 `form:"pos" json:"pos" binding:"required"` //分片序号
TotalPos int64 `form:"totalPos" json:"totalPos" binding:"required"` //总分片数
Data string `form:"data" json:"data" binding:"required"` //分片内容
}
if err := c.ShouldBind(&args); err != nil {
common.ServeJSON(c, stderr.ErrParamError, err)
return
}
for cnt < Retries {
resp, httpErr = updownloadser.SendFile2FS(args.ID, args.Data, args.POS, args.TotalPos)
if httpErr == nil {
break
}
time.Sleep(time.Duration(interval[cnt]) * time.Second)
log.Warn("retry to upload file to file-server", log.Any("重试次数", cnt), log.E(httpErr))
cnt++
}
if httpErr != nil {
log.Warn("file upload wrong ", log.E(httpErr))
common.ServeJSON(c, stderr.ErrUploadError, nil)
return
}
if resp.Code == http.StatusOK {
vidres.SourceID = resp.Data.VID
vidres.SourceURL = resp.Data.VideoURI
common.ServeJSON(c, stderr.Success, vidres)
return
}
common.ServeJSON(c, stderr.ErrUploadError, resp)
}
// Submit doc
// @Summary 提交视频的基本信息
// @Description 视频基本信息提交
// @Tags WEB-uploaddown
// @Accept mpfd,json
// @Produce json,html
// @Param uid formData integer true "用户ID"
// @Param title formData string true "视频标题"
// @Param tags formData array true "视频标签数组"
// @Param playTime formData string false "视频时长"
// @Param cover formData string false "封面图"
// @Param coverThumb formData string false "小图"
// @Param via formData string false "视频来源"
// @Param coins formData integer false "观看金币"
// @Param size formData integer false "文件大小"
// @Param mimeType formData string false "影片类型"
// @Param sourceURL formData string true "资源url"
// @Param sourceID formData string true "上传视频成功后 返回的ID"
// @Param filename formData string true "文件名"
// @Param resolution formData string false "分辨率"
// @Param md5 formData string true "文件摘要"
// @Param freeTime formData integer false "免费观影时长"
// @Param seedLinkUrl formData string false "种子下载链接"
// @Param seedSize formData integer false "种子影片大小"
// @Param seedPlayTime formData integer false "种子影片时长"
// @Success 200 {string} json "{"msg": "操作成功"}"
// @Failure 400 {string} json "{"msg": "操作失败"}"
// @Router /web/vid/submit [post]
func Submit(ctx *gin.Context) {
manager, err := common.GetAdminAct(ctx)
if err != nil {
common.ServeJSON(ctx, stderr.AdminIDErr, err.Error())
return
}
param := vidmod.WebSubmitReq{}
if err = ctx.ShouldBind(&param); err != nil {
common.ServeJSON(ctx, stderr.ErrParamError, nil)
return
}
//对上传的视频的秒数做限制
if param.PlayTime != 0 {
if param.PlayTime < vidmod.SubmitVideoPlayTimeLimit {
common.ServeJSON(ctx, stderr.ErrPlayTimeTooShort, "")
return
}
}
//默认newsType
if len(param.NewsType) == 0 {
param.NewsType = vidmod.SP
}
//图集的第一张放到封面中
if (param.NewsType == vidmod.COVER || param.NewsType == vidmod.PIC) && len(param.SeriesCover) != 0 {
param.Cover = param.SeriesCover[0]
param.CoverThumb = param.SeriesCover[0]
}
code, vid := vidser.SubmitBase(param)
if code != stderr.Success {
_, _ = vidser.DeleteManyByTTL(vid)
common.ServeJSON(ctx, code, vid)
return
}
if param.NewsType == vidmod.COVER || param.NewsType == vidmod.PIC ||
param.NewsType == vidmod.AD_COVER || (param.NewsType == vidmod.SEED_LINK && param.SourceURL == "") {
common.ServeJSON(ctx, code, vid)
return
}
code = vidser.SendBaseInfo2AWs(param)
if code != stderr.Success {
_, _ = vidser.DeleteManyByTTL(vid)
}
log, _ := json.Marshal(param)
_ = operatorlgmod.RecordOperation(manager, constant.VideoManageList, constant.Add, string(log), ctx.Request.URL.RequestURI())
common.ServeJSON(ctx, code, vid)
}
// PullFileInfoFromAws doc
// @Summary
// @Description 从AWS拉取视频信息
// @Tags WEB-uploaddown
// @Accept mpfd,json
// @Produce json,html
// @Param token formData string true "调用此接口的token""
// @Param uid formData array true "用户ID 数组"
// @Param cityes formData array true "城市名字 数组"
// @Param maxPlayTime formData integer false "最长播放时间"
// @Param minPlayTime formData integer false "最小播放时间"
// @Param pageSize formData integer true "分页数据"
// @Param newUpdateAt formData string false "批次更新标识"
// @Success 200 {string} json "{"msg": "操作成功"}"
// @Failure 400 {string} json "{"msg": "操作失败"}"
// @Router /web/vid/pullFileInfoFromAws [post]
func PullFileInfoFromAws(ctx *gin.Context) {
param := vidmod.PullReq{}
if err := ctx.ShouldBind(&param); err != nil {
common.ServeJSON(ctx, stderr.ErrParamError, nil)
return
}
if param.Token != "q7ydjHVIVBYiTqQ&" {
common.ServeJSON(ctx, stderr.ErrNoToken, nil)
return
}
var code stderr.Code
var data map[string]interface{}
switch param.SyncType {
case "SP":
code, data = updownloadser.PullFile(param)
case "SERIES":
code, data = updownloadser.PullSeriesFile(param)
}
if param.NewUpdateAt != "" {
updownloadser.SyncNewImportVideoToElastic(param.NewUpdateAt, time.Time{}, time.Time{})
}
common.ServeJSON(ctx, code, data)
}
// UploadStatic doc
// @Summary 文件管理 - 表单上传文件
// @Description 表单上传文件,上传静态文件到AWS 用于独立文件上传
// @Tags WEB-uploaddown
// @Accept mpfd,json
// @Produce json,html
// @Param upload formData file true "文件"
// @Success 200 {string} json "{"msg": "success" "data":{"coverImg":"xxxxxxxxxx.ext"}}"
// @Failure 400 {string} json "{"msg": "操作失败"}"
// @Router /web/vid/uploadStatic [post]
func UploadStatic(c *gin.Context) {
var (
resp vidmod.FsSendSingleResp
commres commod.Resp
err error
)
headers, err := c.FormFile("upload")
id := c.PostForm("id")
if err != nil {
log.Warn("request multipart wrong ", log.E(err))
common.ServeJSON(c, stderr.ErrUploadError, err.Error())
return
}
f, err := headers.Open()
if err != nil {
log.Warn("headers Open file wrong ", log.E(err))
common.ServeJSON(c, stderr.ErrUploadError, err.Error())
return
}
byteData, err := io.ReadAll(f)
f.Close()
if err != nil {
log.Warn("request multipart wrong ", log.E(err))
common.ServeJSON(c, stderr.ErrUploadError, err.Error())
return
}
fileData := base64.StdEncoding.EncodeToString(byteData)
if id == "" {
resp, err = updownloadser.SendImageToFS(headers.Filename, fileData)
} else {
ext := strings.TrimLeft(filepath.Ext(headers.Filename), ".")
commres, err = updownloadser.SendVidCover2FS(id, ext, fileData)
}
if err != nil {
log.Warn("file upload wrong ", log.E(err))
common.ServeJSON(c, stderr.ErrUploadError, err.Error())
return
}
if resp.Code == stderr.Success {
common.ServeJSON(c, stderr.Success, gin.H{
"coverImg": resp.Data.FileName,
"sizeB": headers.Size, //字节
})
return
}
if commres.Code == stderr.Success {
common.ServeJSON(c, stderr.Success, commres.Data)
return
}
common.ServeJSON(c, stderr.ErrUploadError, "")
}
// UploadStaticBatch doc
// @Summary 文件管理 - 表单上传文件 批量上传
// @Description 表单上传文件,上传静态文件到AWS 用于独立文件上传
// @Tags WEB-uploaddown
// @Accept mpfd,json
// @Produce json,html
// @Param uploads formData file true "文件"
// @Success 200 {string} json "{"msg": "success" "data":{"coverImg":"xxxxxxxxxx.ext"}}"
// @Failure 400 {string} json "{"msg": "操作失败"}"
// @Router /web/vid/uploadStatic [post]
func UploadStaticBatch(c *gin.Context) {
form, err := c.MultipartForm()
if err != nil {
log.Warn("request multipart wrong ", log.E(err))
common.ServeJSON(c, stderr.ErrUploadError, err.Error())
return
}
files := form.File["upload[]"]
batch := make([]*updownloadser.FileInfo, len(files))
for i, f := range files {
fi, err := f.Open()
if err != nil {
log.Warn("headers Open file wrong ", log.E(err))
common.ServeJSON(c, stderr.ErrUploadError, err.Error())
return
}
byteData, err := io.ReadAll(fi)
fi.Close()
if err != nil {
log.Warn("request multipart wrong ", log.E(err))
common.ServeJSON(c, stderr.ErrUploadError, err.Error())
return
}
fileData := base64.StdEncoding.EncodeToString(byteData)
fileInfo := &updownloadser.FileInfo{
FileName: &f.Filename,
FileData: &fileData,
Resize: true,
}
batch[i] = fileInfo
}
resp, err := updownloadser.SendImageToFSBatch(updownloadser.InfoBatch{Batch: batch})
if err != nil {
log.Warn("file upload wrong ", log.E(err))
common.ServeJSON(c, stderr.ErrUploadError, err.Error())
return
}
common.ServeJSON(c, stderr.Success, gin.H{"filePath": resp.Data.GetFileNames(), "success": resp.Data.Count()})
}
// DownloadM3u8 doc
// @Summary 文件管理 - 下载文件接口
// @Description 下载文件
// @Tags 正式
// @Accept mpfd,json
// @Produce json,html
// @Success 200 {string} json "{"msg": "操作成功"}"
// @Failure 400 {string} json "{"msg": "操作失败"}"
// @Router /vid/m3u8/:source [get]
func DownloadM3u8(c *gin.Context) {
var cdnURL string
source := c.Param("source")
if source == "" {
common.ServeJSON(c, stderr.ErrParamError, "")
return
}
if ext := filepath.Ext(source); ext != ".m3u8" {
common.ServeJSON(c, stderr.ErrMimeType, "")
return
}
fileName := filepath.Base(source)
c.Writer.Header().Add("Content-Disposition", fmt.Sprintf("attachment; filename=%s", fileName))
//媒体资源库选择
mds := m3u8.GetMediaResouce(source)
if mds == constant.MediaSourceLaoSiJi {
source = strings.Replace(source, "/laosiji/", "", -1)
}
data, err := updownloadser.FsIO(source, mds)
if err != nil {
log.ZapLog.Warn("download file error", log.E(err))
c.JSON(http.StatusBadRequest, gin.H{"data": "", "mag": stderr.ErrDownloadError.Msg()})
return
}
if webg.Conf.Switch.CdnOriginBaseOnLocal {
cdnURL = webg.Conf.URL.CdnUrl
} else {
cdns := sourcemod.GetCdnURL()
if len(cdns) > 0 {
cdnURL = cdns[0].Url
} else {
cdnURL = webg.Conf.URL.CdnUrl
}
}
// TS 分片鉴权签名密钥：优先取配置(webg.Conf.Base.TsAuth)，未配置时回退内置默认(版本 default + 内置常量)
keyVersion, authKey := webg.Conf.Base.TsAuth.Resolve()
var bytebuff *bytes.Buffer
if mds == constant.MediaSourcePMS {
// bytebuff = m3u8.DecodeFromReader(data, "", "/api/web/admin/vid/pms/sec", webg.Conf.Base.PMCSecIV)
bytebuff = m3u8.DecodeFromReader(data, "", "/api/web/admin/vid", "", mds, authKey, keyVersion, source)
} else {
serUrl := "/api/web/admin/vid/sp/sec"
if mds == constant.MediaSourceJH1B {
serUrl = "/api/web/admin/vid/sp/m3u8sec"
} else if mds == constant.MediaSourceLaoSiJi {
serUrl = "/api/web/admin/vid/sp/lsjsec"
}
bytebuff = m3u8.DecodeFromReader(data, common.BindUrl(cdnURL, strings.Trim(source, fileName)), serUrl, "", mds, authKey, keyVersion, source)
}
if bytebuff == nil {
log.Warn("can't create m3u8 file")
c.JSON(http.StatusNoContent, gin.H{"data": "", "msg": stderr.CodeEmptyData.Msg()})
return
}
c.Data(200, "application/octet-stream", bytebuff.Bytes())
}
// SyncNewVideo doc
// @Summary 文件管理 - 下载文件接口
// @Description 下载文件
// @Tags 正式
// @Accept mpfd,json
// @Produce json,html
// @Param newUpdateAt formData string true "视频标识"
// @Success 200 {string} json "{"msg": "操作成功"}"
// @Failure 400 {string} json "{"msg": "操作失败"}"
// @Router /api/web/admin/vid/syncNewVideo [post]
func SyncNewVideo(c *gin.Context) {
type Info struct {
NewUpdateAt string `form:"newUpdateAt" json:"newUpdateAt"`
Token string `form:"token" json:"token" binging:"required"`
Start time.Time `form:"start" json:"start"`
End time.Time `form:"end" json:"end"`
}
var param = Info{}
if err := c.ShouldBind(&param); err != nil {
common.ServeJSON(c, stderr.ErrParamError, err)
return
}
if param.Token != "q7ydjHVIVBYiTqQ&" {
common.ServeJSON(c, stderr.ErrNoToken, "")
return
}
updownloadser.SyncNewImportVideoToElastic(param.NewUpdateAt, param.Start, param.End)
common.ServeJSON(c, stderr.Success, "")
}
// SpiderSyncSubmit doc
// @Summary 爬虫同步视频基本信息
// @Description 视频基本信息提交
// @Tags WEB-uploaddown
// @Accept mpfd,json
// @Produce json,html
// @Param uid formData integer true "用户ID"
// @Param title formData string true "视频标题"
// @Param tags formData array true "视频标签数组"
// @Param playTime formData string false "视频时长"
// @Param cover formData string false "封面图"
// @Param coverThumb formData string false "小图"
// @Param via formData string false "视频来源"
// @Param coins formData integer false "观看金币"
// @Param size formData integer false "文件大小"
// @Param mimeType formData string false "影片类型"
// @Param sourceURL formData string true "资源url"
// @Param sourceID formData string true "上传视频成功后 返回的ID"
// @Param filename formData string true "文件名"
// @Param resolution formData string false "分辨率"
// @Param md5 formData string true "文件摘要"
// @Param freeTime formData integer false "免费观影时长"
// @Success 200 {string} json "{"msg": "操作成功"}"
// @Failure 400 {string} json "{"msg": "操作失败"}"
// @Router /vid/spiderSyncSubmit [post]
func SpiderSyncSubmit(ctx *gin.Context) {
param := vidmod.WebSubmitReq{}
if err := ctx.ShouldBind(&param); err != nil {
common.ServeJSON(ctx, stderr.ErrParamError, err.Error())
return
}
//默认newsType
if len(param.NewsType) == 0 {
param.NewsType = vidmod.SP
}
//图集的第一张放到封面中
if (param.NewsType == vidmod.COVER || param.NewsType == vidmod.PIC) && len(param.SeriesCover) != 0 {
param.Cover = param.SeriesCover[0]
param.CoverThumb = param.SeriesCover[0]
}
code, vid := vidser.SubmitBase(param)
if code != stderr.Success {
_, _ = vidser.DeleteManyByTTL(vid)
common.ServeJSON(ctx, code, vid)
return
}
if param.NewsType == vidmod.COVER || param.NewsType == vidmod.PIC {
common.ServeJSON(ctx, code, vid)
return
}
common.ServeJSON(ctx, code, vid)
}
// UploadVideoSuccess doc
// @Summary 文件管理 - 上传视频成功回调
// @Description 上传视频成功回调
// @Tags WEB-uploaddown
// @Accept mpfd,json
// @Produce json,html
// @Param upload formData file true "文件类型"
// @Success 200 {string} json "{"msg": "success" "data":""}"
// @Failure 400 {string} json "{"msg": "fail"}"
// @Router /web/vid/uploadSuccess [post]
func UploadVideoSuccess(c *gin.Context) {
var params struct {
Id string `json:"id"`
}
if err := c.ShouldBind(&params); err != nil {
common.ServeJSON(c, stderr.ErrParamError, err.Error())
return
}
//通知文件服, 视频文件上传完成
if code := m3u8.UploadSuccess(params.Id); code != 200 {
log.Error("UploadVideoSuccess m3u8.UploadSuccess code != 200")
common.ServeJSON(c, stderr.Failure, "")
return
}
common.ServeJSON(c, stderr.Success, "")
}