585 lines
18 KiB
Go
585 lines
18 KiB
Go
|
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()
|
||
|
|
}
|