540 lines
16 KiB
Go
540 lines
16 KiB
Go
package imports
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"fonchain-fiee/api/accountFiee"
|
|
"fonchain-fiee/api/bundle"
|
|
apiCast "fonchain-fiee/api/cast"
|
|
"fonchain-fiee/api/files"
|
|
"fonchain-fiee/pkg/config"
|
|
"fonchain-fiee/pkg/model"
|
|
modelCast "fonchain-fiee/pkg/model/cast"
|
|
"fonchain-fiee/pkg/service"
|
|
"fonchain-fiee/pkg/service/cast"
|
|
"fonchain-fiee/pkg/service/upload"
|
|
"io"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/mholt/archiver"
|
|
"github.com/xuri/excelize/v2"
|
|
)
|
|
|
|
func ImportPublish(c *gin.Context) {
|
|
// 1. 上传画家短视频详情文件
|
|
excelFile, err := c.FormFile("excel")
|
|
if err != nil {
|
|
c.JSON(400, gin.H{"error": "缺少 Excel 文件 excel"})
|
|
return
|
|
}
|
|
zipFile, err := c.FormFile("zip")
|
|
if err != nil {
|
|
c.JSON(400, gin.H{"error": "缺少 ZIP 文件"})
|
|
return
|
|
}
|
|
|
|
// 2. 保存临时文件
|
|
tempDir := "tmp"
|
|
os.MkdirAll(tempDir, 0755)
|
|
excelPath := filepath.Join(tempDir, "artists.xlsx")
|
|
zipPath := filepath.Join(tempDir, "archive.zip")
|
|
|
|
if err = c.SaveUploadedFile(excelFile, excelPath); err != nil {
|
|
c.JSON(500, gin.H{"error": "保存 Excel 失败"})
|
|
return
|
|
}
|
|
if err = c.SaveUploadedFile(zipFile, zipPath); err != nil {
|
|
c.JSON(500, gin.H{"error": "保存 ZIP 文件失败"})
|
|
return
|
|
}
|
|
|
|
// 3. 解压 ZIP
|
|
unzipPath := filepath.Join(tempDir, "unzipped")
|
|
if _, err = os.Stat(unzipPath); err == nil {
|
|
// 路径已存在，删除
|
|
if removeErr := os.RemoveAll(unzipPath); removeErr != nil {
|
|
c.JSON(500, gin.H{"error": "清理已存在解压目录失败: " + removeErr.Error()})
|
|
return
|
|
}
|
|
}
|
|
os.MkdirAll(unzipPath, 0755)
|
|
if err = archiver.Unarchive(zipPath, unzipPath); err != nil {
|
|
c.JSON(500, gin.H{"error": "解压 ZIP 失败: " + err.Error()})
|
|
return
|
|
}
|
|
entries, err := os.ReadDir(unzipPath)
|
|
if err != nil || len(entries) == 0 {
|
|
c.JSON(500, gin.H{"error": "读取解压目录失败或目录为空"})
|
|
return
|
|
}
|
|
|
|
if len(entries) == 1 && entries[0].IsDir() {
|
|
// 说明解压后多了一层目录，把它设为新的 unzipPath
|
|
unzipPath = filepath.Join(unzipPath, entries[0].Name())
|
|
}
|
|
defer os.RemoveAll(tempDir)
|
|
// 4. 读取 Excel 画家名单, 匹配视频和图片
|
|
artists, err := readArtistVideoInfo(excelPath, unzipPath)
|
|
if err != nil {
|
|
c.JSON(500, gin.H{"error": "读取 Excel 失败"})
|
|
return
|
|
}
|
|
// 5.发布视频
|
|
var failedRecords []FailedRecord
|
|
var artistResp []ArtistVideoDetail
|
|
|
|
for _, artist := range artists {
|
|
var infoResp *accountFiee.UserInfoResponse
|
|
var err error
|
|
list, err := service.AccountFieeProvider.UserList(context.Background(), &accountFiee.UserListRequest{
|
|
Name: artist.Name,
|
|
})
|
|
if err != nil {
|
|
failedRecords = append(failedRecords, FailedRecord{
|
|
Name: artist.Name,
|
|
Msg: fmt.Sprintf("获取用户信息失败: %s", err.Error()),
|
|
})
|
|
log.Printf(fmt.Sprintf("获取用户信息失败: %s", err.Error()))
|
|
continue
|
|
}
|
|
if list != nil && len(list.UserList) > 0 {
|
|
infoResp, err = service.AccountFieeProvider.Info(context.Background(), &accountFiee.InfoRequest{
|
|
ID: list.UserList[0].Id,
|
|
Domain: "app",
|
|
})
|
|
if err != nil {
|
|
failedRecords = append(failedRecords, FailedRecord{
|
|
Name: artist.Name,
|
|
Msg: fmt.Sprintf("获取用户信息失败: %s", err.Error()),
|
|
})
|
|
log.Printf(fmt.Sprintf("获取用户信息失败: %s", err.Error()))
|
|
continue
|
|
}
|
|
}
|
|
|
|
if err = cast.CheckUserBundleBalance(int32(list.UserList[0].Id), modelCast.BalanceTypeVideoValue); err != nil {
|
|
failedRecords = append(failedRecords, FailedRecord{
|
|
Name: artist.Name,
|
|
Msg: fmt.Sprintf("检查用户视频可消耗数量: %s", err.Error()),
|
|
})
|
|
log.Printf(fmt.Sprintf("检查用户视频可消耗数量: %s", err.Error()))
|
|
continue
|
|
}
|
|
//自媒体账号
|
|
accountList, err := service.CastProvider.MediaUserList(c, &apiCast.MediaUserListReq{
|
|
//ArtistUuid: strconv.FormatUint(list.UserList[0].Id, 10),
|
|
ArtistVal: artist.Name,
|
|
Page: 1,
|
|
PageSize: 10,
|
|
})
|
|
if err != nil {
|
|
failedRecords = append(failedRecords, FailedRecord{
|
|
Name: artist.Name,
|
|
Msg: fmt.Sprintf("自媒体账号数量获取失败: %s,账号数量:%d", err.Error(), len(accountList.Data)),
|
|
})
|
|
log.Printf(fmt.Sprintf("自媒体账号数量获取失败: %s,账号数量:%d", err.Error(), len(accountList.Data)))
|
|
continue
|
|
}
|
|
if accountList == nil || len(accountList.Data) == 0 {
|
|
failedRecords = append(failedRecords, FailedRecord{
|
|
Name: artist.Name,
|
|
Msg: "自媒体账号数量为0",
|
|
})
|
|
log.Printf(fmt.Sprintf("自媒体账号,账号数量:%d", len(accountList.Data)))
|
|
continue
|
|
}
|
|
mediaAccountUuids := []string{}
|
|
mediaAccountNames := []string{}
|
|
platformIDs := []apiCast.PlatformIDENUM{}
|
|
for _, info := range accountList.Data {
|
|
if info.PlatformID == 2 && ((artist.Id == "31" && info.ArtistName == "荣小松") ||
|
|
(artist.Id == "72" && info.ArtistName == "韩风霞")) {
|
|
continue // 跳过
|
|
}
|
|
mediaAccountUuids = append(mediaAccountUuids, info.MediaAccountUuid)
|
|
mediaAccountNames = append(mediaAccountNames, info.PlatformUserName)
|
|
platformIDs = append(platformIDs, apiCast.PlatformIDENUM(info.PlatformID))
|
|
}
|
|
newCtx := cast.NewCtxWithUserInfo(c)
|
|
resp, err := service.CastProvider.UpdateWorkVideo(newCtx, &apiCast.UpdateWorkVideoReq{
|
|
Title: artist.Title,
|
|
Content: artist.Title,
|
|
VideoUrl: artist.Video,
|
|
CoverUrl: artist.Img,
|
|
MediaAccountUuids: mediaAccountUuids,
|
|
MediaAccountNames: mediaAccountNames,
|
|
PlatformIDs: platformIDs,
|
|
PublishConfig1: &apiCast.PublishConfig{
|
|
CanComment: 1,
|
|
CanJoin: 1,
|
|
CanQuote: 1,
|
|
ForbidComment: 2,
|
|
IsAI: 1,
|
|
PublicType: 1,
|
|
},
|
|
PublishConfig2: &apiCast.PublishConfig{
|
|
CanComment: 1,
|
|
CanJoin: 1,
|
|
CanQuote: 1,
|
|
ForbidComment: 2,
|
|
IsAI: 1,
|
|
PublicType: 1,
|
|
},
|
|
PublishConfig3: &apiCast.PublishConfig{
|
|
CanComment: 1,
|
|
CanJoin: 1,
|
|
CanQuote: 1,
|
|
ForbidComment: 1,
|
|
IsAI: 1,
|
|
PublicType: 1,
|
|
},
|
|
Action: "submit",
|
|
ArtistUuid: strconv.FormatUint(list.UserList[0].Id, 10),
|
|
ArtistName: infoResp.Name,
|
|
ArtistPhone: infoResp.TelNum,
|
|
ArtistPhoneAreaCode: infoResp.TelAreaCode,
|
|
Source: 2,
|
|
})
|
|
if err != nil {
|
|
failedRecords = append(failedRecords, FailedRecord{
|
|
Name: artist.Name,
|
|
Msg: fmt.Sprintf("发布"+artist.Name+"视频"+artist.Title+"失败: %s", err.Error()),
|
|
})
|
|
log.Printf(fmt.Sprintf("发布"+artist.Name+"视频"+artist.Title+"失败: %s", err.Error()))
|
|
continue
|
|
}
|
|
artistResp = append(artistResp, ArtistVideoDetail{
|
|
Id: artist.Id,
|
|
ArtistName: artist.Name,
|
|
Title: artist.Title,
|
|
WorkUuid: resp.WorkUuid,
|
|
Youtube: artist.Youtube,
|
|
Instagram: artist.Instagram,
|
|
TikTok: artist.TikTok,
|
|
})
|
|
}
|
|
excelUrl, err := exportRecordsToExcel(artistResp)
|
|
if err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
|
|
// 6. 返回结果
|
|
service.Success(c, map[string]interface{}{
|
|
"excelUrl": excelUrl,
|
|
"failedRecords": failedRecords,
|
|
})
|
|
}
|
|
|
|
func readArtistVideoInfo(excelPath, unzipPath string) ([]ArtistMedia, error) {
|
|
log.Println(unzipPath)
|
|
f, err := excelize.OpenFile(excelPath)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer f.Close()
|
|
sheetName := f.GetSheetName(0)
|
|
rows, err := f.GetRows(sheetName)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
log.Println("start read excel")
|
|
var artists []ArtistMedia
|
|
for i, row := range rows {
|
|
if i == 0 || i == 1 || len(row) < 2 {
|
|
continue
|
|
}
|
|
if i == 165 {
|
|
break
|
|
}
|
|
id, _ := f.GetCellValue(sheetName, fmt.Sprintf("A%d", i+1))
|
|
if id != "" {
|
|
id = strings.TrimSpace(id)
|
|
}
|
|
artistName, _ := f.GetCellValue(sheetName, fmt.Sprintf("B%d", i+1))
|
|
if artistName != "" {
|
|
artistName = strings.TrimSpace(artistName)
|
|
}
|
|
title, _ := f.GetCellValue(sheetName, fmt.Sprintf("C%d", i+1))
|
|
if title != "" {
|
|
title = strings.TrimSpace(title)
|
|
}
|
|
youtube, _ := f.GetCellValue(sheetName, fmt.Sprintf("D%d", i+1))
|
|
if youtube != "" {
|
|
youtube = strings.TrimSpace(youtube)
|
|
}
|
|
instagram, _ := f.GetCellValue(sheetName, fmt.Sprintf("E%d", i+1))
|
|
if instagram != "" {
|
|
instagram = strings.TrimSpace(instagram)
|
|
}
|
|
tiktok, _ := f.GetCellValue(sheetName, fmt.Sprintf("F%d", i+1))
|
|
if tiktok != "" {
|
|
tiktok = strings.TrimSpace(tiktok)
|
|
}
|
|
artists = append(artists, ArtistMedia{
|
|
Id: id,
|
|
Name: artistName,
|
|
Title: title,
|
|
Youtube: youtube,
|
|
Instagram: instagram,
|
|
TikTok: tiktok,
|
|
})
|
|
}
|
|
artists, err = matchArtistMedia(artists, unzipPath)
|
|
return artists, nil
|
|
}
|
|
func matchArtistMedia(artists []ArtistMedia, unzipPath string) ([]ArtistMedia, error) {
|
|
var err error
|
|
var res []ArtistMedia
|
|
for _, artist := range artists {
|
|
oldImgPath := fmt.Sprintf("%s/%s/%s.jpg", unzipPath, artist.Name, artist.Id)
|
|
oldVideoPath := fmt.Sprintf("%s/%s/%s.mp4", unzipPath, artist.Name, artist.Id)
|
|
// 检查源文件是否存在
|
|
if _, err = os.Stat(oldImgPath); os.IsNotExist(err) {
|
|
continue
|
|
}
|
|
if _, err = os.Stat(oldVideoPath); os.IsNotExist(err) {
|
|
continue
|
|
}
|
|
baseDir := filepath.Join(unzipPath, artist.Name)
|
|
if err = os.MkdirAll(baseDir, 0755); err != nil {
|
|
log.Println("创建目录失败:", err)
|
|
return nil, err
|
|
}
|
|
log.Println("创建目录成功:", baseDir)
|
|
|
|
// 重命名
|
|
now := time.Now().Unix()
|
|
imgPath := fmt.Sprintf("%s/%s/%s_%d.jpg", unzipPath, artist.Name, artist.Id, now)
|
|
videoPath := fmt.Sprintf("%s/%s/%s_%d.mp4", unzipPath, artist.Name, artist.Id, now)
|
|
if err = os.Rename(oldImgPath, imgPath); err != nil {
|
|
log.Println("图片:"+oldImgPath+"重命名失败:", err)
|
|
return nil, err
|
|
}
|
|
if err = os.Rename(oldVideoPath, videoPath); err != nil {
|
|
log.Println("视频:"+oldVideoPath+"重命名失败:", err)
|
|
return nil, err
|
|
}
|
|
//转为url
|
|
content, err := os.ReadFile(videoPath)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err = UploadToAnotherService(context.Background(), content, filepath.Base(videoPath)); err != nil {
|
|
log.Println("上传视频失败:", err)
|
|
return nil, err
|
|
}
|
|
var httpType string
|
|
if config.AppMode == "prod" {
|
|
url := "saas.fiee.com"
|
|
httpType = fmt.Sprintf("%s%s", model.HttpsType, url)
|
|
} else {
|
|
url := "114.218.158.24:9020"
|
|
httpType = fmt.Sprintf("%s%s", model.HttpType, url)
|
|
}
|
|
baseUrl := fmt.Sprintf("%s/api/fiee/resource/raw/", httpType)
|
|
videoUrl := baseUrl + filepath.Base(videoPath)
|
|
imgUrl, err := upload.PutBos(filepath.ToSlash(imgPath), "image", false)
|
|
if err != nil {
|
|
log.Println("上传图片失败:", err)
|
|
return nil, err
|
|
}
|
|
tmp := artist
|
|
tmp.Id = artist.Id
|
|
tmp.Name = artist.Name
|
|
tmp.Title = artist.Title
|
|
tmp.Img = imgUrl
|
|
//tmp.Video = filepath.ToSlash(videoPath)
|
|
tmp.Video = videoUrl
|
|
res = append(res, tmp)
|
|
}
|
|
return res, nil
|
|
}
|
|
func UploadToAnotherService(ctx context.Context, fileData []byte, path string) error {
|
|
const chunkSize = 4*1024*1024 - 100
|
|
_, err := service.FilesProvider.TusCreate(ctx, &files.TusCreateReq{
|
|
Path: path,
|
|
UserSpacePath: "",
|
|
Override: true,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
log.Println("create success ......**********")
|
|
offset := int64(0)
|
|
totalSize := int64(len(fileData))
|
|
for offset < totalSize {
|
|
end := offset + chunkSize
|
|
if end > totalSize {
|
|
end = totalSize
|
|
}
|
|
chunk := fileData[offset:end]
|
|
_, err = service.FilesProvider.TusUpload(ctx, &files.TusUploadReq{
|
|
Path: path,
|
|
UploadOffset: offset,
|
|
Content: chunk,
|
|
UserSpacePath: "",
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("上传 offset=%d chunk 失败: %w", offset, err)
|
|
}
|
|
log.Printf("upload chunk: %d - %d success\n", offset, end)
|
|
offset = end
|
|
}
|
|
return nil
|
|
}
|
|
func exportRecordsToExcel(artistInfos []ArtistVideoDetail) (string, error) {
|
|
f := excelize.NewFile()
|
|
sheet := "Sheet1"
|
|
f.NewSheet(sheet)
|
|
|
|
// 写表头
|
|
headers := []string{"序号", "画家名", "标题", "uuid", "youtube", "instagram", "tiktok"}
|
|
|
|
for col, h := range headers {
|
|
_ = f.SetCellValue(sheet, string(rune('A'+col))+"1", h)
|
|
}
|
|
|
|
// 写数据
|
|
for i, artistInfo := range artistInfos {
|
|
row := i + 2
|
|
_ = f.SetCellValue(sheet, "A"+strconv.Itoa(row), artistInfo.Id)
|
|
_ = f.SetCellValue(sheet, "B"+strconv.Itoa(row), artistInfo.ArtistName)
|
|
_ = f.SetCellValue(sheet, "C"+strconv.Itoa(row), artistInfo.Title)
|
|
_ = f.SetCellValue(sheet, "D"+strconv.Itoa(row), artistInfo.WorkUuid)
|
|
_ = f.SetCellValue(sheet, "E"+strconv.Itoa(row), artistInfo.Youtube)
|
|
_ = f.SetCellValue(sheet, "F"+strconv.Itoa(row), artistInfo.Instagram)
|
|
_ = f.SetCellValue(sheet, "G"+strconv.Itoa(row), artistInfo.TikTok)
|
|
}
|
|
// 保存文件
|
|
filename := "画家视频详情记录.xlsx"
|
|
fileDir := "./runtime/import/" // 自定义目录
|
|
_ = os.MkdirAll(fileDir, os.ModePerm)
|
|
filePath := filepath.Join(fileDir, filename)
|
|
if err := f.SaveAs(filePath); err != nil {
|
|
return "", err
|
|
}
|
|
excelUrl, err := upload.PutBos(filePath, "excel", true)
|
|
if err != nil {
|
|
return "", err
|
|
|
|
}
|
|
return excelUrl, nil
|
|
}
|
|
func updateApproval(ctx *gin.Context, artistId uint64, workUuid string, accountInfos []*apiCast.MediaUserInfo, videoUrl, imgUrl, title string) error {
|
|
var publishAccounts []PublishAccount
|
|
var publishPlatformIds []int32
|
|
|
|
for _, v := range accountInfos {
|
|
publishAccounts = append(publishAccounts, PublishAccount{
|
|
AccountName: v.PlatformUserName,
|
|
AccountID: v.MediaAccountUuid,
|
|
})
|
|
publishPlatformIds = append(publishPlatformIds, int32(v.PlatformID))
|
|
}
|
|
var req CreateRequest
|
|
var url string
|
|
saasPublishVideo := &SaasPublishVideo{
|
|
Title: title,
|
|
Describe: title,
|
|
IsYoutubeSee: 1,
|
|
IsTiktokScreen: 1,
|
|
IsTiktokComment: 1,
|
|
IsTiktokQuote: 1,
|
|
IsTiktokAiGenerate: 1,
|
|
Cover: imgUrl,
|
|
PlatformIds: publishPlatformIds,
|
|
PublishAccounts: publishAccounts,
|
|
Videos: []Video{
|
|
{
|
|
VideoAddress: videoUrl,
|
|
VideoThumbnail: imgUrl,
|
|
},
|
|
},
|
|
}
|
|
if config.AppMode == "prod" {
|
|
url = "https://erp.fonchain.com/approval/v2/create"
|
|
req = CreateRequest{
|
|
Type: "SaasPublishVideo",
|
|
DepartmentID: 3,
|
|
Domain: "7bfa3942cceb20389822af7b57c5798e",
|
|
MenuType: 2,
|
|
SaasPublishVideo: saasPublishVideo,
|
|
}
|
|
} else {
|
|
url = "http://114.218.158.24:9020/approval/v2/create"
|
|
req = CreateRequest{
|
|
Type: "SaasPublishVideo",
|
|
DepartmentID: 3,
|
|
Domain: "7bfa3942cceb20389822af7b57c5798e",
|
|
MenuType: 2,
|
|
SaasPublishVideo: saasPublishVideo,
|
|
}
|
|
}
|
|
jsonBytes, err := json.Marshal(req)
|
|
if err != nil {
|
|
return err
|
|
|
|
}
|
|
res, err := http.Post(url, "application/json", bytes.NewBuffer(jsonBytes))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer res.Body.Close()
|
|
responseBodyBytes, err := io.ReadAll(res.Body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var apiResp APIResponse
|
|
err = json.Unmarshal(responseBodyBytes, &apiResp)
|
|
if err != nil {
|
|
// 处理错误
|
|
return err
|
|
}
|
|
fmt.Println("拿到审批ID:", apiResp.Data.ID)
|
|
_, err = service.CastProvider.UpdateStatus(ctx, &apiCast.UpdateStatusReq{
|
|
WorkUuid: workUuid,
|
|
WorkAction: apiCast.WorkActionENUM_APPROVAL,
|
|
ApprovalID: strconv.FormatUint(apiResp.Data.ID, 10),
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = service.CastProvider.UpdateStatus(ctx, &apiCast.UpdateStatusReq{
|
|
WorkUuid: workUuid,
|
|
WorkAction: apiCast.WorkActionENUM_APPROVAL_PASS,
|
|
ApprovalID: strconv.FormatUint(apiResp.Data.ID, 10),
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = service.BundleProvider.AddBundleBalance(ctx, &bundle.AddBundleBalanceReq{
|
|
UserId: int32(artistId),
|
|
VideoConsumptionNumber: 1,
|
|
})
|
|
if err != nil {
|
|
log.Printf(fmt.Sprintf("扣除余额失败: %s", err.Error()))
|
|
return err
|
|
}
|
|
_, err = service.CastProvider.UpdateStatus(ctx, &apiCast.UpdateStatusReq{
|
|
WorkAction: apiCast.WorkActionENUM_CONFIRM,
|
|
WorkUuid: workUuid,
|
|
ConfirmRemark: "",
|
|
ConfirmStatus: 1,
|
|
})
|
|
if err != nil {
|
|
log.Printf(fmt.Sprintf("更新状态失败: %s", err.Error()))
|
|
return err
|
|
}
|
|
return nil
|
|
}
|