func PatchUser(c *gin.Context) {
me := session.User(c)
in := &model.User{}
err := c.Bind(in)
if err != nil {
c.AbortWithStatus(http.StatusBadRequest)
return
}
user, err := store.GetUserLogin(c, c.Param("login"))
if err != nil {
c.AbortWithStatus(http.StatusNotFound)
return
}
user.Admin = in.Admin
user.Active = in.Active
// cannot update self
if me.ID == user.ID {
c.AbortWithStatus(http.StatusForbidden)
return
}
err = store.UpdateUser(c, user)
if err != nil {
c.AbortWithStatus(http.StatusConflict)
return
}
c.IndentedJSON(http.StatusOK, user)
}
// Handler is a route handler for '/movie.:format' route
func Handler(c *gin.Context) {
requestType := c.Param("format")
term := c.Request.PostFormValue("text")
log.Printf("Movie Query: %s", term)
movie, err := lookupMovie(term)
switch requestType {
case "json":
if err != nil {
c.JSON(http.StatusNotFound, gin.H{"Response": err.Error()})
} else {
c.IndentedJSON(http.StatusOK, movie)
}
case "slack":
text, err := formatSlackResp(movie)
if err != nil {
c.String(http.StatusNotFound, "Not Found")
}
c.String(http.StatusOK, text)
default:
c.JSON(http.StatusUnsupportedMediaType, nil)
}
}
func processCommentHook(c *gin.Context, hook *model.Hook) {
repo, user, err := getRepoAndUser(c, hook.Repo.Slug)
if err != nil {
return
}
config, maintainer, err := getConfigAndMaintainers(c, user, repo)
if err != nil {
return
}
approvers, err := buildApprovers(c, user, repo, config, maintainer, hook.Issue)
if err != nil {
return
}
approved := len(approvers) >= config.Approvals
err = remote.SetStatus(c, user, repo, hook.Issue.Number, approved)
if err != nil {
log.Errorf("Error setting status for %s pr %d. %s", repo.Slug, hook.Issue.Number, err)
c.String(500, "Error setting status. %s.", err)
return
}
log.Debugf("processed comment for %s. received %d of %d approvals", repo.Slug, len(approvers), config.Approvals)
c.IndentedJSON(200, gin.H{
"approvers": maintainer.People,
"settings": config,
"approved": approved,
"approved_by": approvers,
})
}
func GetBuild(c *gin.Context) {
if c.Param("number") == "latest" {
GetBuildLast(c)
return
}
repo := session.Repo(c)
num, err := strconv.Atoi(c.Param("number"))
if err != nil {
c.AbortWithError(http.StatusBadRequest, err)
return
}
build, err := store.GetBuildNumber(c, repo, num)
if err != nil {
c.AbortWithError(http.StatusInternalServerError, err)
return
}
jobs, _ := store.GetJobList(c, build)
out := struct {
*model.Build
Jobs []*model.Job `json:"jobs"`
}{build, jobs}
c.IndentedJSON(http.StatusOK, &out)
}
func GetRepos(c *gin.Context) {
user := session.User(c)
remote := remote.FromContext(c)
var repos []*model.RepoLite
// get the repository list from the cache
reposv, ok := c.Get("repos")
if ok {
repos = reposv.([]*model.RepoLite)
} else {
var err error
repos, err = remote.Repos(user)
if err != nil {
c.AbortWithStatus(http.StatusInternalServerError)
return
}
}
// for each repository in the remote system we get
// the intersection of those repostiories in Drone
repos_, err := store.GetRepoListOf(c, repos)
if err != nil {
c.AbortWithStatus(http.StatusInternalServerError)
return
}
c.Set("repos", repos)
c.IndentedJSON(http.StatusOK, repos_)
}
func processPRHook(c *gin.Context, prHook *model.PRHook) {
repo, user, err := getRepoAndUser(c, prHook.Repo.Slug)
if err != nil {
return
}
err = remote.SetStatus(c, user, repo, prHook.Number, false)
if err != nil {
log.Errorf("Error setting status. %s", err)
c.String(500, "Error setting status. %s", err)
return
}
config, _, err := getConfigAndMaintainers(c, user, repo)
if err != nil {
return
}
if prHook.Update && config.DoComment {
err = remote.WriteComment(c, user, repo, prHook.Number, "The Pull Request has been updated. No comments before this one will count for approval.")
if err != nil {
log.Errorf("Error writing comment for status. %s", err)
c.String(500, "Error writing comment for status. %s", err)
return
}
}
c.IndentedJSON(200, gin.H{
"number": prHook.Number,
"approved": false,
})
}
// PostsHandler is a route handler for '/producthunt/posts.:format' route
func PostsHandler(c *gin.Context) {
requestType := c.Param("format")
daysAgo, err := strconv.Atoi(c.Request.PostFormValue("text"))
if err != nil {
daysAgo = 0
}
log.Printf("Days Ago: %d", daysAgo)
posts, err := getPosts(daysAgo)
switch requestType {
case "json":
if err != nil {
c.JSON(http.StatusNotFound, gin.H{"Response": err.Error()})
} else {
c.IndentedJSON(http.StatusOK, posts)
}
case "slack":
text, err := formatPostsSlackResp(posts)
if err != nil {
c.String(http.StatusNotFound, "Not Found")
}
c.String(http.StatusOK, text)
default:
c.JSON(http.StatusUnsupportedMediaType, nil)
}
}
func GetLoginToken(c *gin.Context) {
remote := remote.FromContext(c)
in := &tokenPayload{}
err := c.Bind(in)
if err != nil {
c.AbortWithError(http.StatusBadRequest, err)
return
}
login, err := remote.Auth(in.Access, in.Refresh)
if err != nil {
c.AbortWithError(http.StatusUnauthorized, err)
return
}
user, err := store.GetUserLogin(c, login)
if err != nil {
c.AbortWithError(http.StatusNotFound, err)
return
}
exp := time.Now().Add(time.Hour * 72).Unix()
token := token.New(token.SessToken, user.Login)
tokenstr, err := token.SignExpires(user.Hash, exp)
if err != nil {
c.AbortWithError(http.StatusInternalServerError, err)
return
}
c.IndentedJSON(http.StatusOK, &tokenPayload{
Access: tokenstr,
Expires: exp - time.Now().Unix(),
})
}
// return data from a sensor in json format
// This function call reduceData!
func (s *Sensorserver) GetSensorData(c *gin.Context) {
// maximum Timestamp is MaxInt32
// fetchLastData return all records, if duration is
// also MaxInt32
// -> MaxInt32 - MaxInt32 = 0 -> get all data since 01.0.1.1970
const duration int = math.MaxInt32
pretty := c.Request.URL.Query().Get("pretty")
sensor := c.Param("name")
data, err := s.fetchLastData(sensor, duration)
if err != nil {
if pretty == "true" {
c.IndentedJSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
} else {
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
}
} else {
if pretty == "true" {
c.IndentedJSON(http.StatusOK, s.reduceData(data))
} else {
c.JSON(http.StatusOK, s.reduceData(data))
}
}
}
func DeleteRequest(c *gin.Context) {
message := "success"
// if err := RequestCollection.Remove(bson.M{"_id": bson.ObjectIdHex(c.Param("id"))}); err != nil {
if err := RequestCollection.RemoveId(bson.ObjectIdHex(c.Param("id"))); err != nil {
message = PrepareMessage(err)
}
c.IndentedJSON(200, gin.H{"message": message})
}
func GetUsers(c *gin.Context) {
users, err := store.GetUserList(c)
if err != nil {
c.AbortWithStatus(http.StatusInternalServerError)
return
}
c.IndentedJSON(http.StatusOK, users)
}
func GetUser(c *gin.Context) {
user, err := store.GetUserLogin(c, c.Param("login"))
if err != nil {
c.AbortWithStatus(http.StatusNotFound)
return
}
c.IndentedJSON(http.StatusOK, user)
}
func GetBuilds(c *gin.Context) {
repo := session.Repo(c)
builds, err := store.GetBuildList(c, repo)
if err != nil {
c.AbortWithStatus(http.StatusInternalServerError)
return
}
c.IndentedJSON(http.StatusOK, builds)
}
func GetRequest(c *gin.Context) {
request := &Request{}
httpCode := 200
message := ""
if err := RequestCollection.FindId(bson.ObjectIdHex(c.Param("id"))).One(request); err != nil {
request = nil
httpCode = 404
message = PrepareMessage(err)
}
c.IndentedJSON(httpCode, gin.H{"data": request, "message": message})
}
func GetRemoteRepos(c *gin.Context) {
user := session.User(c)
repos, err := cache.GetRepos(c, user)
if err != nil {
c.AbortWithStatus(http.StatusInternalServerError)
return
}
c.IndentedJSON(http.StatusOK, repos)
}
func (s *Sensorserver) Stats(c *gin.Context) {
prev := s.boltdb.Stats()
pretty := c.Request.URL.Query().Get("pretty")
if pretty == "true" {
c.IndentedJSON(http.StatusOK, prev)
} else {
c.JSON(http.StatusOK, prev)
}
}
func CreateRequest(c *gin.Context) {
request := &Request{}
message := "success"
httpCode := 200
c.Bind(request)
if err := request.Create(); err != nil {
message = PrepareMessage(err)
request = nil
httpCode = 500
}
c.IndentedJSON(httpCode, gin.H{"message": message, "data": request})
}
func JSONResponse(ctx *gin.Context, statusCode int, obj ...interface{}) {
if len(obj) == 1 {
if gin.Mode() == "debug" {
ctx.IndentedJSON(statusCode, obj[0])
} else {
ctx.JSON(statusCode, obj[0])
}
} else {
if gin.Mode() == "debug" {
ctx.IndentedJSON(statusCode, obj)
} else {
ctx.JSON(statusCode, obj)
}
}
}
// CreateToken procedure generates both tokens, sends them to ms-auth, and returns them to client
func CreateToken(c *gin.Context, host *url.URL, cid string) (err error) {
//create token
if aToken, rToken, err := KeyInstance().GenerateAccessToken(cid, true); err == nil {
//post refresh to ms-auth
PostRefresh(host, cid, rToken)
//return both to Client
data := map[string]string{
"access_token": aToken,
"refresh_token": rToken,
}
c.IndentedJSON(200, data)
return nil
}
return err //TODO: Figure out what error would mean for client logging in and handle in functions calling this one
}
func GetBuildLast(c *gin.Context) {
repo := session.Repo(c)
branch := c.DefaultQuery("branch", repo.Branch)
build, err := store.GetBuildLast(c, repo, branch)
if err != nil {
c.String(http.StatusInternalServerError, err.Error())
return
}
jobs, _ := store.GetJobList(c, build)
out := struct {
*model.Build
Jobs []*model.Job `json:"jobs"`
}{build, jobs}
c.IndentedJSON(http.StatusOK, &out)
}
func PatchRepo(c *gin.Context) {
repo := session.Repo(c)
user := session.User(c)
in := &struct {
IsTrusted *bool `json:"trusted,omitempty"`
Timeout *int64 `json:"timeout,omitempty"`
AllowPull *bool `json:"allow_pr,omitempty"`
AllowPush *bool `json:"allow_push,omitempty"`
AllowDeploy *bool `json:"allow_deploy,omitempty"`
AllowTag *bool `json:"allow_tag,omitempty"`
}{}
if err := c.Bind(in); err != nil {
c.AbortWithError(http.StatusBadRequest, err)
return
}
if in.AllowPush != nil {
repo.AllowPush = *in.AllowPush
}
if in.AllowPull != nil {
repo.AllowPull = *in.AllowPull
}
if in.AllowDeploy != nil {
repo.AllowDeploy = *in.AllowDeploy
}
if in.AllowTag != nil {
repo.AllowTag = *in.AllowTag
}
if in.IsTrusted != nil && user.Admin {
repo.IsTrusted = *in.IsTrusted
}
if in.Timeout != nil && user.Admin {
repo.Timeout = *in.Timeout
}
err := store.UpdateRepo(c, repo)
if err != nil {
c.AbortWithError(http.StatusInternalServerError, err)
return
}
c.IndentedJSON(http.StatusOK, repo)
}
func GetRepos(c *gin.Context) {
user := session.User(c)
repos, err := cache.GetRepos(c, user)
if err != nil {
c.AbortWithStatus(http.StatusInternalServerError)
return
}
// for each repository in the remote system we get
// the intersection of those repostiories in Drone
repos_, err := store.GetRepoListOf(c, repos)
if err != nil {
c.AbortWithStatus(http.StatusInternalServerError)
return
}
c.IndentedJSON(http.StatusOK, repos_)
}
func GetRemoteRepos(c *gin.Context) {
user := session.User(c)
remote := remote.FromContext(c)
reposv, ok := c.Get("repos")
if ok {
c.IndentedJSON(http.StatusOK, reposv)
return
}
repos, err := remote.Repos(user)
if err != nil {
c.AbortWithStatus(http.StatusInternalServerError)
return
}
c.Set("repos", repos)
c.IndentedJSON(http.StatusOK, repos)
}
func GetUser(c *gin.Context) {
user, err := store.GetUserLogin(c, c.Param("login"))
if err != nil {
c.AbortWithStatus(http.StatusNotFound)
return
}
token := token.New(token.UserToken, user.Login)
tokenstr, err := token.Sign(user.Hash)
if err != nil {
tokenstr = ""
}
userWithToken := struct {
*model.User
Token string `json:"token,omitempty"`
}{user, tokenstr}
c.IndentedJSON(http.StatusOK, userWithToken)
}
// Handler is a route handler for '/excuse.:format' route
func Handler(c *gin.Context) {
requestType := c.Param("format")
excuse, err := getAnExcuse()
switch requestType {
case "json":
if err != nil {
c.JSON(http.StatusNotFound, gin.H{"Response": err.Error()})
} else {
c.IndentedJSON(http.StatusOK, excuse)
}
case "slack":
if err != nil {
c.String(http.StatusNotFound, "> I am not feeling well\n")
}
c.String(http.StatusOK, "\n> "+excuse.Text+"\n")
default:
c.String(http.StatusUnsupportedMediaType, "")
}
}
func EditRequest(c *gin.Context) {
message := "success"
request := &Request{}
httpCode := 200
err := RequestCollection.FindId(bson.ObjectIdHex(c.Param("id"))).One(request)
if err != nil {
message = PrepareMessage(err)
httpCode = 404
} else {
c.Bind(request)
if err = request.Check(); err != nil {
message = PrepareMessage(err)
httpCode = 400
} else if err = RequestCollection.UpdateId(bson.ObjectIdHex(c.Param("id")), bson.M{"$set": request}); err != nil {
request = nil
message = PrepareMessage(err)
httpCode = 500
}
}
c.IndentedJSON(httpCode, gin.H{"message": message, "data": request})
}
func PostUser(c *gin.Context) {
in := &struct {
model.User
Token string `json:"oauth_token"`
}{}
err := c.Bind(in)
if err != nil {
c.String(http.StatusBadRequest, err.Error())
return
}
user := &model.User{}
user.Login = in.Login
user.Email = in.Email
user.Admin = in.Admin
user.Token = in.Token
user.Avatar = in.Avatar
user.Active = true
user.Hash = crypto.Rand()
err = store.CreateUser(c, user)
if err != nil {
c.String(http.StatusInternalServerError, err.Error())
return
}
token := token.New(token.UserToken, user.Login)
tokenstr, err := token.Sign(user.Hash)
if err != nil {
tokenstr = ""
}
userWithToken := struct {
*model.User
Token string `json:"token,omitempty"`
}{user, tokenstr}
c.IndentedJSON(http.StatusOK, userWithToken)
}
func PostNode(c *gin.Context) {
engine := context.Engine(c)
in := struct {
Addr string `json:"address"`
Arch string `json:"architecture"`
Cert string `json:"cert"`
Key string `json:"key"`
CA string `json:"ca"`
}{}
err := c.Bind(&in)
if err != nil {
c.AbortWithStatus(http.StatusBadRequest)
return
}
node := &model.Node{}
node.Addr = in.Addr
node.Cert = in.Cert
node.Key = in.Key
node.CA = in.CA
node.Arch = "linux_amd64"
err = engine.Allocate(node)
if err != nil {
c.String(http.StatusBadRequest, err.Error())
return
}
err = store.CreateNode(c, node)
if err != nil {
c.AbortWithStatus(http.StatusInternalServerError)
return
}
c.IndentedJSON(http.StatusOK, node)
}
func PostUser(c *gin.Context) {
in := &model.User{}
err := c.Bind(in)
if err != nil {
c.String(http.StatusBadRequest, err.Error())
return
}
user := &model.User{}
user.Login = in.Login
user.Email = in.Email
user.Admin = in.Admin
user.Avatar = in.Avatar
user.Active = true
user.Hash = crypto.Rand()
err = store.CreateUser(c, user)
if err != nil {
c.String(http.StatusInternalServerError, err.Error())
return
}
c.IndentedJSON(http.StatusOK, user)
}
// LoginToken authenticates a user with their GitHub token and
// returns an LGTM API token in the response.
func LoginToken(c *gin.Context) {
access := c.Query("access_token")
login, err := remote.GetUserToken(c, access)
if err != nil {
c.String(403, "Unable to authenticate user. %s", err)
return
}
user, err := store.GetUserLogin(c, login)
if err != nil {
c.String(404, "Unable to authenticate user %s. Not registered.", user.Login)
return
}
exp := time.Now().Add(time.Hour * 72).Unix()
token := token.New(token.UserToken, user.Login)
tokenstr, err := token.SignExpires(user.Secret, exp)
if err != nil {
c.AbortWithError(http.StatusInternalServerError, err)
return
}
c.IndentedJSON(http.StatusOK, &tokenPayload{
Access: tokenstr,
Expires: exp - time.Now().Unix(),
})
}
