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.
116 lines
2.8 KiB
116 lines
2.8 KiB
package service |
|
|
|
import ( |
|
"context" |
|
"sort" |
|
|
|
"go-common/app/admin/main/workflow/model" |
|
"go-common/app/admin/main/workflow/model/param" |
|
"go-common/library/log" |
|
) |
|
|
|
// AddEvent will add a event |
|
func (s *Service) AddEvent(c context.Context, ep *param.EventParam) (eid int64, err error) { |
|
e := &model.Event{ |
|
Cid: ep.Cid, |
|
AdminID: ep.AdminID, |
|
Content: ep.Content, |
|
Attachments: ep.Attachments, |
|
Event: ep.Event, |
|
} |
|
|
|
if err = s.dao.ORM.Create(e).Error; err != nil { |
|
log.Error("Failed to create event(%v): %v", e, err) |
|
return |
|
} |
|
eid = e.Eid |
|
s.task(func() { |
|
var c *model.Chall |
|
if c, err = s.dao.Chall(context.Background(), e.Cid); err != nil { |
|
log.Error("s.dao.Chall(%d) error(%v)", e.Cid, err) |
|
err = nil |
|
return |
|
} |
|
s.afterAddReply(ep, c) |
|
}) |
|
|
|
return |
|
} |
|
|
|
// BatchAddEvent will add events to batch chall |
|
func (s *Service) BatchAddEvent(c context.Context, bep *param.BatchEventParam) (eids []int64, err error) { |
|
if len(bep.Cids) <= 0 { |
|
return |
|
} |
|
eids = make([]int64, 0, len(bep.Cids)) |
|
|
|
for _, cid := range bep.Cids { |
|
e := &model.Event{ |
|
Cid: cid, |
|
AdminID: bep.AdminID, |
|
Content: bep.Content, |
|
Attachments: bep.Attachments, |
|
Event: bep.Event, |
|
} |
|
if err = s.dao.ORM.Create(e).Error; err != nil { |
|
log.Error("Failed to create event(%v): %v", e, err) |
|
return |
|
} |
|
eids = append(eids, int64(e.Eid)) |
|
} |
|
|
|
s.task(func() { |
|
var challs map[int64]*model.Chall |
|
if challs, err = s.dao.Challs(context.Background(), bep.Cids); err != nil { |
|
log.Error("s.dao.Challs(%v) error(%v)", bep.Cids, err) |
|
return |
|
} |
|
s.afterAddMultiReply(bep, challs) |
|
}) |
|
return |
|
} |
|
|
|
// ListEvent will add a set of events by challenge id |
|
func (s *Service) ListEvent(c context.Context, cid int64) (eventList model.EventSlice, err error) { |
|
var ( |
|
events map[int64]*model.Event |
|
) |
|
if events, err = s.dao.EventsByCid(c, cid); err != nil { |
|
log.Error("Failed to s.dao.Events(%d): %v", cid, err) |
|
return |
|
} |
|
|
|
eventList = make(model.EventSlice, 0, len(events)) |
|
for _, e := range events { |
|
eventList = append(eventList, e) |
|
} |
|
|
|
sort.Slice(eventList, func(i, j int) bool { |
|
return eventList[i].CTime < eventList[j].CTime |
|
}) |
|
return |
|
} |
|
|
|
// batchLastEvent will return the last log on specified targets |
|
func (s *Service) batchLastEvent(c context.Context, cids []int64) (cEvents map[int64]*model.Event, err error) { |
|
var ( |
|
eids []int64 |
|
events map[int64]*model.Event |
|
) |
|
|
|
if eids, err = s.dao.BatchLastEventIDs(c, cids); err != nil { |
|
log.Error("s.dao.BatchLastEventIDs(%d) error(%v)", cids, err) |
|
return |
|
} |
|
if events, err = s.dao.EventsByIDs(c, eids); err != nil { |
|
log.Error("s.dao.EventsByIDs(%d) error(%v)", eids, err) |
|
return |
|
} |
|
|
|
cEvents = make(map[int64]*model.Event, len(eids)) |
|
for _, e := range events { |
|
cEvents[e.Cid] = e |
|
} |
|
|
|
return |
|
}
|
|
|