You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
356 lines
8.9 KiB
356 lines
8.9 KiB
package appeal |
|
|
|
import ( |
|
"context" |
|
xtime "go-common/library/time" |
|
"hash/crc32" |
|
"strconv" |
|
"strings" |
|
"time" |
|
|
|
"go-common/app/interface/main/creative/model/appeal" |
|
"go-common/app/interface/main/creative/model/archive" |
|
"go-common/app/service/main/account/model" |
|
"go-common/app/service/main/archive/api" |
|
"go-common/library/ecode" |
|
"go-common/library/log" |
|
) |
|
|
|
// List get appeal List. |
|
func (s *Service) List(c context.Context, mid int64, pn, ps int, tp, ip string) (all, open, closed int, res []*appeal.Appeal, err error) { |
|
list, err := s.ap.AppealList(c, mid, appeal.Business, ip) |
|
if err != nil { |
|
log.Error("s.ap.Appeals error(%v)", err) |
|
return |
|
} |
|
if len(list) == 0 { |
|
return |
|
} |
|
var ( |
|
start, end int |
|
oaps []*appeal.Appeal // open appeal |
|
caps []*appeal.Appeal // close appeal |
|
apTmp []*appeal.Appeal // tmp appeal . |
|
) |
|
aps := make([]*appeal.Appeal, 0, len(list)) |
|
for _, v := range list { |
|
ap := &appeal.Appeal{} |
|
ap.ID = v.ID |
|
ap.Oid = v.Oid |
|
ap.Cid = v.ID |
|
ap.Mid = v.Mid |
|
ap.State = v.BusinessState |
|
ap.Content = v.Desc |
|
ap.Description = v.Desc |
|
ap.CTime = v.CTime |
|
ap.MTime = v.MTime |
|
aps = append(aps, ap) |
|
} |
|
for _, v := range aps { |
|
if appeal.IsOpen(v.State) { |
|
oaps = append(oaps, v) |
|
} else { |
|
caps = append(caps, v) |
|
} |
|
} |
|
all = len(aps) |
|
open = len(oaps) |
|
closed = len(caps) |
|
if pn > 1 { |
|
start = (pn - 1) * ps |
|
} else { |
|
start = 0 |
|
} |
|
end = pn * ps |
|
if tp == "open" { |
|
apTmp = oaps |
|
} else if tp == "closed" { |
|
apTmp = caps |
|
} else { |
|
apTmp = aps |
|
} |
|
total := len(apTmp) |
|
if total == 0 { |
|
return |
|
} |
|
if total <= start { |
|
res = make([]*appeal.Appeal, 0) |
|
} else if total <= end { |
|
res = apTmp[start:total] |
|
} else { |
|
res = apTmp[start:end] |
|
} |
|
if len(res) > 0 { |
|
var ( |
|
aids []int64 |
|
aMap map[int64]*archive.ArcVideo |
|
) |
|
for _, v := range res { |
|
aids = append(aids, v.Oid) |
|
} |
|
if len(aids) > 0 { |
|
if aMap, err = s.arc.Views(c, mid, aids, ip); err != nil { |
|
log.Error("s.arc.Archives aids(%v), ip(%s) err(%v)", aids, ip, err) |
|
return |
|
} |
|
} |
|
for _, v := range res { |
|
if _, ok := aMap[v.Oid]; !ok { |
|
continue |
|
} |
|
arc := &api.Arc{ |
|
Aid: aMap[v.Oid].Archive.Aid, |
|
Pic: coverURL(aMap[v.Oid].Archive.Cover), |
|
Title: aMap[v.Oid].Archive.Title, |
|
State: int32(aMap[v.Oid].Archive.State), |
|
} |
|
v.ID = v.Cid |
|
v.Title = arc.Title |
|
v.Pics = arc.Pic |
|
v.Archive = arc |
|
} |
|
} |
|
return |
|
} |
|
|
|
// Detail get a appeal and events. |
|
func (s *Service) Detail(c context.Context, mid, cid int64, ip string) (ap *appeal.Appeal, err error) { |
|
var apmeta *appeal.AppealMeta |
|
if apmeta, err = s.ap.AppealDetail(c, mid, cid, appeal.Business, ip); err != nil { |
|
log.Error("s.ap.AppealDetail error(%v)", err) |
|
return |
|
} |
|
if apmeta == nil { |
|
err = ecode.AppealNotExist |
|
return |
|
} |
|
var ( |
|
av *archive.ArcVideo |
|
arc *api.Arc |
|
starStr, etimeStr string |
|
star, etime int64 |
|
) |
|
ap = &appeal.Appeal{} |
|
ap.ID = apmeta.ID |
|
ap.Oid = apmeta.Oid |
|
ap.Cid = apmeta.ID |
|
ap.Mid = apmeta.Mid |
|
ap.State = apmeta.BusinessState |
|
ap.Content = apmeta.Desc |
|
ap.Description = apmeta.Desc |
|
ap.CTime = apmeta.CTime |
|
ap.MTime = apmeta.MTime |
|
ap.Attachments = apmeta.Attachments |
|
if starStr, etimeStr, err = s.ap.AppealStarInfo(c, mid, cid, appeal.Business, ip); err != nil { |
|
log.Error("s.ap.AppealStarInfo(%d,%d) error(%v)", mid, cid, err) |
|
err = nil |
|
} |
|
if starStr != "" { |
|
star, err = strconv.ParseInt(starStr, 10, 64) |
|
if err != nil { |
|
log.Error("strconv.Atoi(%s) applealid(%d) error(%v)", starStr, cid, err) |
|
err = nil |
|
} |
|
ap.Star = int8(star) |
|
} |
|
if etimeStr != "" { |
|
etime, err = strconv.ParseInt(etimeStr, 10, 64) |
|
if err != nil { |
|
log.Error("strconv.Atoi(%s) applealid(%d) error(%v)", etimeStr, cid, err) |
|
err = nil |
|
} |
|
ap.MTime = xtime.Time(etime) |
|
} |
|
if av, err = s.arc.View(c, mid, ap.Oid, ip, 0, 0); err != nil { |
|
log.Error("s.arc.View(%d,%d) error(%v)", mid, ap.Oid, err) |
|
err = ecode.ArchiveNotExist |
|
return |
|
} |
|
if av != nil && av.Archive != nil { |
|
arc = &api.Arc{ |
|
Aid: av.Archive.Aid, |
|
Pic: coverURL(av.Archive.Cover), |
|
Title: av.Archive.Title, |
|
State: int32(av.Archive.State), |
|
} |
|
} |
|
if arc == nil { |
|
arc = &api.Arc{} |
|
} |
|
ap.Title = arc.Title |
|
ap.Aid = arc.Aid |
|
ap.Archive = arc |
|
eventTmp := make([]*appeal.Event, 0, len(apmeta.Events)) |
|
for _, v := range apmeta.Events { // Attachments 过滤管理员备注. |
|
if v.Event == 2 { |
|
continue |
|
} |
|
apev := &appeal.Event{} |
|
apev.ID = v.ID |
|
apev.AdminID = v.Adminid |
|
apev.Content = v.Content |
|
apev.ApID = v.Cid |
|
apev.Pics = v.Attachments |
|
apev.Event = v.Event |
|
apev.Attachments = v.Attachments |
|
apev.CTime = v.CTime |
|
apev.MTime = v.MTime |
|
eventTmp = append(eventTmp, apev) |
|
} |
|
ap.Events = eventTmp |
|
var strTmp []string |
|
for _, v := range ap.Attachments { |
|
strTmp = append(strTmp, v.Path) |
|
} |
|
ap.Pics = strings.Join(strTmp, ";") |
|
if ap.State == appeal.StateNoRead { |
|
if err = s.ap.AppealState(c, mid, cid, appeal.Business, appeal.StateReply, ip); err != nil { |
|
log.Error("s.ap.AppealState error(%v)", err) |
|
err = nil |
|
} |
|
} |
|
var ( |
|
pf *model.Profile |
|
) |
|
if pf, err = s.acc.Profile(c, mid, ip); err != nil { |
|
log.Error("s.acc.Profile(%d) mid(%d)|ip(%s)|error(%v)", mid, ip, err) |
|
return |
|
} |
|
if pf != nil { |
|
ap.UserInfo = &appeal.UserInfo{ |
|
MID: pf.Mid, |
|
Name: pf.Name, |
|
Sex: pf.Sex, |
|
Face: pf.Face, |
|
Rank: pf.Rank, |
|
Level: pf.Level, |
|
} |
|
} |
|
return |
|
} |
|
|
|
// State shutdown an appeal. |
|
func (s *Service) State(c context.Context, mid, cid, state int64, ip string) (err error) { |
|
if err = s.ap.AppealState(c, mid, cid, appeal.Business, state, ip); err != nil { |
|
log.Error("s.ap.AppealState error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// Add create an appeal. |
|
func (s *Service) Add(c context.Context, mid, aid int64, qq, phone, email, desc, attachments, ip string, ap *appeal.BusinessAppeal) (apID int64, err error) { |
|
arc, err := s.arc.View(c, mid, aid, ip, 0, 0) |
|
if err != nil { |
|
log.Error("s.arc.Archive error(%v)", err) |
|
err = ecode.CreativeArcServiceErr |
|
return |
|
} |
|
if arc == nil { |
|
log.Error("archive not exist") |
|
err = ecode.ArchiveNotExist |
|
return |
|
} |
|
if arc.Archive.Mid != mid { |
|
log.Error("login mid(%d) and archive mid(%d) are different ", mid, arc.Archive.Mid) |
|
err = ecode.AppealOwner |
|
return |
|
} |
|
if !appeal.Allow(arc.Archive.State) { |
|
log.Error("archive aid(%d) mid(%d) state(%d) ", aid, mid, arc.Archive.State) |
|
err = ecode.AppealLimit |
|
return |
|
} |
|
appeals, err := s.ap.AppealList(c, mid, appeal.Business, ip) |
|
if err != nil { |
|
log.Error("s.ap.AppealList error (%v)", err) |
|
return |
|
} |
|
for _, k := range appeals { |
|
if aid == k.Oid && appeal.IsOpen(k.BusinessState) { |
|
err = ecode.AppealOpen |
|
return |
|
} |
|
} |
|
var tid int64 |
|
tid, err = s.tag.AppealTag(c, aid, ip) |
|
if err != nil { |
|
log.Error("s.tag.AppealTag error(%v)", err) |
|
return |
|
} |
|
if tid == 0 && s.appealTag != 0 { |
|
tid = s.appealTag |
|
} |
|
if tid == 0 { |
|
log.Error("s.tag.AppealTag tid(%d)", tid) |
|
return |
|
} |
|
if apID, err = s.ap.AddAppeal(c, tid, aid, mid, appeal.Business, qq, phone, email, desc, attachments, ip, ap); err != nil { |
|
log.Error("s.ap.AddAppeal error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// Reply add reply an appeal. |
|
func (s *Service) Reply(c context.Context, mid, cid, event int64, content, attachments, ip string) (err error) { |
|
if err = s.ap.AddReply(c, cid, event, content, attachments, ip); err != nil { |
|
log.Error("s.ap.AddReply error(%v)", err) |
|
return |
|
} |
|
if err = s.ap.AppealState(c, mid, cid, appeal.Business, appeal.StateCreate, ip); err != nil { |
|
log.Error("user add reply s.ap.AppealState error(%v)", err) |
|
err = nil |
|
} |
|
return |
|
} |
|
|
|
// PhoneEmail get user phone & email |
|
func (s *Service) PhoneEmail(c context.Context, ck, ip string) (ct *appeal.Contact, err error) { |
|
if ct, err = s.acc.PhoneEmail(c, ck, ip); err != nil { |
|
log.Error("s.acc.PhoneEmail error(%v)", err) |
|
} |
|
if ct == nil { |
|
err = ecode.NothingFound |
|
} |
|
return |
|
} |
|
|
|
// Star give star to appeal. |
|
func (s *Service) Star(c context.Context, mid, cid, star int64, ip string) (err error) { |
|
if err = s.ap.AppealExtra(c, mid, cid, appeal.Business, star, "star", ip); err != nil { |
|
log.Error("s.ap.AppealExtra error(%v)", err) |
|
return |
|
} |
|
if err = s.ap.AppealExtra(c, mid, cid, appeal.Business, time.Now().Unix(), "etime", ip); err != nil { |
|
log.Error("s.ap.AppealExtra error(%v)", err) |
|
return |
|
} |
|
if s.ap.AppealState(c, mid, cid, appeal.Business, appeal.StateUserFinished, ip); err != nil { |
|
log.Error("star change stats s.ap.AppealState error(%v)", err) |
|
err = nil |
|
} |
|
return |
|
} |
|
|
|
// coverURL convert cover url to full url. |
|
func coverURL(uri string) (cover string) { |
|
if uri == "" { |
|
return |
|
} |
|
cover = uri |
|
if strings.Index(uri, "http://") == 0 { |
|
return |
|
} |
|
if len(uri) >= 10 && uri[:10] == "/templets/" { |
|
return |
|
} |
|
if strings.HasPrefix(uri, "group1") { |
|
cover = "http://i0.hdslb.com/" + uri |
|
return |
|
} |
|
if pos := strings.Index(uri, "/uploads/"); pos != -1 && (pos == 0 || pos == 3) { |
|
cover = uri[pos+8:] |
|
} |
|
cover = strings.Replace(cover, "{IMG}", "", -1) |
|
cover = "http://i" + strconv.FormatInt(int64(crc32.ChecksumIEEE([]byte(cover)))%3, 10) + ".hdslb.com" + cover |
|
return |
|
}
|
|
|