Create & Init Project...

app/interface/main/tv/service/audit/BUILD

@@ -0,0 +1,51 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["service_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = ["//app/interface/main/tv/conf:go_default_library"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "audit.go",
+        "service.go",
+        "transcode.go",
+    ],
+    importpath = "go-common/app/interface/main/tv/service/audit",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/tv/conf:go_default_library",
+        "//app/interface/main/tv/dao/audit:go_default_library",
+        "//app/interface/main/tv/dao/cms:go_default_library",
+        "//app/interface/main/tv/model:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/interface/main/tv/service/audit/audit.go

@@ -0,0 +1,70 @@
+package audit
+
+import (
+	"context"
+
+	"go-common/app/interface/main/tv/model"
+	"go-common/library/database/sql"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+// HandleAudits treats the slice of IDList
+func (s *Service) HandleAudits(ctx context.Context, vals []*model.IDList) (err error) {
+	var tx *sql.Tx
+	if tx, err = s.auditDao.BeginTran(ctx); err != nil {
+		log.Error("audit HandleAudits BeginTran Err %v", err)
+		return
+	}
+	for _, v := range vals {
+		if err = s.handleAudit(ctx, v, tx); err != nil {
+			log.Error("HandleAudits audit (%v), err %v", v, err)
+			tx.Rollback()
+			return
+		}
+	}
+	tx.Commit()
+	return
+}
+
+// handleAudit checks the prefix to dispatch the task to ugc/pgc season/ep
+func (s *Service) handleAudit(ctx context.Context, val *model.IDList, tx *sql.Tx) (err error) {
+	var (
+		op = new(model.AuditOp)
+	)
+	if err = op.FromIDList(val); err != nil {
+		log.Error("audit handle Type error %v", val)
+		return
+	}
+	switch op.ContentType {
+	case model.UgcArc:
+		if arcCMS, err := s.cmsDao.LoadArcMeta(ctx, op.KID); err == nil && arcCMS != nil && arcCMS.NotDeleted() {
+			return auditCore(ctx, op, tx, s.auditDao.UpdateArc)
+		}
+	case model.UgcVideo:
+		if videoCMS, err := s.cmsDao.LoadVideoMeta(ctx, op.KID); err == nil && videoCMS != nil && videoCMS.NotDeleted() {
+			return auditCore(ctx, op, tx, s.auditDao.UpdateVideo)
+		}
+	case model.PgcSn:
+		if snCMS, err := s.cmsDao.SnAuth(ctx, op.KID); err == nil && snCMS != nil && snCMS.NotDeleted() {
+			return auditCore(ctx, op, tx, s.auditDao.UpdateSea)
+		}
+	case model.PgcEp:
+		if epCMS, err := s.cmsDao.EpAuth(ctx, op.KID); err == nil && epCMS != nil && epCMS.NotDeleted() {
+			return auditCore(ctx, op, tx, s.auditDao.UpdateCont)
+		}
+	default:
+		log.Error("audit handle Content Type Error %s", op.ToMsg())
+		return ecode.TvDangbeiWrongType
+	}
+	return ecode.NothingFound
+}
+
+type doAudit func(ctx context.Context, v *model.AuditOp, tx *sql.Tx) (err error)
+
+func auditCore(c context.Context, v *model.AuditOp, tx *sql.Tx, updateFunc doAudit) (err error) {
+	if err = updateFunc(c, v, tx); err != nil {
+		log.Error("%s fail(%v)", v.ToMsg(), err)
+	}
+	return
+}

app/interface/main/tv/service/audit/service.go

@@ -0,0 +1,24 @@
+package audit
+
+import (
+	"go-common/app/interface/main/tv/conf"
+	auditDao "go-common/app/interface/main/tv/dao/audit"
+	"go-common/app/interface/main/tv/dao/cms"
+)
+
+// Service .
+type Service struct {
+	conf     *conf.Config
+	auditDao *auditDao.Dao
+	cmsDao   *cms.Dao
+}
+
+// New .
+func New(c *conf.Config) *Service {
+	srv := &Service{
+		conf:     c,
+		auditDao: auditDao.New(c),
+		cmsDao:   cms.New(c),
+	}
+	return srv
+}

app/interface/main/tv/service/audit/service_test.go

@@ -0,0 +1,21 @@
+package audit
+
+import (
+	"flag"
+	"path/filepath"
+	"time"
+
+	"go-common/app/interface/main/tv/conf"
+)
+
+var (
+	srv *Service
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/tv-interface.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	srv = New(conf.Conf)
+	time.Sleep(time.Second)
+}

app/interface/main/tv/service/audit/transcode.go

@@ -0,0 +1,75 @@
+package audit
+
+import (
+	"context"
+
+	"go-common/app/interface/main/tv/model"
+	"go-common/library/ecode"
+)
+
+const (
+	_typeUGC = "ugc"
+	_typePGC = "pgc"
+)
+
+type cidExistFunc = func(context.Context, int64) ([]int64, error)
+type cidTransFunc = func(context.Context, []int64, int64) error
+type reqTrans struct {
+	CID       int64
+	Action    int64
+	CheckFunc cidExistFunc
+	TransFunc cidTransFunc
+}
+
+// Transcode update the video/ep's transcoded status
+func (s *Service) Transcode(req *model.ReqTransode) (err error) {
+	var ctx = context.TODO()
+	if req.ContType == _typePGC {
+		err = s.transPGC(ctx, req.CID, req.Action)
+	} else if req.ContType == _typeUGC {
+		err = s.transUGC(ctx, req.CID, req.Action)
+	} else {
+		err = ecode.TvDangbeiWrongType
+	}
+	return
+}
+
+func commonTrans(ctx context.Context, req reqTrans) (err error) {
+	var ids []int64
+	if ids, err = req.CheckFunc(ctx, req.CID); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		return ecode.NothingFound
+	}
+	err = req.TransFunc(ctx, ids, req.Action)
+	return
+}
+
+func (s *Service) transPGC(ctx context.Context, cid int64, action int64) (err error) {
+	return commonTrans(ctx, reqTrans{
+		CID:       cid,
+		Action:    action,
+		CheckFunc: s.auditDao.PgcCID,
+		TransFunc: s.auditDao.PgcTranscode,
+	})
+}
+
+func (s *Service) transUGC(ctx context.Context, cid int64, action int64) (err error) {
+	return commonTrans(ctx, reqTrans{
+		CID:       cid,
+		Action:    action,
+		CheckFunc: s.auditDao.UgcCID,
+		TransFunc: s.auditDao.UgcTranscode,
+	})
+}
+
+// ApplyPGC saves the pgc transcode apply time
+func (s *Service) ApplyPGC(ctx context.Context, req *model.ReqApply) (err error) {
+	return commonTrans(ctx, reqTrans{
+		CID:       req.CID,
+		Action:    req.ApplyTime,
+		CheckFunc: s.auditDao.PgcCID,
+		TransFunc: s.auditDao.ApplyPGC,
+	})
+}