aps/apsMicro.git

package controllers
 
import (
    "basic.com/valib/bhomeclient.git"
    "encoding/json"
    "strings"
    "time"
    "vamicro/log-service/models"
)
 
type LogServiceController struct {
    bk bhomeclient.Broker
}
 
func (ac LogServiceController) FindAllMap(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
    var module models.Modules
    allmap := module.FindAllMap()
 
    return &bhomeclient.Reply{Success: true, Data: allmap}
}
 
func (ac LogServiceController) SetModules(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
    var params []models.Modules
    if err := c.BindJSON(&params); err != nil {
        return &bhomeclient.Reply{Success: false, Msg: "参数格式错误,非法的json格式"}
    }
    for _, item := range params {
        item.Insert()
    }
    return &bhomeclient.Reply{Success: true, Data: params}
}
 
func (ac LogServiceController) SetOperations(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
    var params []models.Operations
    if err := c.BindJSON(&params); err != nil {
        return &bhomeclient.Reply{Success: false, Msg: "参数格式错误,非法的json格式"}
    }
    for _, item := range params {
        item.Insert()
    }
    return &bhomeclient.Reply{Success: true, Data: params}
}
 
func (ac LogServiceController) Modules(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
    var moduleMod models.Modules
    modules, err := moduleMod.FindAll()
    if nil == err {
        return &bhomeclient.Reply{Success: true, Data: modules}
    } else {
        return &bhomeclient.Reply{Success: true, Data: make([]interface{}, 0)}
    }
}
 
func (ac LogServiceController) Operations(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
    var opModel models.Operations
    module := c.Query("module")
    opers, err := opModel.FindAll(module)
    if nil == err {
        return &bhomeclient.Reply{Success: true, Data: opers}
    } else {
        return &bhomeclient.Reply{Success: false, Msg: err.Error()}
    }
}
 
func (ac LogServiceController) OperationLog(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
    var params models.OperationQuery
    if err := c.BindJSON(&params); err != nil {
        return &bhomeclient.Reply{Success: false, Msg: "参数格式错误,非法的json格式"}
    }
 
    var tsStart, tsEnd time.Time
    if params.TimeStart == "" && params.TimeEnd == "" {
        tsEnd = time.Now()
        tsStart = tsEnd.Add(-time.Hour * 24)
    } else if params.TimeStart == "" && params.TimeEnd != "" {
        ts, ok := checkTime(params.TimeEnd)
        if !ok {
            return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
        }
        tsEnd = ts
        tsStart = tsEnd.Add(-time.Hour * 24 * 365)
    } else if params.TimeStart != "" && params.TimeEnd == "" {
        ts, ok := checkTime(params.TimeStart)
        if !ok {
            return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
        }
 
        tsStart = ts
        tsEnd = time.Now()
    } else {
        var ok bool
        tsStart, ok = checkTime(params.TimeStart)
        if !ok {
            return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
        }
 
        tsEnd, ok = checkTime(params.TimeEnd)
        if !ok {
            return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
        }
 
        if tsStart.After(tsEnd) {
            return &bhomeclient.Reply{Success: false, Msg: "参数有误, 开始时间大于结束时间"}
        }
    }
 
    db := models.GetDB()
    db = db.Where("timestamp >= ? AND timestamp <= ?", tsStart.Unix(), tsEnd.Unix())
    if params.Module != "" {
        db = db.Where("module = ?", params.Module)
    }
 
    if params.Function != "" {
        db = db.Where("function = ?", params.Function)
    }
 
    if params.Result != "" {
        db = db.Where("result = ?", params.Result)
    }
 
    if params.FuzzySearch != "" {
        db = db.Where("para like ? or userName like ? or function like ?",
            "%"+params.FuzzySearch+"%",
            "%"+params.FuzzySearch+"%",
            "%"+params.FuzzySearch+"%")
    }
 
    if params.Page <= 0 {
        params.Page = 1
    }
    var count int64 = 0
    err := db.Table("t_op_log").Count(&count).Error
    if nil != err {
        return &bhomeclient.Reply{Success: false, Msg: "内部错误" + err.Error()}
    }
    var logs []*models.OperationLog
    if result := db.Table("t_op_log").Limit(params.PageSize).Offset((params.Page - 1) * params.PageSize).Order("timestamp DESC").Find(&logs); nil != result.Error {
        return &bhomeclient.Reply{Success: false, Msg: "内部错误" + result.Error.Error()}
    }
 
    return &bhomeclient.Reply{Success: true, Data: map[string]interface{}{"logs": logs, "total": count}}
}
 
func (ac LogServiceController) ScheduleLog(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
    var params models.ScheduleQuery
    if err := c.BindJSON(&params); err != nil {
        return &bhomeclient.Reply{Success: false, Msg: "参数格式错误,非法的json格式"}
    }
 
    var tsStart, tsEnd time.Time
    if params.TimeStart == "" && params.TimeEnd == "" {
        tsEnd = time.Now()
        tsStart = tsEnd.Add(-time.Hour * 24)
    } else if params.TimeStart == "" && params.TimeEnd != "" {
        ts, ok := checkTime(params.TimeEnd)
        if !ok {
            return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
        }
        tsEnd = ts
        tsStart = tsEnd.Add(-time.Hour * 24)
    } else if params.TimeStart != "" && params.TimeEnd == "" {
        ts, ok := checkTime(params.TimeStart)
        if !ok {
            return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
        }
 
        tsStart = ts
        tsEnd = tsStart.Add(time.Hour * 24)
    } else {
        var ok bool
        tsStart, ok = checkTime(params.TimeStart)
        if !ok {
            return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
        }
 
        tsEnd, ok = checkTime(params.TimeEnd)
        if !ok {
            return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
        }
 
        if tsStart.After(tsEnd) {
            return &bhomeclient.Reply{Success: false, Msg: "参数有误, 开始时间大于结束时间"}
        }
    }
 
    db := models.GetDB()
    db = db.Where("timestamp >= ? AND timestamp <= ?", tsStart.Unix(), tsEnd.Unix())
    if params.ProcID != "" {
        procIds := strings.Split(params.ProcID, ",")
        db = db.Where("procID in (?)", procIds)
    }
 
    if params.ProcName != "" {
        db = db.Where("procName like ?", params.ProcName)
    }
 
    if params.FuzzySearch != "" {
        db = db.Where("info like ?", "%"+params.FuzzySearch+"%")
    }
 
    if params.Page <= 0 {
        params.Page = 1
    }
    var count int64 = 0
    err := db.Table("t_schedule_log").Count(&count).Error
    if nil != err {
        return &bhomeclient.Reply{Success: false, Msg: "内部错误" + err.Error()}
    }
    var logs []*models.ScheduleLog
    if result := db.Table("t_schedule_log").Limit(params.PageSize).Offset((params.Page - 1) * params.PageSize).Find(&logs); nil != result.Error {
        return &bhomeclient.Reply{Success: false, Msg: "内部错误" + result.Error.Error()}
    }
 
    data := make([]map[string]interface{}, 0)
 
    if len(logs) > 0 {
        for _, item := range logs {
            dd := make(map[string]interface{}, 0)
            l, _ := json.Marshal(item)
            json.Unmarshal(l, &dd)
            dd["addTime"] = time.Unix(item.Timestamp, 0).Format("2006-01-02 15:04:05")
            dd["minute"] = 0
            t, err := time.ParseInLocation("2006-01-02 15:04:05", item.ScheduleStartTime, time.Local)
            if nil == err {
                t2, err := time.ParseInLocation("2006-01-02 15:04:05", item.ScheduleEndTime, time.Local)
                if err == nil {
                    dd["minute"] = (t2.Unix() - t.Unix()) / 60
                }
            }
 
            data = append(data, dd)
        }
    }
    return &bhomeclient.Reply{Success: true, Data: map[string]interface{}{"logs": data, "total": count}}
}
 
func (ac LogServiceController) RuleServerLog(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
    var params models.RuleServerLogQuery
    if err := c.BindJSON(&params); err != nil {
        return &bhomeclient.Reply{Success: false, Msg: "参数格式错误,非法的json格式"}
    }
 
    db := models.GetDB()
    if params.TimeStart != "" {
        db = db.Where("lastSendDate >= ?", params.TimeStart)
    }
    if params.TimeEnd != "" {
        db = db.Where("lastSendDate <= ?", params.TimeEnd)
    }
    if params.TaskName != "" {
        db = db.Where("name like ?", params.TaskName)
    }
 
    if params.State != "" {
        db = db.Where("state like ?", params.State)
    }
 
    if params.FuzzySearch != "" {
        db = db.Where("name like ? ", "%"+params.FuzzySearch+"%")
    }
 
    if params.Page <= 0 {
        params.Page = 1
    }
    var count int64 = 0
    err := db.Table("t_rule_server_log").Count(&count).Error
    if nil != err {
        return &bhomeclient.Reply{Success: false, Msg: "内部错误" + err.Error()}
    }
    var logs []*models.RuleServerLog
    if result := db.Table("t_rule_server_log").Limit(params.PageSize).Offset((params.Page - 1) * params.PageSize).Find(&logs); nil != result.Error {
        return &bhomeclient.Reply{Success: false, Msg: "内部错误" + result.Error.Error()}
    }
 
    return &bhomeclient.Reply{Success: true, Data: map[string]interface{}{"logs": logs, "total": count}}
}
 
func (ac LogServiceController) VaSystemLog(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
    var params models.VaSystemQuery
    if err := c.BindJSON(&params); err != nil {
        return &bhomeclient.Reply{Success: false, Msg: "参数格式错误,非法的json格式"}
    }
 
    var tsStart, tsEnd time.Time
    if params.TimeStart == "" && params.TimeEnd == "" {
        tsEnd = time.Now()
        tsStart = tsEnd.Add(-time.Hour * 24)
    } else if params.TimeStart == "" && params.TimeEnd != "" {
        ts, ok := checkTime(params.TimeEnd)
        if !ok {
            return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
        }
        tsEnd = ts
        tsStart = tsEnd.Add(-time.Hour * 24)
    } else if params.TimeStart != "" && params.TimeEnd == "" {
        ts, ok := checkTime(params.TimeStart)
        if !ok {
            return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
        }
 
        tsStart = ts
        tsEnd = tsStart.Add(time.Hour * 24)
    } else {
        var ok bool
        tsStart, ok = checkTime(params.TimeStart)
        if !ok {
            return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
        }
 
        tsEnd, ok = checkTime(params.TimeEnd)
        if !ok {
            return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
        }
 
        if tsStart.After(tsEnd) {
            return &bhomeclient.Reply{Success: false, Msg: "参数有误, 开始时间大于结束时间"}
        }
    }
 
    db := models.GetDB()
    db = db.Where("timestamp >= ? AND timestamp <= ?", tsStart.Unix(), tsEnd.Unix())
    if len(params.ProcName) > 0 {
        db = db.Where("procName in (?)", params.ProcName)
    }
 
    if params.Level != 0 {
        db = db.Where("level = (?)", params.Level)
    }
 
    if params.FuzzySearch != "" {
        db = db.Where("address like ? or info like ? or procName like ?",
            "%"+params.FuzzySearch+"%",
            "%"+params.FuzzySearch+"%",
            "%"+params.FuzzySearch+"%")
    }
 
    if params.Page <= 0 {
        params.Page = 1
    }
 
    var count int64 = 0
    tableName := models.VaSystemLog{}.TableName()
 
    err := db.Table(tableName).Count(&count).Error
    if nil != err {
        return &bhomeclient.Reply{Success: false, Msg: "内部错误" + err.Error()}
    }
 
    var logs []*models.VaSystemLog
    if result := db.Table(tableName).Limit(params.PageSize).Offset((params.Page - 1) * params.PageSize).Order("timestamp DESC").Find(&logs); nil != result.Error {
        return &bhomeclient.Reply{Success: false, Msg: "内部错误" + result.Error.Error()}
    }
 
    return &bhomeclient.Reply{Success: true, Data: map[string]interface{}{"logs": logs, "total": count}}
}
 
func (ac LogServiceController) GetProcNames(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
    logs := []models.VaSystemLog{}
    procs := []string{}
 
    tableName := models.VaSystemLog{}.TableName()
    models.GetDB().Table(tableName).Group("procName").Select("procName").Find(&logs).Pluck("procName", &procs)
 
    return &bhomeclient.Reply{Success: true, Data: procs}
}
 
func checkTime(dateTime string) (time.Time, bool) {
    ts, err := time.ParseInLocation("2006-01-02 15:04:05", dateTime, time.Local)
    if err != nil {
        return ts, false
    }
 
    return ts, true
}