Introduce GORM.

services/aggregation.go

@@ -1,16 +1,16 @@
 package services
 
 import (
-	"database/sql"
 	"fmt"
 	"log"
 	"time"
 
+	"github.com/jinzhu/gorm"
 	"github.com/n1try/wakapi/models"
 )
 
 type AggregationService struct {
-	Db               *sql.DB
+	Db               *gorm.DB
 	HeartbeatService *HeartbeatService
 }
 
@@ -19,7 +19,7 @@ func (srv *AggregationService) Aggregate(from time.Time, to time.Time, user *mod
 	if err != nil {
 		log.Fatal(err)
 	}
-	for _, h := range heartbeats {
+	for _, h := range *heartbeats {
 		fmt.Printf("%+v\n", h)
 	}
 }

services/heartbeat.go

@@ -1,78 +1,38 @@
 package services
 
 import (
-	"database/sql"
-	"errors"
-	"fmt"
 	"time"
 
+	"github.com/jinzhu/gorm"
 	"github.com/n1try/wakapi/models"
+	gormbulk "github.com/t-tiger/gorm-bulk-insert"
 )
 
 const TableHeartbeat = "heartbeat"
 
 type HeartbeatService struct {
-	Db *sql.DB
+	Db *gorm.DB
 }
 
-func (srv *HeartbeatService) InsertBatch(heartbeats []*models.Heartbeat, user *models.User) error {
-	qTpl := "INSERT INTO %+s (user, time, entity, type, category, is_write, project, branch, language, operating_system, editor) VALUES %+s;"
-	qFill := ""
-	vals := []interface{}{}
-
-	for _, h := range heartbeats {
-		qFill = qFill + "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?),"
-		vals = append(vals, user.UserId, h.Time.String(), h.Entity, h.Type, h.Category, h.IsWrite, h.Project, h.Branch, h.Language, h.OperatingSystem, h.Editor)
+func (srv *HeartbeatService) InsertBatch(heartbeats *[]models.Heartbeat) error {
+	var batch []interface{}
+	for _, h := range *heartbeats {
+		batch = append(batch, h)
 	}
 
-	q := fmt.Sprintf(qTpl, TableHeartbeat, qFill[0:len(qFill)-1])
-	stmt, _ := srv.Db.Prepare(q)
-	result, err := stmt.Exec(vals...)
-	if err != nil {
+	if err := gormbulk.BulkInsert(srv.Db, batch, 3000); err != nil {
 		return err
 	}
-	n, err := result.RowsAffected()
-	if err != nil || n != int64(len(heartbeats)) {
-		return errors.New(fmt.Sprintf("Failed to insert %+v rows.", len(heartbeats)))
-	}
 	return nil
 }
 
-func (srv *HeartbeatService) GetAllFrom(date time.Time, user *models.User) ([]models.Heartbeat, error) {
-	q := fmt.Sprintf("SELECT user, time, language, project, operating_system, editor FROM %+s WHERE time >= ? AND user = ?", TableHeartbeat)
-	rows, err := srv.Db.Query(q, date.String(), user.UserId)
-	defer rows.Close()
-	if err != nil {
-		return make([]models.Heartbeat, 0), err
-	}
-
+func (srv *HeartbeatService) GetAllFrom(date time.Time, user *models.User) (*[]models.Heartbeat, error) {
 	var heartbeats []models.Heartbeat
-	for rows.Next() {
-		var h models.Heartbeat
-		var language sql.NullString
-		var project sql.NullString
-		var operatingSystem sql.NullString
-		var editor sql.NullString
-
-		err := rows.Scan(&h.User, &h.Time, &language, &project, &operatingSystem, &editor)
-
-		if language.Valid {
-			h.Language = language.String
-		}
-		if project.Valid {
-			h.Project = project.String
-		}
-		if operatingSystem.Valid {
-			h.OperatingSystem = operatingSystem.String
-		}
-		if editor.Valid {
-			h.Editor = editor.String
-		}
-
-		if err != nil {
-			return make([]models.Heartbeat, 0), err
-		}
-		heartbeats = append(heartbeats, h)
+	if err := srv.Db.
+		Where(&models.Heartbeat{UserID: user.ID}).
+		Where("time > ?", date).
+		Find(&heartbeats).Error; err != nil {
+		return nil, err
 	}
-	return heartbeats, nil
+	return &heartbeats, nil
 }

services/user.go

@@ -1,33 +1,27 @@
 package services
 
 import (
-	"database/sql"
-	"fmt"
-
+	"github.com/jinzhu/gorm"
 	"github.com/n1try/wakapi/models"
 )
 
 const TableUser = "user"
 
 type UserService struct {
-	Db *sql.DB
+	Db *gorm.DB
 }
 
-func (srv *UserService) GetUserById(userId string) (models.User, error) {
-	q := fmt.Sprintf("SELECT user_id, api_key FROM %+s WHERE user_id = ?;", TableUser)
-	u := models.User{}
-	err := srv.Db.QueryRow(q, userId).Scan(&u.UserId, &u.ApiKey)
-	if err != nil {
+func (srv *UserService) GetUserById(userId string) (*models.User, error) {
+	u := &models.User{}
+	if err := srv.Db.Where(&models.User{ID: userId}).First(u).Error; err != nil {
 		return u, err
 	}
 	return u, nil
 }
 
-func (srv *UserService) GetUserByKey(key string) (models.User, error) {
-	q := fmt.Sprintf("SELECT user_id, api_key FROM %+s WHERE api_key = ?;", TableUser)
-	var u models.User
-	err := srv.Db.QueryRow(q, key).Scan(&u.UserId, &u.ApiKey)
-	if err != nil {
+func (srv *UserService) GetUserByKey(key string) (*models.User, error) {
+	u := &models.User{}
+	if err := srv.Db.Where(&models.User{ApiKey: key}).First(u).Error; err != nil {
 		return u, err
 	}
 	return u, nil