Create & Init Project...

app/admin/main/tv/service/others.go

@@ -0,0 +1,177 @@
+package service
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"net/url"
+	"strconv"
+
+	"go-common/app/admin/main/tv/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/xstr"
+
+	"github.com/jinzhu/gorm"
+)
+
+// Playurl new playurl function, get url from API
+func (s *Service) Playurl(cid int) (playurl string, err error) {
+	if playurl, err = s.dao.Playurl(ctx, cid); err != nil {
+		log.Error("Playurl API Error(%d) (%v)", cid, err)
+		return
+	}
+	if playurl, err = s.hostChange(playurl); err != nil {
+		log.Error("hostChange Error(%s)-(%v)", playurl, err)
+		return
+	}
+	log.Info("NewPlayURL cid = %d, playurl = %s", cid, playurl)
+	return
+}
+
+// hostChange can change the url from playurl api to tvshenhe's host
+func (s *Service) hostChange(playurl string) (replacedURL string, err error) {
+	u, err := url.Parse(playurl)
+	if err != nil {
+		log.Error("hostChange ParseURL error (%v)", err)
+		return
+	}
+	log.Info("[hostChange] for URL: %s, Original Host: %s, Now we change it to: %s", playurl, u.Host, s.c.Cfg.Playpath)
+	u.Host = s.c.Cfg.Playpath // replace the host
+	u.RawQuery = ""           // remove useless query
+	replacedURL = u.String()
+	return
+}
+
+// Upload can upload a file object: store the info in Redis, and transfer the file to Bfs
+func (s *Service) Upload(c context.Context, fileName string, fileType string, timing int64, body []byte) (location string, err error) {
+	if location, err = s.dao.Upload(c, fileName, fileType, timing, body); err != nil {
+		log.Error("s.upload.Upload() error(%v)", err)
+	}
+	return
+}
+
+// unshelveReqT treats the unshelve request to db ( for update ) and dbSel (for select )
+func (s *Service) unshelveReqT(req *model.ReqUnshelve) (db, dbSel *gorm.DB, err error) {
+	if length := len(req.IDs); length == 0 || length > s.c.Cfg.AuditConsult.UnshelveNb {
+		err = ecode.RequestErr
+		return
+	}
+	switch req.Type {
+	case 1: // sid
+		db = s.DB.Model(&model.TVEpSeason{}).Where("is_deleted = 0").
+			Where(fmt.Sprintf("id IN (%s)", xstr.JoinInts(req.IDs)))
+		dbSel = db.Select("id")
+	case 2: // epid
+		db = s.DB.Model(&model.Content{}).Where("is_deleted = 0").
+			Where(fmt.Sprintf("epid IN (%s)", xstr.JoinInts(req.IDs)))
+		dbSel = db.Select("epid")
+	case 3: // aid
+		db = s.DB.Model(&model.Archive{}).Where("deleted = 0").
+			Where(fmt.Sprintf("aid IN (%s)", xstr.JoinInts(req.IDs)))
+		dbSel = db.Select("aid")
+	case 4: // cid
+		db = s.DB.Model(&model.Video{}).Where("deleted = 0").
+			Where(fmt.Sprintf("cid IN (%s)", xstr.JoinInts(req.IDs)))
+		dbSel = db.Select("cid")
+	default:
+		err = ecode.RequestErr
+	}
+	return
+}
+
+// Unshelve is to soft delete the media data
+func (s *Service) Unshelve(c context.Context, req *model.ReqUnshelve, username string) (resp *model.RespUnshelve, err error) {
+	var (
+		rows         *sql.Rows
+		existMap     = make(map[int64]int, len(req.IDs))
+		db, dbSelect *gorm.DB
+		updField     = make(map[string]int, 1)
+	)
+	log.Warn("Unshelve Req Type %d, IDs %v, Username %s", req.Type, req.IDs, username) // record user's action
+	resp = &model.RespUnshelve{
+		SuccIDs: make([]int64, 0),
+		FailIDs: make([]int64, 0),
+	}
+	if db, dbSelect, err = s.unshelveReqT(req); err != nil {
+		log.Error("unshelve ReqT Err %v", err)
+		return
+	}
+	if rows, err = dbSelect.Rows(); err != nil {
+		log.Error("db rows Ids %v, Err %v", req.IDs, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() { // pick existing ids
+		var sid int64
+		if err = rows.Scan(&sid); err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			return
+		}
+		resp.SuccIDs = append(resp.SuccIDs, sid)
+		existMap[sid] = 1
+	}
+	if err = rows.Err(); err != nil {
+		log.Error("rows.Err %v", err)
+		return
+	}
+	for _, v := range req.IDs { // treat to have the non-existing ids
+		if _, ok := existMap[v]; !ok {
+			resp.FailIDs = append(resp.FailIDs, v)
+		}
+	}
+	if len(resp.SuccIDs) == 0 { // there isn't any to update ids
+		return
+	}
+	switch req.Type {
+	case 1, 2: // sid, epid
+		updField["is_deleted"] = 1
+	case 3, 4: // aid, cid
+		updField["deleted"] = 1
+	}
+	if err = db.Update(updField).Error; err != nil {
+		log.Error("update Ids %v, err %v", req.IDs, err)
+	}
+	return
+}
+
+// ChlSplash gets channel's splash data
+func (s *Service) ChlSplash(c context.Context, req *model.ReqChannel) (res *model.ChannelPager, err error) {
+	var (
+		db    = s.DB.Model(&model.Channel{}).Where("deleted!=?", _isDeleted)
+		items []*model.ChannelFmt
+		count int64
+	)
+	if req.Desc != "" {
+		db = db.Where("`desc` LIKE ?", "%"+req.Desc+"%")
+	}
+	if req.Title != "" {
+		db = db.Where("title = ?", req.Title)
+	}
+	db.Count(&count)
+	if req.Order == model.OrderDesc {
+		db = db.Order("mtime DESC")
+	} else {
+		db = db.Order("mtime ASC")
+	}
+	if err = db.Offset((req.Page - 1) * _pagesize).Limit(_pagesize).Find(&items).Error; err != nil {
+		log.Error("chlList Error (%v)", err)
+		return
+	}
+	for _, v := range items {
+		v.MtimeFormat = s.TimeFormat(v.Mtime)
+		v.Mtime = 0
+	}
+	res = &model.ChannelPager{
+		TotalCount: count,
+		Pn:         req.Page,
+		Ps:         _pagesize,
+		Items:      items,
+	}
+	return
+}
+
+func atoi(str string) (res int) {
+	res, _ = strconv.Atoi(str)
+	return
+}