// PostHook accepts a post-commit hook and parses the payload
// in order to trigger a build. The payload is specified to the
// remote system (ie GitHub) and will therefore get parsed by
// the appropriate remote plugin.
//
// POST /api/repos/{host}/{owner}/{name}/branches/{branch}/commits/{commit}
//
func PostCommit(c web.C, w http.ResponseWriter, r *http.Request) {
var ctx = context.FromC(c)
var (
branch = c.URLParams["branch"]
hash = c.URLParams["commit"]
host = c.URLParams["host"]
repo = ToRepo(c)
remote = remote.Lookup(host)
)
commit, err := datastore.GetCommitSha(ctx, repo, branch, hash)
if err != nil {
w.WriteHeader(http.StatusNotFound)
return
}
if commit.Status == model.StatusStarted ||
commit.Status == model.StatusEnqueue {
w.WriteHeader(http.StatusConflict)
return
}
commit.Status = model.StatusEnqueue
commit.Started = 0
commit.Finished = 0
commit.Duration = 0
if err := datastore.PutCommit(ctx, commit); err != nil {
w.WriteHeader(http.StatusInternalServerError)
return
}
owner, err := datastore.GetUser(ctx, repo.UserID)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
return
}
// Request a new token and update
user_token, err := remote.GetToken(owner)
if user_token != nil {
owner.Access = user_token.AccessToken
owner.Secret = user_token.RefreshToken
owner.TokenExpiry = user_token.Expiry
datastore.PutUser(ctx, owner)
} else if err != nil {
w.WriteHeader(http.StatusBadRequest)
return
}
// drop the items on the queue
go worker.Do(ctx, &worker.Work{
User: owner,
Repo: repo,
Commit: commit,
Host: httputil.GetURL(r),
})
w.WriteHeader(http.StatusOK)
}
// PostUserSync accepts a request to post user sync
//
// POST /api/user/sync
//
func PostUserSync(c web.C, w http.ResponseWriter, r *http.Request) {
var ctx = context.FromC(c)
var user = ToUser(c)
if user == nil {
w.WriteHeader(http.StatusUnauthorized)
return
}
var remote = remote.Lookup(user.Remote)
if remote == nil {
w.WriteHeader(http.StatusNotFound)
return
}
if user.Syncing {
w.WriteHeader(http.StatusConflict)
return
}
// Request a new token and update
user_token, err := remote.GetToken(user)
if user_token != nil {
user.Access = user_token.AccessToken
user.Secret = user_token.RefreshToken
user.TokenExpiry = user_token.Expiry
} else if err != nil {
w.WriteHeader(http.StatusNotFound)
return
}
user.Syncing = true
if err := datastore.PutUser(ctx, user); err != nil {
w.WriteHeader(http.StatusNotFound)
return
}
go sync.SyncUser(ctx, user, remote)
w.WriteHeader(http.StatusNoContent)
return
}
// GetLogin accepts a request to authorize the user and to
// return a valid OAuth2 access token. The access token is
// returned as url segment #access_token
//
// GET /login/:host
//
func GetLogin(c web.C, w http.ResponseWriter, r *http.Request) {
var ctx = context.FromC(c)
var host = c.URLParams["host"]
var redirect = "/"
var remote = remote.Lookup(host)
if remote == nil {
w.WriteHeader(http.StatusNotFound)
return
}
w.Header().Del("Content-Type")
// authenticate the user
login, err := remote.Authorize(w, r)
if err != nil {
log.Println(err)
w.WriteHeader(http.StatusBadRequest)
return
} else if login == nil {
// in this case we probably just redirected
// the user, so we can exit with no error
return
}
// get the user from the database
u, err := datastore.GetUserLogin(ctx, host, login.Login)
if err != nil {
// if self-registration is disabled we should
// return a notAuthorized error. the only exception
// is if no users exist yet in the system we'll proceed.
if remote.OpenRegistration() == false {
users, err := datastore.GetUserList(ctx)
if err != nil || len(users) != 0 {
log.Println("Unable to create account. Registration is closed")
w.WriteHeader(http.StatusForbidden)
return
}
}
// create the user account
u = model.NewUser(remote.GetKind(), login.Login, login.Email)
u.Name = login.Name
u.SetEmail(login.Email)
// insert the user into the database
if err := datastore.PostUser(ctx, u); err != nil {
log.Println(err)
w.WriteHeader(http.StatusBadRequest)
return
}
// the user id should NEVER equal zero
if u.ID == 0 {
log.Println("Unable to create account. User ID is zero")
w.WriteHeader(http.StatusInternalServerError)
return
}
// if this is the first user, they
// should be an admin.
if u.ID == 1 {
u.Admin = true
}
}
// update the user access token
// in case it changed in GitHub
u.Access = login.Access
u.Secret = login.Secret
u.Name = login.Name
u.TokenExpiry = login.Expiry
u.SetEmail(login.Email)
u.Syncing = u.IsStale()
if err := datastore.PutUser(ctx, u); err != nil {
log.Println(err)
w.WriteHeader(http.StatusBadRequest)
return
}
// look at the last synchronized date to determine if
// we need to re-sync the account.
//
// todo(bradrydzewski) this should move to a server/sync package and
// should be injected into this struct, just like the database code.
//
// todo(bradrydzewski) this login should be a bit more intelligent
// than the current implementation.
if u.Syncing {
redirect = "/sync"
log.Println("sync user account.", u.Login)
// sync inside a goroutine
go sync.SyncUser(ctx, u, remote)
}
token, err := session.GenerateToken(ctx, r, u)
if err != nil {
log.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
redirect = redirect + "#access_token=" + token
http.Redirect(w, r, redirect, http.StatusSeeOther)
}