Pierre-Olivier Mercier
0cc0ae3c7d
All checks were successful
continuous-integration/drone/push Build is passing
677 lines
19 KiB
Go
677 lines
19 KiB
Go
package main
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"encoding/base64"
|
|
"flag"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"net/url"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/aws/aws-sdk-go/aws"
|
|
"github.com/aws/aws-sdk-go/service/s3"
|
|
"github.com/drone/drone-go/drone"
|
|
"github.com/gin-gonic/gin"
|
|
"golang.org/x/oauth2"
|
|
)
|
|
|
|
var (
|
|
droneToken = ""
|
|
droneConfig *http.Client
|
|
droneEndpoint string
|
|
)
|
|
|
|
func init() {
|
|
flag.StringVar(&droneToken, "drone-token", droneToken, "Token for Drone Oauth")
|
|
flag.StringVar(&droneEndpoint, "drone-endpoint", droneEndpoint, "Drone Endpoint")
|
|
}
|
|
|
|
func initializeDroneOauth() {
|
|
if droneToken != "" {
|
|
config := new(oauth2.Config)
|
|
droneConfig = config.Client(
|
|
oauth2.NoContext,
|
|
&oauth2.Token{
|
|
AccessToken: droneToken,
|
|
},
|
|
)
|
|
}
|
|
}
|
|
|
|
type RepositoryAdminPull struct {
|
|
Tag *string `json:"tag"`
|
|
OptionalSignature bool `json:"sig_optional"`
|
|
}
|
|
|
|
func declareAPIAuthRepositoriesRoutes(router *gin.RouterGroup) {
|
|
router.GET("/repositories", func(c *gin.Context) {
|
|
var u *User
|
|
if user, ok := c.Get("user"); ok {
|
|
u = user.(*User)
|
|
} else {
|
|
u = c.MustGet("LoggedUser").(*User)
|
|
}
|
|
|
|
repositories, err := u.GetRepositories()
|
|
if err != nil {
|
|
log.Println("Unable to GetRepositories:", err)
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "Unable to retrieve your repositories. Please try again in a few moment."})
|
|
return
|
|
}
|
|
|
|
if work, ok := c.Get("work"); ok {
|
|
var res []*Repository
|
|
|
|
for _, r := range repositories {
|
|
if r.IdWork == work.(*Work).Id {
|
|
// Is the URL used elsewhere?
|
|
repos, _ := getRepositoriesByURI(r.URI)
|
|
if len(repos) > 1 {
|
|
r.AlreadyUsed = true
|
|
}
|
|
|
|
res = append(res, r)
|
|
}
|
|
}
|
|
|
|
c.JSON(http.StatusOK, res)
|
|
} else {
|
|
c.JSON(http.StatusOK, repositories)
|
|
}
|
|
})
|
|
router.POST("/repositories", func(c *gin.Context) {
|
|
var u *User
|
|
if user, ok := c.Get("user"); ok {
|
|
u = user.(*User)
|
|
} else {
|
|
u = c.MustGet("LoggedUser").(*User)
|
|
}
|
|
|
|
var repository Repository
|
|
if err := c.ShouldBindJSON(&repository); err != nil {
|
|
c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"errmsg": err.Error()})
|
|
return
|
|
}
|
|
|
|
uri, err := url.Parse(repository.URI)
|
|
if err != nil {
|
|
tmp := strings.Split(repository.URI, ":")
|
|
if len(tmp) == 2 {
|
|
uri, err = url.Parse(fmt.Sprintf("ssh://%s/%s", tmp[0], tmp[1]))
|
|
} else if len(tmp) == 3 {
|
|
uri, err = url.Parse(fmt.Sprintf("%s://%s/%s", tmp[0], tmp[1], tmp[2]))
|
|
}
|
|
|
|
if err != nil {
|
|
c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"errmsg": fmt.Sprintf("invalid repository URL: %s", err.Error())})
|
|
return
|
|
}
|
|
}
|
|
|
|
if strings.Contains(uri.Host, "epita.fr") {
|
|
if !strings.HasPrefix(uri.Path, fmt.Sprintf("/%s/", u.Login)) {
|
|
c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"errmsg": "repository URL forbidden"})
|
|
return
|
|
}
|
|
}
|
|
|
|
var w *Work
|
|
if work, ok := c.Get("work"); ok {
|
|
w = work.(*Work)
|
|
} else if repository.IdWork > 0 {
|
|
var err error
|
|
w, err = getWork(int(repository.IdWork))
|
|
if err != nil {
|
|
c.AbortWithStatusJSON(http.StatusNotFound, gin.H{"errmsg": "Unable to find the given work identifier."})
|
|
return
|
|
}
|
|
} else {
|
|
c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"errmsg": "Unable to find the given work identifier."})
|
|
return
|
|
}
|
|
|
|
k, err := u.NewRepository(w, repository.URI)
|
|
if err != nil {
|
|
log.Println("Unable to NewRepository:", err)
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "Unable to register your public repository. Please try again in a few moment."})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, k)
|
|
})
|
|
|
|
repositoriesRoutes := router.Group("/repositories/:rid")
|
|
repositoriesRoutes.Use(repositoryHandler)
|
|
|
|
repositoriesRoutes.GET("", func(c *gin.Context) {
|
|
repo := c.MustGet("repository").(*Repository)
|
|
|
|
// Is the URL used elsewhere?
|
|
repos, _ := getRepositoriesByURI(repo.URI)
|
|
if len(repos) > 1 {
|
|
repo.AlreadyUsed = true
|
|
}
|
|
|
|
c.JSON(http.StatusOK, repo)
|
|
})
|
|
repositoriesRoutes.PUT("", func(c *gin.Context) {
|
|
current := c.MustGet("repository").(*Repository)
|
|
|
|
var new Repository
|
|
if err := c.ShouldBindJSON(&new); err != nil {
|
|
c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"errmsg": err.Error()})
|
|
return
|
|
}
|
|
|
|
new.Id = current.Id
|
|
|
|
u := c.MustGet("LoggedUser").(*User)
|
|
if new.IdUser != current.IdUser && !u.IsAdmin {
|
|
c.AbortWithStatusJSON(http.StatusForbidden, gin.H{"errmsg": "Operation not allowed."})
|
|
return
|
|
}
|
|
|
|
if repository, err := new.Update(); err != nil {
|
|
log.Println("Unable to Update repository:", err)
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": fmt.Sprintf("An error occurs during repository updation: %s", err.Error())})
|
|
return
|
|
} else {
|
|
c.JSON(http.StatusOK, repository)
|
|
}
|
|
})
|
|
repositoriesRoutes.DELETE("", func(c *gin.Context) {
|
|
loggeduser := c.MustGet("LoggedUser").(*User)
|
|
repository := c.MustGet("repository").(*Repository)
|
|
work, err := getWork(int(repository.IdWork))
|
|
if err != nil {
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "Unable to find related work."})
|
|
return
|
|
|
|
}
|
|
|
|
now := time.Now()
|
|
|
|
if !loggeduser.IsAdmin && (!work.Shown || work.Corrected || work.StartAvailability.After(now) || work.EndAvailability.Before(now)) {
|
|
c.AbortWithStatusJSON(http.StatusForbidden, gin.H{"errmsg": "The submission is closed."})
|
|
return
|
|
}
|
|
|
|
if _, err := repository.Delete(); err != nil {
|
|
log.Println("Unable to Delete repository:", err)
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": fmt.Sprintf("An error occurs during repository deletion: %s", err.Error())})
|
|
return
|
|
} else {
|
|
c.JSON(http.StatusOK, nil)
|
|
}
|
|
})
|
|
|
|
repositoriesRoutes.POST("/trigger", func(c *gin.Context) {
|
|
loggeduser := c.MustGet("LoggedUser").(*User)
|
|
var u *User
|
|
if user, ok := c.Get("user"); ok {
|
|
u = user.(*User)
|
|
} else {
|
|
u = loggeduser
|
|
}
|
|
repo := c.MustGet("repository").(*Repository)
|
|
work, err := getWork(int(repo.IdWork))
|
|
if err != nil {
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "Unable to find related work."})
|
|
return
|
|
}
|
|
|
|
now := time.Now()
|
|
|
|
if repo.LastCheck != nil && !repo.LastCheck.Before(now.Add(-5*time.Minute)) && !loggeduser.IsAdmin {
|
|
c.AbortWithStatusJSON(http.StatusPaymentRequired, gin.H{"errmsg": "Please wait between two pulls."})
|
|
return
|
|
}
|
|
|
|
var rap RepositoryAdminPull
|
|
if loggeduser.IsAdmin {
|
|
c.ShouldBindJSON(&rap)
|
|
}
|
|
|
|
TriggerTagUpdate(c, work, repo, u, rap.Tag, rap.OptionalSignature)
|
|
})
|
|
|
|
repositoriesRoutes.GET("/state", func(c *gin.Context) {
|
|
repo := c.MustGet("repository").(*Repository)
|
|
|
|
tmp := strings.Split(repo.DroneRef, "/")
|
|
if len(tmp) < 3 {
|
|
c.AbortWithStatusJSON(http.StatusNotFound, gin.H{"errmsg": "No build number. Please try pulling your work."})
|
|
return
|
|
}
|
|
|
|
nbuild, err := strconv.Atoi(tmp[2])
|
|
if err != nil {
|
|
c.AbortWithStatusJSON(http.StatusNotFound, gin.H{"errmsg": "Bad build number. Please retry pulling your work."})
|
|
return
|
|
}
|
|
|
|
client := drone.NewClient(droneEndpoint, droneConfig)
|
|
result, err := client.Build(tmp[0], tmp[1], nbuild)
|
|
if err != nil {
|
|
c.AbortWithStatusJSON(http.StatusNotFound, gin.H{"errmsg": "Unable to find the referenced extraction."})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, result)
|
|
})
|
|
|
|
repositoriesRoutes.GET("/state-logs", func(c *gin.Context) {
|
|
repo := c.MustGet("repository").(*Repository)
|
|
|
|
tmp := strings.Split(repo.DroneRef, "/")
|
|
if len(tmp) < 3 {
|
|
c.AbortWithStatusJSON(http.StatusNotFound, gin.H{"errmsg": "No build number. Please try pulling your work."})
|
|
return
|
|
}
|
|
|
|
nbuild, err := strconv.Atoi(tmp[2])
|
|
if err != nil {
|
|
c.AbortWithStatusJSON(http.StatusNotFound, gin.H{"errmsg": "Bad build number. Please retry pulling your work."})
|
|
return
|
|
}
|
|
|
|
client := drone.NewClient(droneEndpoint, droneConfig)
|
|
result, err := client.Logs(tmp[0], tmp[1], nbuild, 1, 3)
|
|
if err != nil {
|
|
log.Printf("An error occurs when retrieving logs from Drone (%s/%s/%d/1/3): %s", tmp[0], tmp[1], nbuild, err.Error())
|
|
c.AbortWithStatusJSON(http.StatusNotFound, gin.H{"errmsg": "Unable to retrieve logs."})
|
|
return
|
|
}
|
|
|
|
if len(result) > 7 {
|
|
c.JSON(http.StatusOK, result[7:])
|
|
} else {
|
|
c.JSON(http.StatusOK, result)
|
|
}
|
|
})
|
|
|
|
repositoriesRoutes.POST("/gradation", func(c *gin.Context) {
|
|
loggeduser := c.MustGet("LoggedUser").(*User)
|
|
if !loggeduser.IsAdmin {
|
|
c.AbortWithStatusJSON(http.StatusForbidden, gin.H{"errmsg": "Permission denied."})
|
|
return
|
|
}
|
|
|
|
var u *User
|
|
if user, ok := c.Get("user"); ok {
|
|
u = user.(*User)
|
|
} else {
|
|
u = loggeduser
|
|
}
|
|
repo := c.MustGet("repository").(*Repository)
|
|
work, err := getWork(int(repo.IdWork))
|
|
if err != nil {
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "Unable to find related work."})
|
|
return
|
|
}
|
|
|
|
TriggerTests(c, work, repo, u)
|
|
})
|
|
}
|
|
|
|
type GitLabWebhook struct {
|
|
EventName string `json:"event_name"`
|
|
ObjectKind string `json:"object_kind"`
|
|
Ref string
|
|
Repository GitLabRepository
|
|
}
|
|
|
|
func declareCallbacksRoutes(router *gin.RouterGroup) {
|
|
router.POST("/callbacks/trigger.json", func(c *gin.Context) {
|
|
// Check event type
|
|
if c.Request.Header.Get("X-Gitlab-Event") != "Tag Push Hook" {
|
|
c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"errmsg": "This trigger is limited to Tag Push event. Please edit your trigger on GitLab."})
|
|
return
|
|
}
|
|
|
|
hook := GitLabWebhook{}
|
|
if err := c.ShouldBindJSON(&hook); err != nil {
|
|
c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"errmsg": err.Error()})
|
|
return
|
|
}
|
|
|
|
// Check token
|
|
repos, err := getRepositoriesByURI(hook.Repository.URL)
|
|
if err != nil {
|
|
log.Println("Unable to getRepositoriesByURI:", err.Error())
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "Unable to retrieve repositories."})
|
|
return
|
|
}
|
|
|
|
var repo *Repository
|
|
for _, r := range repos {
|
|
if len(r.Secret) == 0 || base64.StdEncoding.EncodeToString(r.Secret) == c.Request.Header.Get("X-Gitlab-Token") {
|
|
repo = r
|
|
break
|
|
}
|
|
}
|
|
|
|
if repo == nil {
|
|
c.AbortWithStatusJSON(http.StatusNotFound, gin.H{"errmsg": "There are no repositories matching this URL and secret. Please check the Gitlab Secret and retry pushing your tag."})
|
|
return
|
|
}
|
|
|
|
work, err := getWork(int(repo.IdWork))
|
|
if err != nil {
|
|
log.Println("Unable to getWork:", err.Error())
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "Unable to find related work."})
|
|
return
|
|
|
|
}
|
|
|
|
user, err := getUser(int(repo.IdUser))
|
|
if err != nil {
|
|
log.Println("Unable to getUser:", err.Error())
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "Unable to find related user."})
|
|
return
|
|
|
|
}
|
|
|
|
tmp := strings.SplitN(hook.Ref, "/", 3)
|
|
if len(tmp) != 3 {
|
|
TriggerTagUpdate(c, work, repo, user, nil, false)
|
|
return
|
|
}
|
|
|
|
if !strings.HasPrefix(tmp[2], work.Tag) {
|
|
// Allow to use a secret for another tag
|
|
if len(repos) > 1 {
|
|
for _, r := range repos {
|
|
w, err := getWork(int(r.IdWork))
|
|
if err != nil {
|
|
log.Println("Unable to getWork:", err.Error())
|
|
continue
|
|
}
|
|
|
|
if strings.HasPrefix(tmp[2], w.Tag) {
|
|
repo = r
|
|
work = w
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
if !strings.HasPrefix(tmp[2], work.Tag) {
|
|
c.AbortWithStatusJSON(http.StatusOK, gin.H{"errmsg": fmt.Sprintf("Ignore ref %q has it doesn't start with %s. Check submission instructions if this is not expected.", tmp[2], work.Tag)})
|
|
return
|
|
}
|
|
}
|
|
|
|
TriggerTagUpdate(c, work, repo, user, &tmp[2], false)
|
|
})
|
|
}
|
|
|
|
func repositoryHandler(c *gin.Context) {
|
|
var u *User
|
|
if user, ok := c.Get("user"); ok {
|
|
u = user.(*User)
|
|
} else {
|
|
u = c.MustGet("LoggedUser").(*User)
|
|
}
|
|
|
|
if rid, err := strconv.Atoi(string(c.Param("rid"))); err != nil {
|
|
c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"errmsg": "Bad repository identifier."})
|
|
return
|
|
} else if c.MustGet("LoggedUser").(*User).IsAdmin {
|
|
if repository, err := getRepository(rid); err != nil {
|
|
c.AbortWithStatusJSON(http.StatusNotFound, gin.H{"errmsg": "Repository not found."})
|
|
return
|
|
} else {
|
|
c.Set("repository", repository)
|
|
c.Next()
|
|
}
|
|
} else if repository, err := u.getRepository(rid); err != nil {
|
|
c.AbortWithStatusJSON(http.StatusNotFound, gin.H{"errmsg": "Repository not found."})
|
|
return
|
|
} else {
|
|
c.Set("repository", repository)
|
|
c.Next()
|
|
}
|
|
}
|
|
|
|
func TriggerTagUpdate(c *gin.Context, work *Work, repo *Repository, u *User, tag *string, sig_optional bool) {
|
|
loggeduser := c.MustGet("LoggedUser").(*User)
|
|
now := time.Now()
|
|
|
|
if !loggeduser.IsAdmin && (!work.Shown || work.Corrected || work.StartAvailability.After(now) || work.EndAvailability.Add(time.Hour).Before(now)) {
|
|
c.AbortWithStatusJSON(http.StatusForbidden, gin.H{"errmsg": "The submission is closed."})
|
|
return
|
|
}
|
|
|
|
repo_tag := work.Tag
|
|
if tag != nil {
|
|
repo_tag = *tag
|
|
}
|
|
|
|
login := u.Login
|
|
groups := u.Groups
|
|
if u.Id != repo.IdUser {
|
|
user, _ := getUser(int(repo.IdUser))
|
|
if user != nil {
|
|
login = user.Login
|
|
groups = user.Groups
|
|
}
|
|
}
|
|
|
|
env := map[string]string{
|
|
"REPO_URL": repo.URI,
|
|
"REPO_TAG": repo_tag,
|
|
"LOGIN": login,
|
|
"GROUPS": groups,
|
|
"DEST": fmt.Sprintf("%d", work.Id),
|
|
}
|
|
|
|
if sig_optional {
|
|
env["TAG_SIG_OPTIONAL"] = "1"
|
|
}
|
|
|
|
client := drone.NewClient(droneEndpoint, droneConfig)
|
|
result, err := client.BuildCreate("teach", "atsebay.t-worker", "", "master", env)
|
|
if err != nil {
|
|
log.Println("Unable to communicate with Drone:", err.Error())
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "Unable to communication with the extraction service."})
|
|
return
|
|
}
|
|
|
|
repo.DroneRef = fmt.Sprintf("%s/%s/%d", "teach", "atsebay.t-worker", result.Number)
|
|
repo.LastCheck = &now
|
|
repo.Update()
|
|
|
|
repo.Secret = []byte{}
|
|
c.JSON(http.StatusOK, repo)
|
|
}
|
|
|
|
func TriggerTests(c *gin.Context, work *Work, repo *Repository, u *User) {
|
|
if work.GradationRepo == nil || len(*work.GradationRepo) == 0 {
|
|
c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"errmsg": "No tests defined for this work."})
|
|
return
|
|
}
|
|
|
|
slug := strings.SplitN(*work.GradationRepo, "/", 2)
|
|
if len(slug) != 2 {
|
|
c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"errmsg": "Graduation repository is invalid."})
|
|
return
|
|
}
|
|
|
|
login := u.Login
|
|
groups := u.Groups
|
|
if u.Id != repo.IdUser {
|
|
user, _ := getUser(int(repo.IdUser))
|
|
if user != nil {
|
|
login = user.Login
|
|
groups = user.Groups
|
|
}
|
|
}
|
|
|
|
branch := "master"
|
|
if len(work.Tag) > 0 {
|
|
branch = work.Tag
|
|
}
|
|
if branch[len(branch)-1] == '-' {
|
|
branch += "grades"
|
|
}
|
|
|
|
s, err := s3NewSession()
|
|
if err != nil {
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "Something goes wrong."})
|
|
return
|
|
}
|
|
|
|
req, _ := s3.New(s).GetObjectRequest(&s3.GetObjectInput{
|
|
Bucket: aws.String(s3_bucket),
|
|
Key: aws.String(filepath.Join(fmt.Sprintf("%d", work.Id), fmt.Sprintf("rendu-%s.tar.xz", u.Login))),
|
|
})
|
|
|
|
url, err := req.Presign(SharingTime)
|
|
if err != nil {
|
|
log.Println("Unable to create presign URL:", err)
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "Something goes wrong when creating the presigned URL."})
|
|
return
|
|
}
|
|
|
|
env := map[string]string{
|
|
"SUBMISSION_URL": repo.URI,
|
|
"META_URL": url,
|
|
"LOGIN": login,
|
|
"GROUPS": groups,
|
|
"DEST": fmt.Sprintf("%d", work.Id),
|
|
}
|
|
|
|
client := drone.NewClient(droneEndpoint, droneConfig)
|
|
result, err := client.BuildCreate(slug[0], slug[1], "", branch, env)
|
|
if err != nil {
|
|
log.Println("Unable to communicate with Drone:", err.Error())
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "Unable to communication with the extraction service."})
|
|
return
|
|
}
|
|
|
|
now := time.Now()
|
|
repo.TestsRef = fmt.Sprintf("%s/%d", *work.GradationRepo, result.Number)
|
|
repo.LastTests = &now
|
|
repo.Update()
|
|
|
|
repo.Secret = []byte{}
|
|
c.JSON(http.StatusOK, repo)
|
|
}
|
|
|
|
type Repository struct {
|
|
Id int64 `json:"id"`
|
|
IdUser int64 `json:"id_user"`
|
|
IdWork int64 `json:"id_work"`
|
|
URI string `json:"uri"`
|
|
Secret []byte `json:"secret,omitempty"`
|
|
LastCheck *time.Time `json:"last_check"`
|
|
DroneRef string `json:"drone_ref,omitempty"`
|
|
LastTests *time.Time `json:"last_tests"`
|
|
TestsRef string `json:"tests_ref,omitempty"`
|
|
AlreadyUsed bool `json:"already_used,omitempty"`
|
|
}
|
|
|
|
func (u *User) GetRepositories() (repositories []*Repository, err error) {
|
|
if rows, errr := DBQuery("SELECT id_repository, id_user, id_work, uri, secret, last_check, droneref, last_tests, testsref FROM user_work_repositories WHERE id_user=?", u.Id); errr != nil {
|
|
return nil, errr
|
|
} else {
|
|
defer rows.Close()
|
|
|
|
for rows.Next() {
|
|
var repo Repository
|
|
if err = rows.Scan(&repo.Id, &repo.IdUser, &repo.IdWork, &repo.URI, &repo.Secret, &repo.LastCheck, &repo.DroneRef, &repo.LastTests, &repo.TestsRef); err != nil {
|
|
return
|
|
}
|
|
repositories = append(repositories, &repo)
|
|
}
|
|
if err = rows.Err(); err != nil {
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
}
|
|
|
|
func getRepositoriesByURI(uri string) (repositories []*Repository, err error) {
|
|
if rows, errr := DBQuery("SELECT id_repository, id_user, id_work, uri, secret, last_check, droneref, last_tests, testsref FROM user_work_repositories WHERE uri=?", uri); errr != nil {
|
|
return nil, errr
|
|
} else {
|
|
defer rows.Close()
|
|
|
|
for rows.Next() {
|
|
var repo Repository
|
|
if err = rows.Scan(&repo.Id, &repo.IdUser, &repo.IdWork, &repo.URI, &repo.Secret, &repo.LastCheck, &repo.DroneRef, &repo.LastTests, &repo.TestsRef); err != nil {
|
|
return
|
|
}
|
|
repositories = append(repositories, &repo)
|
|
}
|
|
if err = rows.Err(); err != nil {
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
}
|
|
|
|
func getRepository(id int) (r *Repository, err error) {
|
|
r = new(Repository)
|
|
err = DBQueryRow("SELECT id_repository, id_user, id_work, uri, secret, last_check, droneref, last_tests, testsref FROM user_work_repositories WHERE id_repository=?", id).Scan(&r.Id, &r.IdUser, &r.IdWork, &r.URI, &r.Secret, &r.LastCheck, &r.DroneRef, &r.LastTests, &r.TestsRef)
|
|
return
|
|
}
|
|
|
|
func (u *User) getRepository(id int) (r *Repository, err error) {
|
|
r = new(Repository)
|
|
err = DBQueryRow("SELECT id_repository, id_user, id_work, uri, secret, last_check, droneref, last_tests, testsref FROM user_work_repositories WHERE id_repository=? AND id_user=?", id, u.Id).Scan(&r.Id, &r.IdUser, &r.IdWork, &r.URI, &r.Secret, &r.LastCheck, &r.DroneRef, &r.LastTests, &r.TestsRef)
|
|
return
|
|
}
|
|
|
|
func (u *User) NewRepository(w *Work, uri string) (*Repository, error) {
|
|
secret := make([]byte, 24)
|
|
_, err := rand.Read(secret)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if res, err := DBExec("INSERT INTO user_work_repositories (id_user, id_work, uri, secret, droneref) VALUES (?, ?, ?, ?, ?)", u.Id, w.Id, uri, secret, ""); err != nil {
|
|
return nil, err
|
|
} else if rid, err := res.LastInsertId(); err != nil {
|
|
return nil, err
|
|
} else {
|
|
return &Repository{rid, u.Id, w.Id, uri, secret, nil, "", nil, "", false}, nil
|
|
}
|
|
}
|
|
|
|
func (r *Repository) Update() (*Repository, error) {
|
|
if _, err := DBExec("UPDATE user_work_repositories SET id_user = ?, id_work = ?, uri = ?, secret = ?, last_check = ?, droneref = ?, last_tests = ?, testsref = ? WHERE id_repository = ?", r.IdUser, r.IdWork, r.URI, r.Secret, r.LastCheck, r.DroneRef, r.LastTests, r.TestsRef, r.Id); err != nil {
|
|
return nil, err
|
|
} else {
|
|
return r, err
|
|
}
|
|
}
|
|
|
|
func (r Repository) Delete() (int64, error) {
|
|
if res, err := DBExec("DELETE FROM user_work_repositories WHERE id_repository = ?", r.Id); err != nil {
|
|
return 0, err
|
|
} else if nb, err := res.RowsAffected(); err != nil {
|
|
return 0, err
|
|
} else {
|
|
return nb, err
|
|
}
|
|
}
|
|
|
|
func ClearRepositories() (int64, error) {
|
|
if res, err := DBExec("DELETE FROM user_work_repositories"); err != nil {
|
|
return 0, err
|
|
} else if nb, err := res.RowsAffected(); err != nil {
|
|
return 0, err
|
|
} else {
|
|
return nb, err
|
|
}
|
|
}
|