// BuildPostHandler handles post actions that occur to the current active stage.
func BuildPostHandler(ctx context.Context, rw http.ResponseWriter, r *http.Request) {
// check for authentication
user := models.FindUser(MustAuthenticate(r))
// setup
dataRenderer := data.FromContext(ctx)
// read parameters
id := to.Uint64(pat.Param(ctx, "id"))
target := r.FormValue("target") // either activity or process
name := r.FormValue("name") // activity (ignored), process - find process
action := r.FormValue("action") // activity (ignored), process passed on
value := r.FormValue("value") // activity (comment), process passed on
// find the build list
var pkg models.List
if err := models.DB.Where("id = ?", id).First(&pkg).Related(&pkg.Stages, "Stages").Error; err != nil {
if err == gorm.ErrRecordNotFound {
panic(ErrNotFound)
} else {
panic(err)
}
}
var result interface{}
// act based on target
switch target {
case "activity":
if value == "" {
panic(ErrBadRequest)
}
pkg.AddActivity(user, value)
result = map[string]interface{}{
"success": true,
}
case "process":
// load up the stage & process
if err := models.DB.Related(&pkg.Stages, "Stages").Error; err != nil {
panic(err)
}
var currentStage *models.ListStage
for _, v := range pkg.Stages {
if v.Name == pkg.StageCurrent {
currentStage = &v
break
}
}
if currentStage == nil {
panic(ErrNoCurrentStage)
}
if err := models.DB.Related(¤tStage.Processes).Error; err != nil {
panic(err)
}
var selectedProcess *models.ListStageProcess
for _, v := range currentStage.Processes {
if v.Name == name {
selectedProcess = &v
break
}
}
if selectedProcess == nil {
panic(ErrBadRequest)
}
// initialise the process
process, err := processes.BuildProcess(selectedProcess)
if err != nil {
panic(err)
}
r, err := process.APIRequest(user, action, value)
if err != nil {
result = map[string]interface{}{
"error": true,
"message": err.Error(),
"result": r,
}
} else {
result = r
}
default:
panic(ErrBadRequest)
}
dataRenderer.Type = data.DataJSON
dataRenderer.Data = result
//http.Redirect(rw, r, r.URL.String(), http.StatusTemporaryRedirect)
}
// BuildGetJSONHandler displays build information in JSON for a specific build.
func BuildGetJSONHandler(ctx context.Context, rw http.ResponseWriter, r *http.Request) {
dataRenderer := data.FromContext(ctx)
id := to.Uint64(pat.Param(ctx, "id"))
user := models.FindUserNoCreate(Authenticated(r))
// load the requested build list
var pkg models.List
if err := models.DB.Where("id = ?", id).First(&pkg).Related(&pkg.Activity, "Activity").Related(&pkg.Artifacts, "Artifacts").Related(&pkg.Links, "Links").Related(&pkg.Stages, "Stages").Error; err != nil {
if err == gorm.ErrRecordNotFound {
panic(ErrNotFound)
} else {
panic(err)
}
}
// load stage information
var stageInfo []buildGetJSONStage
for _, v := range pkg.Stages {
if err := models.DB.Related(&v.Processes, "Processes").Error; err != nil && err != gorm.ErrRecordNotFound {
panic(err)
}
// get all process info
status := map[string]processes.ProcessStatus{}
metadata := map[string]interface{}{}
optional := map[string]bool{}
for _, p := range v.Processes {
process, err := processes.BuildProcess(&p)
if err != nil {
panic(err)
}
status[p.Name] = process.Status()
metadata[p.Name] = process.APIMetadata(user)
optional[p.Name] = p.Optional
}
stageInfo = append(stageInfo, buildGetJSONStage{
Name: v.Name,
Status: status,
Metadata: metadata,
Optional: optional,
})
}
// render the data in a nice way
dataRenderer.Data = &buildGetJSON{
ID: pkg.ID,
Platform: pkg.Platform,
Channel: pkg.Channel,
Variants: strings.Split(pkg.Variants, ";"),
Name: pkg.Name,
Artifacts: pkg.Artifacts,
Links: pkg.Links,
Activity: pkg.Activity,
Changes: pkg.Changes,
BuildDate: pkg.BuildDate,
Updated: pkg.UpdatedAt,
PlatformConfig: pkg.PlatformGitConfig,
Stages: stageInfo,
CurrentStage: pkg.StageCurrent,
Status: pkg.StageResult,
Advisory: pkg.AdvisoryID,
}
dataRenderer.Type = data.DataJSON
}