monitoring setup, project dashboard, account page

storage/monitoring.go

@@ -1,44 +1,102 @@
 package storage
 
+import (
+	"github.com/Sirupsen/logrus"
+	"time"
+)
+
 type ProjectMonitoringSnapshot struct {
-	NewTaskCount      int64
-	FailedTaskCount   int64
-	ClosedTaskCount   int64
-	WorkerAccessCount int64
-	TimeStamp         int64
+	NewTaskCount              int64 `json:"new_task_count"`
+	FailedTaskCount           int64 `json:"failed_task_count"`
+	ClosedTaskCount           int64 `json:"closed_task_count"`
+	WorkerAccessCount         int64 `json:"worker_access_count"`
+	AwaitingVerificationCount int64 `json:"awaiting_verification_count"`
+	TimeStamp                 int64 `json:"time_stamp"`
 }
 
 func (database *Database) MakeProjectSnapshots() {
 
+	startTime := time.Now()
 	db := database.getDB()
 
 	_, err := db.Exec(`
 		INSERT INTO project_monitoring_snapshot
-		  (project, new_task_count, failed_task_count, closed_task_count, worker_access_count, timestamp)
+		  (project, new_task_count, failed_task_count, closed_task_count, worker_access_count,
+		   awaiting_verification_task_count, timestamp)
 		SELECT id,
-			   (SELECT COUNT(*) FROM task WHERE task.project = project.id AND status = 1),
+			   (SELECT COUNT(*) FROM task 
+					LEFT JOIN worker_verifies_task wvt on task.id = wvt.task
+			   		WHERE task.project = project.id AND status = 1 AND wvt.task IS NULL),
 			   (SELECT COUNT(*) FROM task WHERE task.project = project.id AND status = 2),
 			   closed_task_count,
 			   (SELECT COUNT(*) FROM worker_has_access_to_project wa WHERE wa.project = project.id),
+			   (SELECT COUNT(*) FROM worker_verifies_task INNER JOIN task t on worker_verifies_task.task = t.id
+			  		WHERE t.project = project.id),
 			   extract(epoch from now() at time zone 'utc')
 		FROM project`)
 	handleErr(err)
+
+	logrus.WithFields(logrus.Fields{
+		"took": time.Now().Sub(startTime),
+	}).Trace("Took monitoring snapshot")
 }
 
-func (database *Database) GetMonitoringSnapshots(pid int64, from int64, to int64) (ss *[]ProjectMonitoringSnapshot) {
+func (database *Database) GetMonitoringSnapshotsBetween(pid int64, from int, to int) (ss *[]ProjectMonitoringSnapshot) {
 
 	db := database.getDB()
 
+	snapshots := make([]ProjectMonitoringSnapshot, 0)
+
 	rows, err := db.Query(`SELECT new_task_count, failed_task_count, closed_task_count,
-		worker_access_count, timestamp FROM project_monitoring_snapshot 
-		WHERE project=$1 AND timestamp BETWEEN $2 AND $3`, pid, from, to)
+		worker_access_count, awaiting_verification_task_count, timestamp FROM project_monitoring_snapshot 
+		WHERE project=$1 AND timestamp BETWEEN $2 AND $3 ORDER BY TIMESTAMP DESC `, pid, from, to)
 	handleErr(err)
 
 	for rows.Next() {
 
 		s := ProjectMonitoringSnapshot{}
-		err := rows.Scan(&s.NewTaskCount, &s.FailedTaskCount, &s.ClosedTaskCount, &s.WorkerAccessCount, &s.TimeStamp)
+		err := rows.Scan(&s.NewTaskCount, &s.FailedTaskCount, &s.ClosedTaskCount, &s.WorkerAccessCount,
+			&s.AwaitingVerificationCount, &s.TimeStamp)
 		handleErr(err)
+
+		snapshots = append(snapshots, s)
 	}
-	return nil
+
+	logrus.WithFields(logrus.Fields{
+		"snapshotCount": len(snapshots),
+		"projectId":     pid,
+		"from":          from,
+		"to":            to,
+	}).Trace("Database.GetMonitoringSnapshotsBetween SELECT")
+
+	return &snapshots
+}
+
+func (database *Database) GetNMonitoringSnapshots(pid int64, count int) (ss *[]ProjectMonitoringSnapshot) {
+
+	db := database.getDB()
+
+	snapshots := make([]ProjectMonitoringSnapshot, 0)
+
+	rows, err := db.Query(`SELECT new_task_count, failed_task_count, closed_task_count,
+		worker_access_count, awaiting_verification_task_count, timestamp FROM project_monitoring_snapshot 
+		WHERE project=$1 ORDER BY TIMESTAMP DESC LIMIT $2`, pid, count)
+	handleErr(err)
+
+	for rows.Next() {
+		s := ProjectMonitoringSnapshot{}
+		err := rows.Scan(&s.NewTaskCount, &s.FailedTaskCount, &s.ClosedTaskCount, &s.WorkerAccessCount,
+			&s.AwaitingVerificationCount, &s.TimeStamp)
+		handleErr(err)
+
+		snapshots = append(snapshots, s)
+	}
+
+	logrus.WithFields(logrus.Fields{
+		"snapshotCount": len(snapshots),
+		"projectId":     pid,
+		"count":         count,
+	}).Trace("Database.GetNMonitoringSnapshots SELECT")
+
+	return &snapshots
 }

storage/project.go

@@ -156,3 +156,31 @@ func (database Database) GetAllProjects() *[]Project {
 
 	return &projects
 }
+
+func (database *Database) GetAssigneeStats(pid int64, count int64) *[]AssignedTasks {
+
+	db := database.getDB()
+	assignees := make([]AssignedTasks, 0)
+
+	rows, err := db.Query(`SELECT worker.alias, COUNT(*) as wc FROM TASK
+  			LEFT JOIN worker ON TASK.assignee = worker.id WHERE project=$1 
+			GROUP BY worker.id ORDER BY wc LIMIT $2`, pid, count)
+	handleErr(err)
+
+	for rows.Next() {
+		assignee := AssignedTasks{}
+		var assigneeAlias sql.NullString
+		err = rows.Scan(&assigneeAlias, &assignee.TaskCount)
+		handleErr(err)
+
+		if assigneeAlias.Valid {
+			assignee.Assignee = assigneeAlias.String
+		} else {
+			assignee.Assignee = "unassigned"
+		}
+
+		assignees = append(assignees, assignee)
+	}
+
+	return &assignees
+}

storage/task.go

@@ -47,7 +47,7 @@ func (database *Database) SaveTask(task *Task, project int64, hash64 int64) erro
 	if err != nil {
 		logrus.WithError(err).WithFields(logrus.Fields{
 			"task": task,
-		}).Warn("Database.saveTask INSERT task ERROR")
+		}).Trace("Database.saveTask INSERT task ERROR")
 		return err
 	}