service/app/mix/service/imageauditservice.go

package service

import (
	"service/api/consts"
	"service/bizcommon/util"
	"service/dbstruct"
	"service/library/logger"

	imageauditproto "service/api/proto/imageaudit/proto"
	imageaudittaskproto "service/api/proto/imageaudittask/proto"

	"github.com/gin-gonic/gin"
	goproto "google.golang.org/protobuf/proto"
)

func (s *Service) CreateUpdateAccountImageAudit(ctx *gin.Context, oldAccount *dbstruct.Account, newAccount *dbstruct.Account) (tasks []*dbstruct.ImageAuditTask) {
	if newAccount.Avatar == nil {
		return nil
	}
	if util.IsInt64SliceEqualAsSet(oldAccount.Avatar.GetImageIds(), newAccount.Avatar.GetImageIds()) {
		return nil
	}

	tasks = make([]*dbstruct.ImageAuditTask, 0)

	tasks = append(tasks, &dbstruct.ImageAuditTask{
		RouteUrl:               goproto.String(ctx.Request.URL.Path),
		AssociativeDatabase:    goproto.String("account"),
		AssociativeTableName:   goproto.String("account"),
		AssociativeTableId:     newAccount.Mid,
		AssociativeTableColumn: goproto.String("avatar"),
		AuditedMedia:           newAccount.Avatar,
		OldMedia:               oldAccount.Avatar,
	})

	addImageAuditTasks(ctx, tasks)

	return
}

func (s *Service) CreateUpdateStreamerImageAudit(ctx *gin.Context, oldStreamer *dbstruct.Streamer, newStreamer *dbstruct.Streamer) (tasks []*dbstruct.ImageAuditTask) {
	tasks = make([]*dbstruct.ImageAuditTask, 0)

	if newStreamer.Cover != nil && !util.IsInt64SliceEqualAsSet(oldStreamer.Cover.GetImageIds(), newStreamer.Cover.GetImageIds()) {
		tasks = append(tasks, &dbstruct.ImageAuditTask{
			RouteUrl:               goproto.String(ctx.Request.URL.Path),
			AssociativeDatabase:    goproto.String("streamer"),
			AssociativeTableName:   goproto.String("streamer"),
			AssociativeTableId:     oldStreamer.Mid,
			AssociativeTableColumn: goproto.String("cover"),
			AuditedMedia:           newStreamer.Cover,
			OldMedia:               oldStreamer.Cover,
		})
	}

	if newStreamer.Album != nil && !util.IsInt64SliceEqualAsSet(oldStreamer.Album.GetImageIds(), newStreamer.Album.GetImageIds()) {
		tasks = append(tasks, &dbstruct.ImageAuditTask{
			RouteUrl:               goproto.String(ctx.Request.URL.Path),
			AssociativeDatabase:    goproto.String("streamer"),
			AssociativeTableName:   goproto.String("streamer"),
			AssociativeTableId:     oldStreamer.Mid,
			AssociativeTableColumn: goproto.String("album"),
			AuditedMedia:           newStreamer.Album,
			OldMedia:               oldStreamer.Album,
		})
	}

	addImageAuditTasks(ctx, tasks)

	return
}

func (s *Service) CreateMomentImageAudit(ctx *gin.Context, newMoment *dbstruct.Moment) (tasks []*dbstruct.ImageAuditTask) {

	if newMoment.MediaComp != nil && len(newMoment.MediaComp.GetImageIds()) > 0 {
		tasks = append(tasks, &dbstruct.ImageAuditTask{
			RouteUrl:               goproto.String(ctx.Request.URL.Path),
			AssociativeDatabase:    goproto.String("moment"),
			AssociativeTableName:   goproto.String("moment"),
			AssociativeTableId:     newMoment.Id,
			AssociativeTableColumn: goproto.String("media_component"),
			AuditedMedia:           newMoment.MediaComp,
			OldMedia:               nil,
			IsAligned:              goproto.Int64(consts.ImageAuditIsAligned_Yes),
		})
	}

	addImageAuditTasks(ctx, tasks)

	return
}

func (s *Service) CreateZoneMomentImageAudit(ctx *gin.Context, newZoneMoment *dbstruct.ZoneMoment) (tasks []*dbstruct.ImageAuditTask) {

	if newZoneMoment.MediaComp != nil && len(newZoneMoment.MediaComp.GetImageIds()) > 0 {
		tasks = append(tasks, &dbstruct.ImageAuditTask{
			RouteUrl:               goproto.String(ctx.Request.URL.Path),
			AssociativeDatabase:    goproto.String("zone_moment"),
			AssociativeTableName:   goproto.String("zone_moment"),
			AssociativeTableId:     newZoneMoment.Id,
			AssociativeTableColumn: goproto.String("media_component"),
			AuditedMedia:           newZoneMoment.MediaComp,
			OldMedia:               nil,
			IsAligned:              goproto.Int64(consts.ImageAuditIsAligned_Yes),
		})
	}

	addImageAuditTasks(ctx, tasks)

	return
}

func addImageAuditTasks(ctx *gin.Context, tasks []*dbstruct.ImageAuditTask) error {
	for _, task := range tasks {
		err := addImageAuditTask(ctx, task)
		if err != nil {
			return err
		}
	}
	return nil
}

func addImageAuditTask(ctx *gin.Context, task *dbstruct.ImageAuditTask) error {
	if task == nil || task.AuditedMedia == nil {
		return nil
	}
	fragmentNum := len(task.AuditedMedia.GetImageIds())
	if fragmentNum == 0 {
		return nil
	}

	batchId, err := _DefaultContentAuditRTI.GetImageAuditBatchId(ctx)
	if err != nil {
		return err
	}

	task.BatchId = goproto.String(batchId)
	task.Status = goproto.Int64(consts.ImageAudit_Created)

	if fragmentNum == 1 {
		task.IsFragmented = goproto.Int64(0)
		task.FragmentsNum = goproto.Int64(1)

		// 写入图像审核表
		if err := prepareNotFragmentedImageAuditTask(ctx, task); err != nil {
			return err
		}
	} else {
		task.IsFragmented = goproto.Int64(1)
		task.FragmentsNum = goproto.Int64(int64(fragmentNum))

		// 写入图像审核表
		if err := prepareFragmentedImageAuditTask(ctx, task); err != nil {
			return err
		}
	}

	// 写入图像审核任务表
	if err := _DefaultImageAuditTask.OpCreate(ctx, &imageaudittaskproto.OpCreateReq{
		ImageAuditTask: task,
	}); err != nil {
		logger.Error("Imageaudittask OpCreate failed: %v", err)
		return err
	}

	return nil
}

// 根据任务信息，创建单个图片的图片审核，并存入数据库，返回images
func prepareFragmentedImageAuditTask(ctx *gin.Context, task *dbstruct.ImageAuditTask) (err error) {

	fragmentsNum := util.DerefInt64(task.FragmentsNum)
	imageAudits := make([]*dbstruct.ImageAudit, fragmentsNum)

	// 将媒体拆分为单个图像并存入图片审核表
	imageIds := task.AuditedMedia.GetImageIds()
	for i, imageId := range imageIds {
		image := &dbstruct.MediaComponent{
			ImageIds: util.Int64Slice([]int64{imageId}),
		}
		imageAudits[i] = &dbstruct.ImageAudit{
			AuditedMedia: image,
			BatchId:      task.BatchId,
			Status:       goproto.Int64(consts.ImageAudit_Created),
		}
	}
	if err = _DefaultImageAudit.OpCreateFragmentGroup(ctx, &imageauditproto.OpCreateBatchReq{
		ImageAudits:  imageAudits,
		FragmentsNum: fragmentsNum,
	}); err != nil {
		logger.Error("Imageaudit OpCreateFragmentGroup failed: %v", err)
		return
	}

	auditFragmentIds := make([]string, fragmentsNum)
	for i, imageaudit := range imageAudits {
		auditFragmentIds[i] = util.DerefString(imageaudit.Id)
	}
	task.ImageAuditFragmentIds = &auditFragmentIds
	return
}

func prepareNotFragmentedImageAuditTask(ctx *gin.Context, task *dbstruct.ImageAuditTask) (err error) {

	imageAudit := &dbstruct.ImageAudit{
		AuditedMedia: task.AuditedMedia,
		BatchId:      task.BatchId,
		Status:       goproto.Int64(consts.ImageAudit_Created),
	}
	if err = _DefaultImageAudit.OpCreate(ctx, &imageauditproto.OpCreateReq{
		ImageAudit: imageAudit,
	}); err != nil {
		logger.Error("Imageaudit OpCreate failed: %v", err)
		return
	}

	task.ImageAuditId = imageAudit.Id
	return
}