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.
584 lines
18 KiB
584 lines
18 KiB
package dao |
|
|
|
import ( |
|
"context" |
|
"database/sql" |
|
"encoding/json" |
|
"fmt" |
|
"time" |
|
|
|
"go-common/app/admin/main/spy/conf" |
|
"go-common/app/admin/main/spy/model" |
|
xsql "go-common/library/database/sql" |
|
"go-common/library/log" |
|
) |
|
|
|
const ( |
|
_eventSQL = "SELECT id,name,nick_name,service_id,ctime,mtime FROM spy_event WHERE name=? AND deleted = 0 LIMIT 1;" |
|
_allGroupSQL = "SELECT id, name, ctime FROM spy_factor_group;" |
|
_updateFactorSQL = "UPDATE spy_factor SET factor_val = ? WHERE id = ?;" |
|
_factorAllSQL = "SELECT id,nick_name,service_id,event_id,group_id,risk_level,factor_val,ctime,mtime FROM spy_factor WHERE group_id = ? ORDER BY factor_val;" |
|
_getList = "SELECT id,mid,event_id,score,base_score,event_score,remark,reason,factor_val,ctime FROM spy_user_event_history_%02d WHERE %s ORDER BY id DESC LIMIT %d,%d;" |
|
_getListTc = "SELECT COUNT(1) FROM spy_user_event_history_%02d WHERE %s;" |
|
_addLogSQL = "INSERT INTO `spy_log`(`name`,`module`,`context`,`ref_id`,`ctime`)VALUES(?,?,?,?,?);" |
|
_getSettingListSQL = "SELECT id,property,name,val,ctime,mtime FROM spy_system_config" |
|
_updateSettingSQL = "UPDATE spy_system_config SET val=? WHERE property=?" |
|
_getUserInfoSQL = "SELECT id,mid,score,base_score,event_score,state,relive_times,mtime FROM spy_user_info_%02d WHERE mid=?" |
|
_addFactorSQL = "INSERT INTO `spy_factor`(`nick_name`,`service_id`,`event_id`,`group_id`,`risk_level`,`factor_val`,`category_id`,`ctime`)VALUES(?,?,?,?,?,?,?,?);" |
|
_addEventSQL = "INSERT INTO `spy_event`(`name`,`nick_name`,`service_id`,`status`,`ctime`,`mtime`)VALUES(?,?,?,?,?,?);" |
|
_addServiceSQL = "INSERT INTO `spy_service`(`name`,`nick_name`,`status`,`ctime`,`mtime`)VALUES(?,?,?,?,?);" |
|
_addGroupSQL = "INSERT INTO `spy_factor_group`(`name`,`ctime`)VALUES(?,?);" |
|
_getReportList = "SELECT id, name, date_version, val, ctime FROM spy_report limit ?,?;" |
|
_getReportCount = "SELECT COUNT(1) FROM spy_report;" |
|
_updateStatStateSQL = "UPDATE spy_statistics SET state=? WHERE id=?" |
|
_updateStatQuantitySQL = "UPDATE spy_statistics SET quantity=? WHERE id=?" |
|
_updateStatDeleteSQL = "UPDATE spy_statistics SET isdel=? WHERE id=?" |
|
_statByIDSQL = "SELECT id,target_mid,target_id,event_id,state,type,quantity,isdel,ctime,mtime FROM spy_statistics WHERE id = ?;" |
|
_logListSQL = "SELECT id,ref_id,name,module,context,ctime FROM spy_log WHERE ref_id = ? AND module = ?;" |
|
_statListByMidSQL = "SELECT id,target_mid,target_id,event_id,state,type,quantity,isdel,ctime,mtime FROM spy_statistics WHERE target_mid = ? AND isdel = 0 ORDER BY id desc limit ?,?;" |
|
_statListByIDSQL = "SELECT id,target_mid,target_id,event_id,state,type,quantity,isdel,ctime,mtime FROM spy_statistics WHERE target_id = ? AND type = ? AND isdel = 0 ORDER BY id desc limit ?,?;" |
|
_statCountByMidSQL = "SELECT COUNT(1) FROM spy_statistics WHERE target_mid = ? AND isdel = 0;" |
|
_statCountByIDSQL = "SELECT COUNT(1) FROM spy_statistics WHERE target_id = ? AND type = ? AND isdel = 0;" |
|
_allEventSQL = "SELECT id,name,nick_name,service_id,status,ctime,mtime FROM spy_event WHERE status<>0" |
|
_updateEventNameSQL = "UPDATE spy_event SET nick_name = ? WHERE id = ?;" |
|
) |
|
|
|
// Event get event from db. |
|
func (d *Dao) Event(ctx context.Context, eventName string) (event *model.Event, err error) { |
|
var ( |
|
row *xsql.Row |
|
) |
|
event = &model.Event{} |
|
row = d.eventStmt.QueryRow(ctx, eventName) |
|
if err = row.Scan(&event.ID, &event.Name, &event.NickName, &event.ServiceID, &event.CTime, &event.MTime); err != nil { |
|
if err == sql.ErrNoRows { |
|
err = nil |
|
return |
|
} |
|
log.Error("row.Scan() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// Factors get all factor info by group id. |
|
func (d *Dao) Factors(c context.Context, gid int64) (res []*model.Factor, err error) { |
|
var rows *xsql.Rows |
|
if rows, err = d.factorAllStmt.Query(c, gid); err != nil { |
|
log.Error("d.allTypesStmt.Query(%d) error(%v)", gid, err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
r := new(model.Factor) |
|
if err = rows.Scan(&r.ID, &r.NickName, &r.ServiceID, &r.EventID, &r.GroupID, &r.RiskLevel, &r.FactorVal, &r.CTime, &r.MTime); err != nil { |
|
log.Error("row.Scan() error(%v)", err) |
|
res = nil |
|
return |
|
} |
|
res = append(res, r) |
|
} |
|
err = rows.Err() |
|
return |
|
} |
|
|
|
// Groups get all group info. |
|
func (d *Dao) Groups(c context.Context) (res []*model.FactorGroup, err error) { |
|
var rows *xsql.Rows |
|
if rows, err = d.allGroupStmt.Query(c); err != nil { |
|
log.Error("d.allGroupStmt.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
r := new(model.FactorGroup) |
|
if err = rows.Scan(&r.ID, &r.Name, &r.CTime); err != nil { |
|
log.Error("row.Scan() error(%v)", err) |
|
res = nil |
|
return |
|
} |
|
res = append(res, r) |
|
} |
|
err = rows.Err() |
|
return |
|
} |
|
|
|
// UpdateFactor update factor. |
|
func (d *Dao) UpdateFactor(c context.Context, factorVal float32, id int64) (affected int64, err error) { |
|
var res sql.Result |
|
if res, err = d.db.Exec(c, _updateFactorSQL, factorVal, id); err != nil { |
|
log.Error("_updateFactorSQL: db.Exec(%v, %d) error(%v)", factorVal, id, err) |
|
return |
|
} |
|
return res.RowsAffected() |
|
} |
|
|
|
func hitHistory(id int64) int64 { |
|
return id % conf.Conf.Property.HistoryShard |
|
} |
|
|
|
// genListSQL get history sql |
|
func (d *Dao) genListSQL(SQLType string, h *model.HisParamReq) (SQL string, values []interface{}) { |
|
values = make([]interface{}, 0, 1) |
|
cond := " mid = ?" |
|
values = append(values, h.Mid) |
|
switch SQLType { |
|
case "list": |
|
SQL = fmt.Sprintf(_getList, hitHistory(h.Mid), cond, (h.Pn-1)*h.Ps, h.Ps) |
|
case "count": |
|
SQL = fmt.Sprintf(_getListTc, hitHistory(h.Mid), cond) |
|
} |
|
return |
|
} |
|
|
|
//HistoryPage user event history. |
|
func (d *Dao) HistoryPage(c context.Context, h *model.HisParamReq) (hs []*model.EventHistoryDto, err error) { |
|
SQL, values := d.genListSQL("list", h) |
|
rows, err := d.db.Query(c, SQL, values...) |
|
if err != nil { |
|
log.Error("dao.QuestionPage(%v,%v) error(%v)", SQL, values, err) |
|
return |
|
} |
|
defer rows.Close() |
|
hs = make([]*model.EventHistoryDto, 0, h.Ps) |
|
for rows.Next() { |
|
hdb := &model.EventHistory{} |
|
err = rows.Scan(&hdb.ID, &hdb.Mid, &hdb.EventID, &hdb.Score, &hdb.BaseScore, &hdb.EventScore, |
|
&hdb.Remark, &hdb.Reason, &hdb.FactorVal, &hdb.Ctime) |
|
eventMSG := &model.EventMessage{} |
|
if err = json.Unmarshal([]byte(hdb.Remark), eventMSG); err != nil { |
|
log.Error("json.Unmarshal(%s) error(%v)", hdb.Remark, err) |
|
} else { |
|
hdb.TargetID = eventMSG.TargetID |
|
hdb.TargetMid = eventMSG.TargetMid |
|
} |
|
if err != nil { |
|
log.Error("rows.Scan error(%v)", err) |
|
return |
|
} |
|
h := &model.EventHistoryDto{ |
|
ID: hdb.ID, |
|
Score: hdb.Score, |
|
BaseScore: hdb.BaseScore, |
|
EventScore: hdb.EventScore, |
|
Reason: hdb.Reason, |
|
Ctime: hdb.Ctime.Unix(), |
|
TargetID: hdb.TargetID, |
|
TargetMid: hdb.TargetMid, |
|
} |
|
if eventMSG.Time != 0 { |
|
_, offset := time.Now().Zone() |
|
t := time.Unix(eventMSG.Time, 0).Add(-time.Duration(offset) * time.Second) |
|
h.SpyTime = t.Unix() |
|
} |
|
hs = append(hs, h) |
|
} |
|
return |
|
} |
|
|
|
// HistoryPageTotalC user ecent history page. |
|
func (d *Dao) HistoryPageTotalC(c context.Context, h *model.HisParamReq) (totalCount int, err error) { |
|
SQL, values := d.genListSQL("count", h) |
|
row := d.db.QueryRow(c, SQL, values...) |
|
if err = row.Scan(&totalCount); err != nil { |
|
if err == sql.ErrNoRows { |
|
row = nil |
|
err = nil |
|
} else { |
|
log.Error("row.Scan error(%v)", err) |
|
} |
|
} |
|
return |
|
} |
|
|
|
//AddLog add log. |
|
func (d *Dao) AddLog(c context.Context, l *model.Log) (affected int64, err error) { |
|
var res sql.Result |
|
if res, err = d.db.Exec(c, _addLogSQL, l.Name, l.Module, l.Context, l.RefID, l.Ctime); err != nil { |
|
fmt.Println("add log ", err) |
|
log.Error("add question: d.db.Exec(%v) error(%v)", l, err) |
|
return |
|
} |
|
return res.RowsAffected() |
|
} |
|
|
|
// SettingList get all setting list |
|
func (d *Dao) SettingList(c context.Context) (list []*model.Setting, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
list = make([]*model.Setting, 0) |
|
if rows, err = d.db.Query(c, _getSettingListSQL); err != nil { |
|
log.Error("d.db.Query(%s) error(%v)", _getSettingListSQL, err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
var setting = &model.Setting{} |
|
if err = rows.Scan(&setting.ID, &setting.Property, &setting.Name, &setting.Val, &setting.CTime, &setting.MTime); err != nil { |
|
log.Error("rows.Scan() error(%v)", err) |
|
return |
|
} |
|
list = append(list, setting) |
|
} |
|
return |
|
} |
|
|
|
// UpdateSetting update setting |
|
func (d *Dao) UpdateSetting(c context.Context, property string, val string) (affected int64, err error) { |
|
var res sql.Result |
|
if res, err = d.db.Exec(c, _updateSettingSQL, val, property); err != nil { |
|
log.Error("d.db.Exec(%s,%d,%s) error(%v)", _updateSettingSQL, val, property) |
|
return |
|
} |
|
if affected, err = res.RowsAffected(); err != nil { |
|
log.Error("res.RowsAffected() error(%v)", err) |
|
return |
|
} |
|
return |
|
} |
|
|
|
func hitInfo(id int64) int64 { |
|
return id % conf.Conf.Property.UserInfoShard |
|
} |
|
|
|
// Info get lastest user info by mid. |
|
func (d *Dao) Info(c context.Context, mid int64) (res *model.UserInfo, err error) { |
|
res = &model.UserInfo{} |
|
hitIndex := hitInfo(mid) |
|
row := d.getUserInfoStmt[hitIndex].QueryRow(c, mid) |
|
if err = row.Scan(&res.ID, &res.Mid, &res.Score, &res.BaseScore, &res.EventScore, &res.State, &res.ReliveTimes, |
|
&res.Mtime); err != nil { |
|
if err == sql.ErrNoRows { |
|
err = nil |
|
res = nil |
|
return |
|
} |
|
log.Error("Info:row.Scan() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
//AddFactor add factor. |
|
func (d *Dao) AddFactor(c context.Context, f *model.Factor) (ret int64, err error) { |
|
var res sql.Result |
|
if res, err = d.db.Exec(c, _addFactorSQL, f.NickName, f.ServiceID, f.EventID, f.GroupID, f.RiskLevel, f.FactorVal, f.CategoryID, f.CTime); err != nil { |
|
log.Error("d.db AddFactor: d.db.Exec(%v) error(%v)", f, err) |
|
return |
|
} |
|
ret, err = res.RowsAffected() |
|
return |
|
} |
|
|
|
//AddEvent add event. |
|
func (d *Dao) AddEvent(c context.Context, f *model.Event) (ret int64, err error) { |
|
var res sql.Result |
|
if res, err = d.db.Exec(c, _addEventSQL, f.Name, f.NickName, f.ServiceID, f.Status, f.CTime, f.MTime); err != nil { |
|
log.Error("d.db AddEvent: d.db.Exec(%v) error(%v)", f, err) |
|
return |
|
} |
|
ret, err = res.RowsAffected() |
|
return |
|
} |
|
|
|
//AddService add service. |
|
func (d *Dao) AddService(c context.Context, f *model.Service) (ret int64, err error) { |
|
var res sql.Result |
|
if res, err = d.db.Exec(c, _addServiceSQL, f.Name, f.NickName, f.Status, f.CTime, f.MTime); err != nil { |
|
log.Error("d.db AddService: d.db.Exec(%v) error(%v)", f, err) |
|
return |
|
} |
|
ret, err = res.RowsAffected() |
|
return |
|
} |
|
|
|
//AddGroup add group. |
|
func (d *Dao) AddGroup(c context.Context, f *model.FactorGroup) (ret int64, err error) { |
|
var res sql.Result |
|
if res, err = d.db.Exec(c, _addGroupSQL, f.Name, f.CTime); err != nil { |
|
log.Error("d.db AddGroup: d.db.Exec(%v) error(%v)", f, err) |
|
return |
|
} |
|
ret, err = res.RowsAffected() |
|
return |
|
} |
|
|
|
// ReportList report list. |
|
func (d *Dao) ReportList(c context.Context, ps, pn int) (list []*model.ReportDto, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if ps == 0 || pn == 0 { |
|
ps = 8 |
|
pn = 1 |
|
} |
|
list = make([]*model.ReportDto, 0) |
|
if rows, err = d.db.Query(c, _getReportList, (pn-1)*ps, ps); err != nil { |
|
log.Error("d.db.Query(%s) error(%v)", _getReportList, err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
var r = &model.Report{} |
|
if err = rows.Scan(&r.ID, &r.Name, &r.DateVersion, &r.Val, &r.Ctime); err != nil { |
|
log.Error("rows.Scan() error(%v)", err) |
|
return |
|
} |
|
list = append(list, &model.ReportDto{ |
|
ID: r.ID, |
|
Name: r.Name, |
|
DateVersion: r.DateVersion, |
|
Val: r.Val, |
|
Ctime: r.Ctime.Unix(), |
|
}) |
|
} |
|
return |
|
} |
|
|
|
// ReportCount get repoet total count. |
|
func (d *Dao) ReportCount(c context.Context) (totalCount int, err error) { |
|
var row = d.db.QueryRow(c, _getReportCount) |
|
if err = row.Scan(&totalCount); err != nil { |
|
if err == sql.ErrNoRows { |
|
row = nil |
|
err = nil |
|
} else { |
|
log.Error("row.Scan error(%v)", err) |
|
} |
|
} |
|
return |
|
} |
|
|
|
// UpdateStatState update stat state. |
|
func (d *Dao) UpdateStatState(c context.Context, state int8, id int64) (affected int64, err error) { |
|
var res sql.Result |
|
if res, err = d.db.Exec(c, _updateStatStateSQL, state, id); err != nil { |
|
log.Error("d.db.Exec(%s,%d,%s) error(%v)", _updateStatStateSQL, state, id) |
|
return |
|
} |
|
if affected, err = res.RowsAffected(); err != nil { |
|
log.Error("res.RowsAffected() error(%v)", err) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// UpdateStatQuantity update stat quantity |
|
func (d *Dao) UpdateStatQuantity(c context.Context, count int64, id int64) (affected int64, err error) { |
|
var res sql.Result |
|
if res, err = d.db.Exec(c, _updateStatQuantitySQL, count, id); err != nil { |
|
log.Error("d.db.Exec(%s,%d,%s) error(%v)", _updateStatQuantitySQL, count, id) |
|
return |
|
} |
|
if affected, err = res.RowsAffected(); err != nil { |
|
log.Error("res.RowsAffected() error(%v)", err) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// DeleteStat delete stat. |
|
func (d *Dao) DeleteStat(c context.Context, isdel int8, id int64) (affected int64, err error) { |
|
var res sql.Result |
|
if res, err = d.db.Exec(c, _updateStatDeleteSQL, isdel, id); err != nil { |
|
log.Error("d.db.Exec(%s,%d,%s) error(%v)", _updateStatDeleteSQL, isdel, id) |
|
return |
|
} |
|
if affected, err = res.RowsAffected(); err != nil { |
|
log.Error("res.RowsAffected() error(%v)", err) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// Statistics get stat info by id from db. |
|
func (d *Dao) Statistics(c context.Context, id int64) (stat *model.Statistics, err error) { |
|
var ( |
|
row *xsql.Row |
|
) |
|
stat = &model.Statistics{} |
|
row = d.db.QueryRow(c, _statByIDSQL, id) |
|
if err = row.Scan(&stat.ID, &stat.TargetMid, &stat.TargetID, &stat.EventID, &stat.State, &stat.Type, &stat.Quantity, &stat.Isdel, &stat.Ctime, &stat.Mtime); err != nil { |
|
if err == sql.ErrNoRows { |
|
err = nil |
|
stat = nil |
|
return |
|
} |
|
log.Error("row.Scan() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
//LogList log list. |
|
func (d *Dao) LogList(c context.Context, refID int64, module int8) (list []*model.Log, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
list = make([]*model.Log, 0) |
|
if rows, err = d.db.Query(c, _logListSQL, refID, module); err != nil { |
|
log.Error("d.db.Query(%s) error(%v)", _logListSQL, err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
var r = &model.Log{} |
|
if err = rows.Scan(&r.ID, &r.RefID, &r.Name, &r.Module, &r.Context, &r.Ctime); err != nil { |
|
log.Error("rows.Scan() error(%v)", err) |
|
return |
|
} |
|
list = append(list, &model.Log{ |
|
ID: r.ID, |
|
RefID: r.RefID, |
|
Name: r.Name, |
|
Module: r.Module, |
|
Context: r.Context, |
|
CtimeUnix: r.Ctime.Unix(), |
|
}) |
|
} |
|
return |
|
} |
|
|
|
//StatListByMid stat list by mid. |
|
func (d *Dao) StatListByMid(c context.Context, mid int64, pn, ps int) (list []*model.Statistics, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if ps == 0 || pn == 0 { |
|
ps = 8 |
|
pn = 1 |
|
} |
|
list = make([]*model.Statistics, 0) |
|
if rows, err = d.db.Query(c, _statListByMidSQL, mid, (pn-1)*ps, ps); err != nil { |
|
log.Error("d.db.Query(%s) error(%v)", _statListByMidSQL, err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
var stat = &model.Statistics{} |
|
if err = rows.Scan(&stat.ID, &stat.TargetMid, &stat.TargetID, &stat.EventID, &stat.State, &stat.Type, &stat.Quantity, &stat.Isdel, &stat.Ctime, &stat.Mtime); err != nil { |
|
log.Error("rows.Scan() error(%v)", err) |
|
return |
|
} |
|
list = append(list, &model.Statistics{ |
|
ID: stat.ID, |
|
TargetMid: stat.TargetMid, |
|
TargetID: stat.TargetID, |
|
EventID: stat.EventID, |
|
Type: stat.Type, |
|
State: stat.State, |
|
Quantity: stat.Quantity, |
|
Isdel: stat.Isdel, |
|
Ctime: stat.Ctime, |
|
Mtime: stat.Mtime, |
|
CtimeUnix: stat.Ctime.Unix(), |
|
MtimeUnix: stat.Mtime.Unix(), |
|
}) |
|
} |
|
return |
|
} |
|
|
|
//StatListByID stat list by id. |
|
func (d *Dao) StatListByID(c context.Context, id int64, t int8, pn, ps int) (list []*model.Statistics, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if ps == 0 || pn == 0 { |
|
ps = 8 |
|
pn = 1 |
|
} |
|
list = make([]*model.Statistics, 0) |
|
if rows, err = d.db.Query(c, _statListByIDSQL, id, t, (pn-1)*ps, ps); err != nil { |
|
log.Error("d.db.Query(%s) error(%v)", _statListByIDSQL, err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
var stat = &model.Statistics{} |
|
if err = rows.Scan(&stat.ID, &stat.TargetMid, &stat.TargetID, &stat.EventID, &stat.State, &stat.Type, &stat.Quantity, &stat.Isdel, &stat.Ctime, &stat.Mtime); err != nil { |
|
log.Error("rows.Scan() error(%v)", err) |
|
return |
|
} |
|
list = append(list, &model.Statistics{ |
|
ID: stat.ID, |
|
TargetMid: stat.TargetMid, |
|
TargetID: stat.TargetID, |
|
EventID: stat.EventID, |
|
Type: stat.Type, |
|
State: stat.State, |
|
Quantity: stat.Quantity, |
|
Isdel: stat.Isdel, |
|
Ctime: stat.Ctime, |
|
Mtime: stat.Mtime, |
|
CtimeUnix: stat.Ctime.Unix(), |
|
MtimeUnix: stat.Mtime.Unix(), |
|
}) |
|
} |
|
return |
|
} |
|
|
|
// StatCountByMid count by mid. |
|
func (d *Dao) StatCountByMid(c context.Context, mid int64) (totalCount int64, err error) { |
|
row := d.db.QueryRow(c, _statCountByMidSQL, mid) |
|
if err = row.Scan(&totalCount); err != nil { |
|
if err == sql.ErrNoRows { |
|
row = nil |
|
err = nil |
|
} else { |
|
log.Error("row.Scan error(%v)", err) |
|
} |
|
} |
|
return |
|
} |
|
|
|
// StatCountByID count by id. |
|
func (d *Dao) StatCountByID(c context.Context, id int64, t int8) (totalCount int64, err error) { |
|
row := d.db.QueryRow(c, _statCountByIDSQL, id, t) |
|
if err = row.Scan(&totalCount); err != nil { |
|
if err == sql.ErrNoRows { |
|
row = nil |
|
err = nil |
|
} else { |
|
log.Error("row.Scan error(%v)", err) |
|
} |
|
} |
|
return |
|
} |
|
|
|
//AllEvent all event. |
|
func (d *Dao) AllEvent(c context.Context) (list []*model.Event, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
list = make([]*model.Event, 0) |
|
if rows, err = d.db.Query(c, _allEventSQL); err != nil { |
|
log.Error("d.db.Query(%s) error(%v)", _allEventSQL, err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
var event = &model.Event{} |
|
if err = rows.Scan(&event.ID, &event.Name, &event.NickName, &event.ServiceID, &event.Status, &event.CTime, &event.MTime); err != nil { |
|
log.Error("rows.Scan() error(%v)", err) |
|
return |
|
} |
|
list = append(list, &model.Event{ |
|
ID: event.ID, |
|
Name: event.Name, |
|
NickName: event.NickName, |
|
ServiceID: event.ServiceID, |
|
Status: event.Status, |
|
CTime: event.CTime, |
|
MTime: event.MTime, |
|
}) |
|
} |
|
return |
|
} |
|
|
|
// UpdateEventName update event name. |
|
func (d *Dao) UpdateEventName(c context.Context, e *model.Event) (affected int64, err error) { |
|
var res sql.Result |
|
if res, err = d.db.Exec(c, _updateEventNameSQL, e.NickName, e.ID); err != nil { |
|
log.Error("_updateEventNameSQL: db.Exec(%v, %d) error(%v)", e.NickName, e.ID, err) |
|
return |
|
} |
|
return res.RowsAffected() |
|
}
|
|
|