Handle updates via git webhooks

storage/project.go

@@ -3,13 +3,15 @@ package storage
 import (
 	"database/sql"
 	"github.com/Sirupsen/logrus"
+	"strings"
 )
 
 type Project struct {
 	Id       int64  `json:"id"`
 	Priority int64  `json:"priority"`
 	Name     string `json:"name"`
-	GitUrl   string `json:"git_url"`
+	CloneUrl string `json:"clone_url"`
+	GitRepo  string `json:"git_repo"`
 	Version  string `json:"version"`
 }
 
@@ -24,8 +26,9 @@ func (database *Database) SaveProject(project *Project) (int64, error) {
 
 func saveProject(project *Project, db *sql.DB) (int64, error) {
 
-	row := db.QueryRow("INSERT INTO project (name, git_url, version, priority) VALUES ($1,$2,$3, $4) RETURNING id",
-		project.Name, project.GitUrl, project.Version, project.Priority)
+	row := db.QueryRow(`INSERT INTO project (name, git_repo, clone_url, version, priority)
+		VALUES ($1,$2,$3,$4,$5) RETURNING id`,
+		project.Name, project.GitRepo, project.CloneUrl, project.Version, project.Priority)
 
 	var id int64
 	err := row.Scan(&id)
@@ -56,14 +59,11 @@ func (database *Database) GetProject(id int64) *Project {
 
 func getProject(id int64, db *sql.DB) *Project {
 
-	project := &Project{}
+	row := db.QueryRow(`SELECT * FROM project WHERE id=$1`, id)
 
-	row := db.QueryRow("SELECT id, name, git_url, version, priority FROM project WHERE id=$1",
-		id)
-
-	err := row.Scan(&project.Id, &project.Name, &project.GitUrl, &project.Version, &project.Priority)
+	project, err := scanProject(row)
 	if err != nil {
-		logrus.WithFields(logrus.Fields{
+		logrus.WithError(err).WithFields(logrus.Fields{
 			"id": id,
 		}).Warn("Database.getProject SELECT project NOT FOUND")
 		return nil
@@ -76,3 +76,61 @@ func getProject(id int64, db *sql.DB) *Project {
 
 	return project
 }
+
+func scanProject(row *sql.Row) (*Project, error) {
+
+	project := &Project{}
+	err := row.Scan(&project.Id, &project.Priority, &project.Name, &project.CloneUrl, &project.GitRepo,
+		&project.Version)
+
+	return project, err
+}
+
+func (database *Database) GetProjectWithRepoName(repoName string) *Project {
+
+	db := database.getDB()
+	project := getProjectWithRepoName(repoName, db)
+	err := db.Close()
+	handleErr(err)
+	return project
+}
+
+func getProjectWithRepoName(repoName string, db *sql.DB) *Project {
+
+	row := db.QueryRow(`SELECT * FROm project WHERE LOWER(git_repo)=$1`, strings.ToLower(repoName))
+
+	project, err := scanProject(row)
+	if err != nil {
+		logrus.WithError(err).WithFields(logrus.Fields{
+			"repoName": repoName,
+		}).Error("Database.getProjectWithRepoName SELECT project NOT FOUND")
+		return nil
+	}
+
+	return project
+}
+
+func (database *Database) UpdateProject(project *Project) {
+
+	db := database.getDB()
+	updateProject(project, db)
+	err := db.Close()
+	handleErr(err)
+}
+
+func updateProject(project *Project, db *sql.DB) {
+
+	res, err := db.Exec(`UPDATE project 
+		SET (priority, name, clone_url, git_repo, version) = ($1,$2,$3,$4,$5) WHERE id=$6`,
+		project.Priority, project.Name, project.CloneUrl, project.GitRepo, project.Version, project.Id)
+	handleErr(err)
+
+	rowsAffected, _ := res.RowsAffected()
+
+	logrus.WithFields(logrus.Fields{
+		"project":      project,
+		"rowsAffected": rowsAffected,
+	}).Trace("Database.updateProject UPDATE project")
+
+	return
+}

storage/task.go

@@ -165,7 +165,7 @@ func scanTask(row *sql.Row) *Task {
 
 	err := row.Scan(&task.Id, &task.Priority, &project.Id, &task.Assignee,
 		&task.Retries, &task.MaxRetries, &task.Status, &task.Recipe, &project.Id,
-		&project.Priority, &project.Name, &project.GitUrl, &project.Version)
+		&project.Priority, &project.Name, &project.CloneUrl, &project.GitRepo, &project.Version)
 	handleErr(err)
 
 	return task

storage/worker.go

@@ -8,12 +8,13 @@ import (
 )
 
 type Identity struct {
-	RemoteAddr string
+	RemoteAddr string `json:"remote_addr"`
+	UserAgent  string `json:"user_agent"`
 }
 
 type Worker struct {
-	Id uuid.UUID `json:"id"`
-	Created int64 `json:"created"`
+	Id       uuid.UUID `json:"id"`
+	Created  int64     `json:"created"`
 	Identity *Identity `json:"identity"`
 }
 
@@ -76,8 +77,8 @@ func getIdentity(id int64, db *sql.DB) (*Identity, error) {
 
 	identity := &Identity{}
 
-	row := db.QueryRow("SELECT (remote_addr) FROM workeridentity WHERE id=$1", id)
-	err := row.Scan(&identity.RemoteAddr)
+	row := db.QueryRow("SELECT remote_addr, user_agent FROM workeridentity WHERE id=$1", id)
+	err := row.Scan(&identity.RemoteAddr, &identity.UserAgent)
 
 	if err != nil {
 		return nil, errors.New("identity not found")
@@ -92,8 +93,8 @@ func getIdentity(id int64, db *sql.DB) (*Identity, error) {
 
 func getOrCreateIdentity(identity *Identity, db *sql.DB) int64 {
 
-	res, err := db.Exec("INSERT INTO workeridentity (remote_addr) VALUES ($1) ON CONFLICT DO NOTHING",
-		identity.RemoteAddr)
+	res, err := db.Exec("INSERT INTO workeridentity (remote_addr, user_agent) VALUES ($1,$2) ON CONFLICT DO NOTHING",
+		identity.RemoteAddr, identity.UserAgent)
 	handleErr(err)
 
 	rowsAffected, err := res.RowsAffected()
@@ -113,4 +114,3 @@ func getOrCreateIdentity(identity *Identity, db *sql.DB) int64 {
 
 	return rowId
 }
-