func GetMonitorById(c *middleware.Context) Response {
id := c.ParamsInt64(":id")
query := m.GetMonitorByIdQuery{Id: id, OrgId: c.OrgId}
query.IsGrafanaAdmin = c.IsGrafanaAdmin
err := bus.Dispatch(&query)
if err != nil {
return ApiError(404, "Monitor not found", nil)
}
return Json(200, query.Result)
}
func GetMonitorById(query *m.GetMonitorByIdQuery) error {
sess := x.Table("monitor")
rawParams := make([]interface{}, 0)
rawSql := `
SELECT
GROUP_CONCAT(DISTINCT(monitor_collector.collector_id)) as collector_ids,
GROUP_CONCAT(DISTINCT(monitor_collector_tag.tag)) as collector_tags,
GROUP_CONCAT(DISTINCT(collector_tags.collector_id)) as tag_collectors,
endpoint.slug as endpoint_slug,
monitor_type.name as monitor_type_name,
monitor.*
FROM monitor
INNER JOIN endpoint on monitor.endpoint_id = endpoint.id
LEFT JOIN monitor_type ON monitor.monitor_type_id = monitor_type.id
LEFT JOIN monitor_collector ON monitor.id = monitor_collector.monitor_id
LEFT JOIN monitor_collector_tag ON monitor.id = monitor_collector_tag.monitor_id
LEFT JOIN
(SELECT
collector.id AS collector_id,
collector_tag.tag as tag
FROM collector
LEFT JOIN collector_tag ON collector.id = collector_tag.collector_id
WHERE (collector.public=1 OR collector.org_id=?) AND (collector_tag.org_id=? OR collector_tag.id is NULL)) as collector_tags
ON collector_tags.tag = monitor_collector_tag.tag
WHERE monitor.id=?
`
rawParams = append(rawParams, query.OrgId, query.OrgId, query.Id)
if !query.IsGrafanaAdmin {
rawSql += "AND monitor.org_id=?\n"
rawParams = append(rawParams, query.OrgId)
}
rawSql += "GROUP BY monitor.id"
//store the results into an array of maps.
results := make([]*MonitorWithCollectorDTO, 0)
err := sess.Sql(rawSql, rawParams...).Find(&results)
if err != nil {
return err
}
if len(results) < 1 {
return m.ErrMonitorNotFound
}
result := results[0]
monitorCollectorIds := make([]int64, 0)
monitorCollectorsMap := make(map[int64]bool)
if result.CollectorIds != "" {
for _, l := range strings.Split(result.CollectorIds, ",") {
i, err := strconv.ParseInt(l, 10, 64)
if err != nil {
return err
}
monitorCollectorIds = append(monitorCollectorIds, i)
monitorCollectorsMap[i] = true
}
}
monitorCollectorTags := make([]string, 0)
if result.CollectorTags != "" {
monitorCollectorTags = strings.Split(result.CollectorTags, ",")
for _, l := range strings.Split(result.TagCollectors, ",") {
i, err := strconv.ParseInt(l, 10, 64)
if err != nil {
return err
}
monitorCollectorsMap[i] = true
}
}
mergedCollectors := make([]int64, len(monitorCollectorsMap))
count := 0
for k := range monitorCollectorsMap {
mergedCollectors[count] = k
count += 1
}
query.Result = &m.MonitorDTO{
Id: result.Id,
EndpointId: result.EndpointId,
OrgId: result.OrgId,
EndpointSlug: result.EndpointSlug,
MonitorTypeId: result.MonitorTypeId,
MonitorTypeName: result.MonitorTypeName,
CollectorIds: monitorCollectorIds,
CollectorTags: monitorCollectorTags,
Collectors: mergedCollectors,
State: scrutinizeState(time.Now(), result.State, result.StateCheck, result.Frequency),
StateChange: result.StateChange,
StateCheck: result.StateCheck,
Settings: result.Settings,
HealthSettings: result.HealthSettings,
Frequency: result.Frequency,
Enabled: result.Enabled,
Offset: result.Offset,
Updated: result.Updated,
}
return nil
}