Upstream
/
harbor
mirror of https://github.com/goharbor/harbor.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

replace status codes with constants in net/http

This commit is contained in:
Tan Jiang 2016-02-24 14:31:52 +08:00
parent ce5fcc1e1e
commit ecedb882a1
13 changed files with 116 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
api/base.go
View File

@ -40,7 +40,7 @@ func (b *BaseAPI) DecodeJsonReq(v interface{}) {
err := json.Unmarshal(b.Ctx.Input.CopyBody(1<<32), v) err := json.Unmarshal(b.Ctx.Input.CopyBody(1<<32), v)
if err != nil { if err != nil {
beego.Error("Error while decoding the json request:", err) beego.Error("Error while decoding the json request:", err)
b.CustomAbort(400, "Invalid json request") b.CustomAbort(http.StatusBadRequest, "Invalid json request")
} }
} }
@ -49,17 +49,17 @@ func (b *BaseAPI) ValidateUser() int {
sessionUserId := b.GetSession("userId") sessionUserId := b.GetSession("userId")
if sessionUserId == nil { if sessionUserId == nil {
beego.Warning("No user id in session, canceling request") beego.Warning("No user id in session, canceling request")
b.CustomAbort(401, "") b.CustomAbort(http.StatusUnauthorized, "")
} }
userId := sessionUserId.(int) userId := sessionUserId.(int)
u, err := dao.GetUser(models.User{UserId: userId}) u, err := dao.GetUser(models.User{UserId: userId})
if err != nil { if err != nil {
beego.Error("Error occurred in GetUser:", err) beego.Error("Error occurred in GetUser:", err)
b.CustomAbort(500, "Internal error.") b.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
if u == nil { if u == nil {
beego.Warning("User was deleted already, user id: ", userId, " canceling request.") beego.Warning("User was deleted already, user id: ", userId, " canceling request.")
b.CustomAbort(401, "") b.CustomAbort(http.StatusUnauthorized, "")
} }
return userId return userId
} }

27
api/project.go
View File

@ -17,6 +17,7 @@ package api
import ( import (
"fmt" "fmt"
"log" "log"
"net/http"
"github.com/vmware/harbor/dao" "github.com/vmware/harbor/dao"
"github.com/vmware/harbor/models" "github.com/vmware/harbor/models"
@ -48,15 +49,15 @@ func (p *ProjectAPI) Prepare() {
p.projectId, err = strconv.ParseInt(id_str, 10, 64) p.projectId, err = strconv.ParseInt(id_str, 10, 64)
if err != nil { if err != nil {
log.Printf("Error parsing project id: %s, error: %v", id_str, err) log.Printf("Error parsing project id: %s, error: %v", id_str, err)
p.CustomAbort(400, "invalid project id") p.CustomAbort(http.StatusBadRequest, "invalid project id")
} }
exist, err := dao.ProjectExists(p.projectId) exist, err := dao.ProjectExists(p.projectId)
if err != nil { if err != nil {
log.Printf("Error occurred in ProjectExists: %v", err) log.Printf("Error occurred in ProjectExists: %v", err)
p.CustomAbort(500, "Internal error.") p.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
if !exist { if !exist {
p.CustomAbort(404, fmt.Sprintf("project does not exist, id: %v", p.projectId)) p.CustomAbort(http.StatusNotFound, fmt.Sprintf("project does not exist, id: %v", p.projectId))
} }
} }
} }
@ -71,7 +72,7 @@ func (p *ProjectAPI) Post() {
err := validateProjectReq(req) err := validateProjectReq(req)
if err != nil { if err != nil {
beego.Error("Invalid project request, error: ", err) beego.Error("Invalid project request, error: ", err)
p.RenderError(400, "Invalid request for creating project") p.RenderError(http.StatusBadRequest, "Invalid request for creating project")
return return
} }
projectName := req.ProjectName projectName := req.ProjectName
@ -80,14 +81,14 @@ func (p *ProjectAPI) Post() {
beego.Error("Error happened checking project existence in db:", err, ", project name:", projectName) beego.Error("Error happened checking project existence in db:", err, ", project name:", projectName)
} }
if exist { if exist {
p.RenderError(409, "") p.RenderError(http.StatusConflict, "")
return return
} }
project := models.Project{OwnerId: p.userId, Name: projectName, CreationTime: time.Now(), Public: public} project := models.Project{OwnerId: p.userId, Name: projectName, CreationTime: time.Now(), Public: public}
err = dao.AddProject(project) err = dao.AddProject(project)
if err != nil { if err != nil {
beego.Error("Failed to add project, error: %v", err) beego.Error("Failed to add project, error: %v", err)
p.RenderError(500, "Failed to add project") p.RenderError(http.StatusInternalServerError, "Failed to add project")
} }
} }
@ -96,11 +97,11 @@ func (p *ProjectAPI) Head() {
result, err := dao.ProjectExists(projectName) result, err := dao.ProjectExists(projectName)
if err != nil { if err != nil {
beego.Error("Error while communicating with DB: ", err) beego.Error("Error while communicating with DB: ", err)
p.RenderError(500, "Error while communicating with DB") p.RenderError(http.StatusInternalServerError, "Error while communicating with DB")
return return
} }
if !result { if !result {
p.RenderError(404, "") p.RenderError(http.StatusNotFound, "")
return return
} }
} }
@ -117,7 +118,7 @@ func (p *ProjectAPI) Get() {
projectList, err := dao.QueryProject(queryProject) projectList, err := dao.QueryProject(queryProject)
if err != nil { if err != nil {
beego.Error("Error occurred in QueryProject:", err) beego.Error("Error occurred in QueryProject:", err)
p.CustomAbort(500, "Internal error.") p.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
for i := 0; i < len(projectList); i++ { for i := 0; i < len(projectList); i++ {
if isProjectAdmin(p.userId, projectList[i].ProjectId) { if isProjectAdmin(p.userId, projectList[i].ProjectId) {
@ -135,7 +136,7 @@ func (p *ProjectAPI) Put() {
projectId, err := strconv.ParseInt(p.Ctx.Input.Param(":id"), 10, 64) projectId, err := strconv.ParseInt(p.Ctx.Input.Param(":id"), 10, 64)
if err != nil { if err != nil {
beego.Error("Error parsing project id:", projectId, ", error: ", err) beego.Error("Error parsing project id:", projectId, ", error: ", err)
p.RenderError(400, "invalid project id") p.RenderError(http.StatusBadRequest, "invalid project id")
return return
} }
@ -145,13 +146,13 @@ func (p *ProjectAPI) Put() {
} }
if !isProjectAdmin(p.userId, projectId) { if !isProjectAdmin(p.userId, projectId) {
beego.Warning("Current user, id:", p.userId, ", does not have project admin role for project, id:", projectId) beego.Warning("Current user, id:", p.userId, ", does not have project admin role for project, id:", projectId)
p.RenderError(403, "") p.RenderError(http.StatusForbidden, "")
return return
} }
err = dao.ToggleProjectPublicity(p.projectId, public) err = dao.ToggleProjectPublicity(p.projectId, public)
if err != nil { if err != nil {
beego.Error("Error while updating project, project id:", projectId, ", error:", err) beego.Error("Error while updating project, project id:", projectId, ", error:", err)
p.RenderError(500, "Failed to update project") p.RenderError(http.StatusInternalServerError, "Failed to update project")
} }
} }
@ -173,7 +174,7 @@ func (p *ProjectAPI) FilterAccessLog() {
accessLogList, err := dao.GetAccessLogs(query) accessLogList, err := dao.GetAccessLogs(query)
if err != nil { if err != nil {
log.Printf("Error occurred in GetAccessLogs: %v", err) log.Printf("Error occurred in GetAccessLogs: %v", err)
p.CustomAbort(500, "Internal error.") p.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
p.Data["json"] = accessLogList p.Data["json"] = accessLogList
p.ServeJSON() p.ServeJSON()

47
api/project_member.go
View File

@ -15,12 +15,13 @@
package api package api
import ( import (
"net/http"
"strconv"
"github.com/vmware/harbor/dao" "github.com/vmware/harbor/dao"
"github.com/vmware/harbor/models" "github.com/vmware/harbor/models"
"github.com/astaxie/beego" "github.com/astaxie/beego"
"strconv"
) )
type ProjectMemberAPI struct { type ProjectMemberAPI struct {
@ -40,18 +41,18 @@ func (pma *ProjectMemberAPI) Prepare() {
pid, err := strconv.ParseInt(pma.Ctx.Input.Param(":pid"), 10, 64) pid, err := strconv.ParseInt(pma.Ctx.Input.Param(":pid"), 10, 64)
if err != nil { if err != nil {
beego.Error("Error parsing project id:", pid, ", error:", err) beego.Error("Error parsing project id:", pid, ", error:", err)
pma.CustomAbort(400, "invalid project Id") pma.CustomAbort(http.StatusBadRequest, "invalid project Id")
return return
} }
p, err := dao.GetProjectById(models.Project{ProjectId: pid}) p, err := dao.GetProjectById(models.Project{ProjectId: pid})
if err != nil { if err != nil {
beego.Error("Error occurred in GetProjectById:", err) beego.Error("Error occurred in GetProjectById:", err)
pma.CustomAbort(500, "Internal error.") pma.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
if p == nil { if p == nil {
beego.Warning("Project with id:", pid, "does not exist.") beego.Warning("Project with id:", pid, "does not exist.")
pma.CustomAbort(404, "Project does not exist") pma.CustomAbort(http.StatusNotFound, "Project does not exist")
} }
pma.project = p pma.project = p
pma.currentUserId = pma.ValidateUser() pma.currentUserId = pma.ValidateUser()
@ -64,7 +65,7 @@ func (pma *ProjectMemberAPI) Prepare() {
memberId, err := strconv.Atoi(mid) memberId, err := strconv.Atoi(mid)
if err != nil { if err != nil {
beego.Error("Invalid member Id, error:", err) beego.Error("Invalid member Id, error:", err)
pma.CustomAbort(400, "Invalid member id") pma.CustomAbort(http.StatusBadRequest, "Invalid member id")
} }
pma.memberId = memberId pma.memberId = memberId
} }
@ -74,7 +75,7 @@ func (pma *ProjectMemberAPI) Get() {
pid := pma.project.ProjectId pid := pma.project.ProjectId
if !CheckProjectPermission(pma.currentUserId, pid) { if !CheckProjectPermission(pma.currentUserId, pid) {
beego.Warning("Current user, user id :", pma.currentUserId, "does not have permission for project, id:", pid) beego.Warning("Current user, user id :", pma.currentUserId, "does not have permission for project, id:", pid)
pma.RenderError(403, "") pma.RenderError(http.StatusForbidden, "")
return return
} }
if pma.memberId == 0 { //member id not set return list of the members if pma.memberId == 0 { //member id not set return list of the members
@ -84,7 +85,7 @@ func (pma *ProjectMemberAPI) Get() {
userList, err := dao.GetUserByProject(queryProject, queryUser) userList, err := dao.GetUserByProject(queryProject, queryUser)
if err != nil { if err != nil {
beego.Error("Failed to query database for member list, error:", err) beego.Error("Failed to query database for member list, error:", err)
pma.RenderError(500, "Internal Server Error") pma.RenderError(http.StatusInternalServerError, "Internal Server Error")
return return
} }
pma.Data["json"] = userList pma.Data["json"] = userList
@ -92,14 +93,14 @@ func (pma *ProjectMemberAPI) Get() {
roleList, err := dao.GetUserProjectRoles(models.User{UserId: pma.memberId}, pid) roleList, err := dao.GetUserProjectRoles(models.User{UserId: pma.memberId}, pid)
if err != nil { if err != nil {
beego.Error("Error occurred in GetUserProjectRoles:", err) beego.Error("Error occurred in GetUserProjectRoles:", err)
pma.CustomAbort(500, "Internal error.") pma.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
//return empty role list to indicate if a user is not a member //return empty role list to indicate if a user is not a member
result := make(map[string]interface{}) result := make(map[string]interface{})
user, err := dao.GetUser(models.User{UserId: pma.memberId}) user, err := dao.GetUser(models.User{UserId: pma.memberId})
if err != nil { if err != nil {
beego.Error("Error occurred in GetUser:", err) beego.Error("Error occurred in GetUser:", err)
pma.CustomAbort(500, "Internal error.") pma.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
result["user_name"] = user.Username result["user_name"] = user.Username
result["user_id"] = pma.memberId result["user_id"] = pma.memberId
@ -115,11 +116,11 @@ func (pma *ProjectMemberAPI) Post() {
rolelist, err := dao.GetUserProjectRoles(userQuery, pid) rolelist, err := dao.GetUserProjectRoles(userQuery, pid)
if err != nil { if err != nil {
beego.Error("Error occurred in GetUserProjectRoles:", err) beego.Error("Error occurred in GetUserProjectRoles:", err)
pma.CustomAbort(500, "Internal error.") pma.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
if len(rolelist) == 0 { if len(rolelist) == 0 {
beego.Warning("Current user, id:", pma.currentUserId, "does not have project admin role for project, id:", pid) beego.Warning("Current user, id:", pma.currentUserId, "does not have project admin role for project, id:", pid)
pma.RenderError(403, "") pma.RenderError(http.StatusForbidden, "")
return return
} }
var req memberReq var req memberReq
@ -128,17 +129,17 @@ func (pma *ProjectMemberAPI) Post() {
userId := CheckUserExists(username) userId := CheckUserExists(username)
if userId <= 0 { if userId <= 0 {
beego.Warning("User does not exist, user name:", username) beego.Warning("User does not exist, user name:", username)
pma.RenderError(404, "User does not exist") pma.RenderError(http.StatusNotFound, "User does not exist")
return return
} }
rolelist, err = dao.GetUserProjectRoles(models.User{UserId: userId}, pid) rolelist, err = dao.GetUserProjectRoles(models.User{UserId: userId}, pid)
if err != nil { if err != nil {
beego.Error("Error occurred in GetUserProjectRoles:", err) beego.Error("Error occurred in GetUserProjectRoles:", err)
pma.CustomAbort(500, "Internal error.") pma.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
if len(rolelist) > 0 { if len(rolelist) > 0 {
beego.Warning("user is already added to project, user id:", userId, ", project id:", pid) beego.Warning("user is already added to project, user id:", userId, ", project id:", pid)
pma.RenderError(409, "user is ready in project") pma.RenderError(http.StatusConflict, "user is ready in project")
return return
} }
@ -146,7 +147,7 @@ func (pma *ProjectMemberAPI) Post() {
err = dao.AddUserProjectRole(userId, pid, int(rid)) err = dao.AddUserProjectRole(userId, pid, int(rid))
if err != nil { if err != nil {
beego.Error("Failed to update DB to add project user role, project id:", pid, ", user id:", userId, ", role id:", rid) beego.Error("Failed to update DB to add project user role, project id:", pid, ", user id:", userId, ", role id:", rid)
pma.RenderError(500, "Failed to update data in database") pma.RenderError(http.StatusInternalServerError, "Failed to update data in database")
return return
} }
} }
@ -159,11 +160,11 @@ func (pma *ProjectMemberAPI) Put() {
rolelist, err := dao.GetUserProjectRoles(userQuery, pid) rolelist, err := dao.GetUserProjectRoles(userQuery, pid)
if err != nil { if err != nil {
beego.Error("Error occurred in GetUserProjectRoles:", err) beego.Error("Error occurred in GetUserProjectRoles:", err)
pma.CustomAbort(500, "Internal error.") pma.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
if len(rolelist) == 0 { if len(rolelist) == 0 {
beego.Warning("Current user, id:", pma.currentUserId, ", does not have project admin role for project, id:", pid) beego.Warning("Current user, id:", pma.currentUserId, ", does not have project admin role for project, id:", pid)
pma.RenderError(403, "") pma.RenderError(http.StatusForbidden, "")
return return
} }
var req memberReq var req memberReq
@ -171,7 +172,7 @@ func (pma *ProjectMemberAPI) Put() {
roleList, err := dao.GetUserProjectRoles(models.User{UserId: mid}, pid) roleList, err := dao.GetUserProjectRoles(models.User{UserId: mid}, pid)
if len(roleList) == 0 { if len(roleList) == 0 {
beego.Warning("User is not in project, user id:", mid, ", project id:", pid) beego.Warning("User is not in project, user id:", mid, ", project id:", pid)
pma.RenderError(404, "user not exist in project") pma.RenderError(http.StatusNotFound, "user not exist in project")
return return
} }
//TODO: delete and insert should in one transaction //TODO: delete and insert should in one transaction
@ -179,7 +180,7 @@ func (pma *ProjectMemberAPI) Put() {
err = dao.DeleteUserProjectRoles(mid, pid) err = dao.DeleteUserProjectRoles(mid, pid)
if err != nil { if err != nil {
beego.Error("Failed to delete project roles for user, user id:", mid, ", project id: ", pid, ", error: ", err) beego.Error("Failed to delete project roles for user, user id:", mid, ", project id: ", pid, ", error: ", err)
pma.RenderError(500, "Failed to update data in DB") pma.RenderError(http.StatusInternalServerError, "Failed to update data in DB")
return return
} }
//insert roles in request //insert roles in request
@ -187,7 +188,7 @@ func (pma *ProjectMemberAPI) Put() {
err = dao.AddUserProjectRole(mid, pid, int(rid)) err = dao.AddUserProjectRole(mid, pid, int(rid))
if err != nil { if err != nil {
beego.Error("Failed to update DB to add project user role, project id:", pid, ", user id:", mid, ", role id:", rid) beego.Error("Failed to update DB to add project user role, project id:", pid, ", user id:", mid, ", role id:", rid)
pma.RenderError(500, "Failed to update data in database") pma.RenderError(http.StatusInternalServerError, "Failed to update data in database")
return return
} }
} }
@ -200,13 +201,13 @@ func (pma *ProjectMemberAPI) Delete() {
rolelist, err := dao.GetUserProjectRoles(userQuery, pid) rolelist, err := dao.GetUserProjectRoles(userQuery, pid)
if len(rolelist) == 0 { if len(rolelist) == 0 {
beego.Warning("Current user, id:", pma.currentUserId, ", does not have project admin role for project, id:", pid) beego.Warning("Current user, id:", pma.currentUserId, ", does not have project admin role for project, id:", pid)
pma.RenderError(403, "") pma.RenderError(http.StatusForbidden, "")
return return
} }
err = dao.DeleteUserProjectRoles(mid, pid) err = dao.DeleteUserProjectRoles(mid, pid)
if err != nil { if err != nil {
beego.Error("Failed to delete project roles for user, user id:", mid, ", project id:", pid, ", error:", err) beego.Error("Failed to delete project roles for user, user id:", mid, ", project id:", pid, ", error:", err)
pma.RenderError(500, "Failed to update data in DB") pma.RenderError(http.StatusInternalServerError, "Failed to update data in DB")
return return
} }
} }

19
api/repository.go
View File

@ -16,6 +16,7 @@ package api
import ( import (
"encoding/json" "encoding/json"
"net/http"
"strconv" "strconv"
"strings" "strings"
"time" "time"
@ -56,28 +57,28 @@ func (ra *RepositoryAPI) Get() {
projectId, err0 := ra.GetInt64("project_id") projectId, err0 := ra.GetInt64("project_id")
if err0 != nil { if err0 != nil {
beego.Error("Failed to get project id, error:", err0) beego.Error("Failed to get project id, error:", err0)
ra.RenderError(400, "Invalid project id") ra.RenderError(http.StatusBadRequest, "Invalid project id")
return return
} }
projectQuery := models.Project{ProjectId: projectId} projectQuery := models.Project{ProjectId: projectId}
p, err := dao.GetProjectById(projectQuery) p, err := dao.GetProjectById(projectQuery)
if err != nil { if err != nil {
beego.Error("Error occurred in GetProjectById:", err) beego.Error("Error occurred in GetProjectById:", err)
ra.CustomAbort(500, "Internal error.") ra.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
if p == nil { if p == nil {
beego.Warning("Project with Id:", projectId, ", does not exist", projectId) beego.Warning("Project with Id:", projectId, ", does not exist", projectId)
ra.RenderError(404, "") ra.RenderError(http.StatusNotFound, "")
return return
} }
if p.Public == 0 && !CheckProjectPermission(ra.userId, projectId) { if p.Public == 0 && !CheckProjectPermission(ra.userId, projectId) {
ra.RenderError(403, "") ra.RenderError(http.StatusForbidden, "")
return return
} }
repoList, err := svc_utils.GetRepoFromCache() repoList, err := svc_utils.GetRepoFromCache()
if err != nil { if err != nil {
beego.Error("Failed to get repo from cache, error:", err) beego.Error("Failed to get repo from cache, error:", err)
ra.RenderError(500, "internal sever error") ra.RenderError(http.StatusInternalServerError, "internal sever error")
} }
projectName := p.Name projectName := p.Name
q := ra.GetString("q") q := ra.GetString("q")
@ -127,7 +128,7 @@ func (ra *RepositoryAPI) GetTags() {
result, err := svc_utils.RegistryApiGet(svc_utils.BuildRegistryUrl(repoName, "tags", "list"), ra.username) result, err := svc_utils.RegistryApiGet(svc_utils.BuildRegistryUrl(repoName, "tags", "list"), ra.username)
if err != nil { if err != nil {
beego.Error("Failed to get repo tags, repo name:", repoName, ", error: ", err) beego.Error("Failed to get repo tags, repo name:", repoName, ", error: ", err)
ra.RenderError(500, "Failed to get repo tags") ra.RenderError(http.StatusInternalServerError, "Failed to get repo tags")
} else { } else {
t := Tag{} t := Tag{}
json.Unmarshal(result, &t) json.Unmarshal(result, &t)
@ -146,14 +147,14 @@ func (ra *RepositoryAPI) GetManifests() {
result, err := svc_utils.RegistryApiGet(svc_utils.BuildRegistryUrl(repoName, "manifests", tag), ra.username) result, err := svc_utils.RegistryApiGet(svc_utils.BuildRegistryUrl(repoName, "manifests", tag), ra.username)
if err != nil { if err != nil {
beego.Error("Failed to get manifests for repo, repo name:", repoName, ", tag:", tag, ", error:", err) beego.Error("Failed to get manifests for repo, repo name:", repoName, ", tag:", tag, ", error:", err)
ra.RenderError(500, "Internal Server Error") ra.RenderError(http.StatusInternalServerError, "Internal Server Error")
return return
} else { } else {
mani := Manifest{} mani := Manifest{}
err = json.Unmarshal(result, &mani) err = json.Unmarshal(result, &mani)
if err != nil { if err != nil {
beego.Error("Failed to decode json from response for manifests, repo name:", repoName, ", tag:", tag, ", error:", err) beego.Error("Failed to decode json from response for manifests, repo name:", repoName, ", tag:", tag, ", error:", err)
ra.RenderError(500, "Internal Server Error") ra.RenderError(http.StatusInternalServerError, "Internal Server Error")
return return
} else { } else {
v1Compatibility := mani.History[0].V1Compatibility v1Compatibility := mani.History[0].V1Compatibility
@ -161,7 +162,7 @@ func (ra *RepositoryAPI) GetManifests() {
err = json.Unmarshal([]byte(v1Compatibility), &item) err = json.Unmarshal([]byte(v1Compatibility), &item)
if err != nil { if err != nil {
beego.Error("Failed to decode V1 field for repo, repo name:", repoName, ", tag:", tag, ", error:", err) beego.Error("Failed to decode V1 field for repo, repo name:", repoName, ", tag:", tag, ", error:", err)
ra.RenderError(500, "Internal Server Error") ra.RenderError(http.StatusInternalServerError, "Internal Server Error")
return return
} else { } else {
item.CreatedStr = item.Created.Format("2006-01-02 15:04:05") item.CreatedStr = item.Created.Format("2006-01-02 15:04:05")

5
api/search.go
View File

@ -15,6 +15,7 @@
package api package api
import ( import (
"net/http"
"sort" "sort"
"strings" "strings"
@ -44,7 +45,7 @@ func (n *SearchAPI) Get() {
projects, err := dao.QueryRelevantProjects(userId) projects, err := dao.QueryRelevantProjects(userId)
if err != nil { if err != nil {
beego.Error("Failed to get projects of user id:", userId, ", error:", err) beego.Error("Failed to get projects of user id:", userId, ", error:", err)
n.CustomAbort(500, "Failed to get project search result") n.CustomAbort(http.StatusInternalServerError, "Failed to get project search result")
} }
projectSorter := &utils.ProjectSorter{Projects: projects} projectSorter := &utils.ProjectSorter{Projects: projects}
sort.Sort(projectSorter) sort.Sort(projectSorter)
@ -66,7 +67,7 @@ func (n *SearchAPI) Get() {
repositories, err2 := svc_utils.GetRepoFromCache() repositories, err2 := svc_utils.GetRepoFromCache()
if err2 != nil { if err2 != nil {
beego.Error("Failed to get repos from cache, error :", err2) beego.Error("Failed to get repos from cache, error :", err2)
n.CustomAbort(500, "Failed to get repositories search result") n.CustomAbort(http.StatusInternalServerError, "Failed to get repositories search result")
} }
sort.Strings(repositories) sort.Strings(repositories)
repositoryResult := filterRepositories(repositories, projects, keyword) repositoryResult := filterRepositories(repositories, projects, keyword)

27
api/user.go
View File

@ -15,6 +15,7 @@
package api package api
import ( import (
"net/http"
"strconv" "strconv"
"github.com/vmware/harbor/dao" "github.com/vmware/harbor/dao"
@ -40,17 +41,17 @@ func (ua *UserAPI) Prepare() {
ua.userId, err = strconv.Atoi(id) ua.userId, err = strconv.Atoi(id)
if err != nil { if err != nil {
beego.Error("Invalid user id, error:", err) beego.Error("Invalid user id, error:", err)
ua.CustomAbort(400, "Invalid user Id") ua.CustomAbort(http.StatusBadRequest, "Invalid user Id")
} }
userQuery := models.User{UserId: ua.userId} userQuery := models.User{UserId: ua.userId}
u, err := dao.GetUser(userQuery) u, err := dao.GetUser(userQuery)
if err != nil { if err != nil {
beego.Error("Error occurred in GetUser:", err) beego.Error("Error occurred in GetUser:", err)
ua.CustomAbort(500, "Internal error.") ua.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
if u == nil { if u == nil {
beego.Error("User with Id:", ua.userId, "does not exist") beego.Error("User with Id:", ua.userId, "does not exist")
ua.CustomAbort(404, "") ua.CustomAbort(http.StatusNotFound, "")
} }
} }
} }
@ -59,13 +60,13 @@ func (ua *UserAPI) Get() {
exist, err := dao.IsAdminRole(ua.currentUid) exist, err := dao.IsAdminRole(ua.currentUid)
if err != nil { if err != nil {
beego.Error("Error occurred in IsAdminRole:", err) beego.Error("Error occurred in IsAdminRole:", err)
ua.CustomAbort(500, "Internal error.") ua.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
if ua.userId == 0 { //list users if ua.userId == 0 { //list users
if !exist { if !exist {
beego.Error("Current user, id:", ua.currentUid, ", does not have admin role, can not list users") beego.Error("Current user, id:", ua.currentUid, ", does not have admin role, can not list users")
ua.RenderError(403, "User does not have admin role") ua.RenderError(http.StatusForbidden, "User does not have admin role")
return return
} }
username := ua.GetString("username") username := ua.GetString("username")
@ -76,7 +77,7 @@ func (ua *UserAPI) Get() {
userList, err := dao.ListUsers(userQuery) userList, err := dao.ListUsers(userQuery)
if err != nil { if err != nil {
beego.Error("Failed to get data from database, error:", err) beego.Error("Failed to get data from database, error:", err)
ua.RenderError(500, "Failed to query from database") ua.RenderError(http.StatusInternalServerError, "Failed to query from database")
return return
} }
ua.Data["json"] = userList ua.Data["json"] = userList
@ -86,12 +87,12 @@ func (ua *UserAPI) Get() {
u, err := dao.GetUser(userQuery) u, err := dao.GetUser(userQuery)
if err != nil { if err != nil {
beego.Error("Error occurred in GetUser:", err) beego.Error("Error occurred in GetUser:", err)
ua.CustomAbort(500, "Internal error.") ua.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
ua.Data["json"] = u ua.Data["json"] = u
} else { } else {
beego.Error("Current user, id:", ua.currentUid, "does not have admin role, can not view other user's detail") beego.Error("Current user, id:", ua.currentUid, "does not have admin role, can not view other user's detail")
ua.RenderError(403, "User does not have admin role") ua.RenderError(http.StatusForbidden, "User does not have admin role")
return return
} }
ua.ServeJSON() ua.ServeJSON()
@ -101,11 +102,11 @@ func (ua *UserAPI) Put() { //currently only for toggle admin, so no request body
exist, err := dao.IsAdminRole(ua.currentUid) exist, err := dao.IsAdminRole(ua.currentUid)
if err != nil { if err != nil {
beego.Error("Error occurred in IsAdminRole:", err) beego.Error("Error occurred in IsAdminRole:", err)
ua.CustomAbort(500, "Internal error.") ua.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
if !exist { if !exist {
beego.Warning("current user, id:", ua.currentUid, ", does not have admin role, can not update other user's role") beego.Warning("current user, id:", ua.currentUid, ", does not have admin role, can not update other user's role")
ua.RenderError(403, "User does not have admin role") ua.RenderError(http.StatusForbidden, "User does not have admin role")
return return
} }
userQuery := models.User{UserId: ua.userId} userQuery := models.User{UserId: ua.userId}
@ -116,17 +117,17 @@ func (ua *UserAPI) Delete() {
exist, err := dao.IsAdminRole(ua.currentUid) exist, err := dao.IsAdminRole(ua.currentUid)
if err != nil { if err != nil {
beego.Error("Error occurred in IsAdminRole:", err) beego.Error("Error occurred in IsAdminRole:", err)
ua.CustomAbort(500, "Internal error.") ua.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
if !exist { if !exist {
beego.Warning("current user, id:", ua.currentUid, ", does not have admin role, can not remove user") beego.Warning("current user, id:", ua.currentUid, ", does not have admin role, can not remove user")
ua.RenderError(403, "User does not have admin role") ua.RenderError(http.StatusForbidden, "User does not have admin role")
return return
} }
err = dao.DeleteUser(ua.userId) err = dao.DeleteUser(ua.userId)
if err != nil { if err != nil {
beego.Error("Failed to delete data from database, error:", err) beego.Error("Failed to delete data from database, error:", err)
ua.RenderError(500, "Failed to delete User") ua.RenderError(http.StatusInternalServerError, "Failed to delete User")
return return
} }
} }

9
controllers/item_detail.go
View File

@ -15,6 +15,7 @@
package controllers package controllers
import ( import (
"net/http"
"net/url" "net/url"
"os" "os"
@ -68,7 +69,7 @@ func (idc *ItemDetailController) Get() {
projectId, _ := idc.GetInt64("project_id") projectId, _ := idc.GetInt64("project_id")
if CheckPublicProject(projectId) == false && (sessionUserId == nil || !CheckProjectRole(sessionUserId.(int), projectId)) { if CheckPublicProject(projectId) == false && (sessionUserId == nil || !CheckProjectRole(sessionUserId.(int), projectId)) {
idc.Redirect("/signIn?uri="+url.QueryEscape(idc.Ctx.Input.URI()), 302) idc.Redirect("/signIn?uri="+url.QueryEscape(idc.Ctx.Input.URI()), http.StatusFound)
} }
projectQuery := models.Project{ProjectId: projectId} projectQuery := models.Project{ProjectId: projectId}
@ -76,11 +77,11 @@ func (idc *ItemDetailController) Get() {
if err != nil { if err != nil {
beego.Error("Error occurred in GetProjectById:", err) beego.Error("Error occurred in GetProjectById:", err)
idc.CustomAbort(500, "Internal error.") idc.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
if project == nil { if project == nil {
idc.Redirect("/signIn", 302) idc.Redirect("/signIn", http.StatusFound)
} }
idc.Data["ProjectId"] = project.ProjectId idc.Data["ProjectId"] = project.ProjectId
@ -94,7 +95,7 @@ func (idc *ItemDetailController) Get() {
roleList, err := dao.GetUserProjectRoles(models.User{UserId: sessionUserId.(int)}, projectId) roleList, err := dao.GetUserProjectRoles(models.User{UserId: sessionUserId.(int)}, projectId)
if err != nil { if err != nil {
beego.Error("Error occurred in GetUserProjectRoles:", err) beego.Error("Error occurred in GetUserProjectRoles:", err)
idc.CustomAbort(500, "Internal error.") idc.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
if len(roleList) > 0 { if len(roleList) > 0 {
idc.Data["RoleId"] = roleList[0].RoleId idc.Data["RoleId"] = roleList[0].RoleId

8
controllers/login.go
View File

@ -15,6 +15,8 @@
package controllers package controllers
import ( import (
"net/http"
"github.com/vmware/harbor/models" "github.com/vmware/harbor/models"
"github.com/vmware/harbor/opt_auth" "github.com/vmware/harbor/opt_auth"
@ -45,11 +47,11 @@ func (c *CommonController) Login() {
user, err := opt_auth.Login(models.AuthModel{principal, password}) user, err := opt_auth.Login(models.AuthModel{principal, password})
if err != nil { if err != nil {
beego.Error("Error occurred in UserLogin:", err) beego.Error("Error occurred in UserLogin:", err)
c.CustomAbort(500, "Internal error.") c.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
if user == nil { if user == nil {
c.CustomAbort(401, "") c.CustomAbort(http.StatusUnauthorized, "")
} }
c.SetSession("userId", user.UserId) c.SetSession("userId", user.UserId)
@ -62,7 +64,7 @@ func (c *CommonController) SwitchLanguage() {
c.SetSession("lang", lang) c.SetSession("lang", lang)
c.Data["Lang"] = lang c.Data["Lang"] = lang
} }
c.Redirect(c.Ctx.Request.Header.Get("Referer"), 302) c.Redirect(c.Ctx.Request.Header.Get("Referer"), http.StatusFound)
} }
func (c *CommonController) Logout() { func (c *CommonController) Logout() {

47
controllers/password.go
View File

@ -16,6 +16,7 @@ package controllers
import ( import (
"bytes" "bytes"
"net/http"
"os" "os"
"regexp" "regexp"
"text/template" "text/template"
@ -34,7 +35,7 @@ type ChangePasswordController struct {
func (cpc *ChangePasswordController) Get() { func (cpc *ChangePasswordController) Get() {
sessionUserId := cpc.GetSession("userId") sessionUserId := cpc.GetSession("userId")
if sessionUserId == nil { if sessionUserId == nil {
cpc.Redirect("/signIn", 302) cpc.Redirect("/signIn", http.StatusFound)
} }
cpc.Data["Username"] = cpc.GetSession("username") cpc.Data["Username"] = cpc.GetSession("username")
cpc.ForwardTo("page_title_change_password", "change-password") cpc.ForwardTo("page_title_change_password", "change-password")
@ -46,25 +47,25 @@ func (cpc *CommonController) UpdatePassword() {
if sessionUserId == nil { if sessionUserId == nil {
beego.Warning("User does not login.") beego.Warning("User does not login.")
cpc.CustomAbort(401, "please_login_first") cpc.CustomAbort(http.StatusUnauthorized, "please_login_first")
} }
oldPassword := cpc.GetString("old_password") oldPassword := cpc.GetString("old_password")
if oldPassword == "" { if oldPassword == "" {
beego.Error("Old password is blank") beego.Error("Old password is blank")
cpc.CustomAbort(400, "Old password is blank") cpc.CustomAbort(http.StatusBadRequest, "Old password is blank")
} }
queryUser := models.User{UserId: sessionUserId.(int), Password: oldPassword} queryUser := models.User{UserId: sessionUserId.(int), Password: oldPassword}
user, err := dao.CheckUserPassword(queryUser) user, err := dao.CheckUserPassword(queryUser)
if err != nil { if err != nil {
beego.Error("Error occurred in CheckUserPassword:", err) beego.Error("Error occurred in CheckUserPassword:", err)
cpc.CustomAbort(500, "Internal error.") cpc.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
if user == nil { if user == nil {
beego.Warning("Password input is not correct") beego.Warning("Password input is not correct")
cpc.CustomAbort(403, "old_password_is_not_correct") cpc.CustomAbort(http.StatusForbidden, "old_password_is_not_correct")
} }
password := cpc.GetString("password") password := cpc.GetString("password")
@ -73,10 +74,10 @@ func (cpc *CommonController) UpdatePassword() {
err = dao.ChangeUserPassword(updateUser, oldPassword) err = dao.ChangeUserPassword(updateUser, oldPassword)
if err != nil { if err != nil {
beego.Error("Error occurred in ChangeUserPassword:", err) beego.Error("Error occurred in ChangeUserPassword:", err)
cpc.CustomAbort(500, "Internal error.") cpc.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
} else { } else {
cpc.CustomAbort(400, "please_input_new_password") cpc.CustomAbort(http.StatusBadRequest, "please_input_new_password")
} }
} }
@ -101,23 +102,23 @@ func (fpc *CommonController) SendEmail() {
pass, _ := regexp.MatchString(`^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$`, email) pass, _ := regexp.MatchString(`^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$`, email)
if !pass { if !pass {
fpc.CustomAbort(400, "email_content_illegal") fpc.CustomAbort(http.StatusBadRequest, "email_content_illegal")
} else { } else {
queryUser := models.User{Email: email} queryUser := models.User{Email: email}
exist, err := dao.UserExists(queryUser, "email") exist, err := dao.UserExists(queryUser, "email")
if err != nil { if err != nil {
beego.Error("Error occurred in UserExists:", err) beego.Error("Error occurred in UserExists:", err)
fpc.CustomAbort(500, "Internal error.") fpc.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
if !exist { if !exist {
fpc.CustomAbort(404, "email_does_not_exist") fpc.CustomAbort(http.StatusNotFound, "email_does_not_exist")
} }
messageTemplate, err := template.ParseFiles("views/reset-password-mail.tpl") messageTemplate, err := template.ParseFiles("views/reset-password-mail.tpl")
if err != nil { if err != nil {
beego.Error("Parse email template file failed:", err) beego.Error("Parse email template file failed:", err)
fpc.CustomAbort(500, err.Error()) fpc.CustomAbort(http.StatusInternalServerError, err.Error())
} }
message := new(bytes.Buffer) message := new(bytes.Buffer)
@ -129,7 +130,7 @@ func (fpc *CommonController) SendEmail() {
uuid, err := dao.GenerateRandomString() uuid, err := dao.GenerateRandomString()
if err != nil { if err != nil {
beego.Error("Error occurred in GenerateRandomString:", err) beego.Error("Error occurred in GenerateRandomString:", err)
fpc.CustomAbort(500, "Internal error.") fpc.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
err = messageTemplate.Execute(message, MessageDetail{ err = messageTemplate.Execute(message, MessageDetail{
Hint: fpc.Tr("reset_email_hint"), Hint: fpc.Tr("reset_email_hint"),
@ -139,13 +140,13 @@ func (fpc *CommonController) SendEmail() {
if err != nil { if err != nil {
beego.Error("message template error:", err) beego.Error("message template error:", err)
fpc.CustomAbort(500, "internal_error") fpc.CustomAbort(http.StatusInternalServerError, "internal_error")
} }
config, err := beego.AppConfig.GetSection("mail") config, err := beego.AppConfig.GetSection("mail")
if err != nil { if err != nil {
beego.Error("Can not load app.conf:", err) beego.Error("Can not load app.conf:", err)
fpc.CustomAbort(500, "internal_error") fpc.CustomAbort(http.StatusInternalServerError, "internal_error")
} }
mail := utils.Mail{ mail := utils.Mail{
@ -158,7 +159,7 @@ func (fpc *CommonController) SendEmail() {
if err != nil { if err != nil {
beego.Error("send email failed:", err) beego.Error("send email failed:", err)
fpc.CustomAbort(500, "send_email_failed") fpc.CustomAbort(http.StatusInternalServerError, "send_email_failed")
} }
user := models.User{ResetUuid: uuid, Email: email} user := models.User{ResetUuid: uuid, Email: email}
@ -177,21 +178,21 @@ func (rpc *ResetPasswordController) Get() {
resetUuid := rpc.GetString("reset_uuid") resetUuid := rpc.GetString("reset_uuid")
if resetUuid == "" { if resetUuid == "" {
beego.Error("Reset uuid is blank.") beego.Error("Reset uuid is blank.")
rpc.Redirect("/", 302) rpc.Redirect("/", http.StatusFound)
} }
queryUser := models.User{ResetUuid: resetUuid} queryUser := models.User{ResetUuid: resetUuid}
user, err := dao.GetUser(queryUser) user, err := dao.GetUser(queryUser)
if err != nil { if err != nil {
beego.Error("Error occurred in GetUser:", err) beego.Error("Error occurred in GetUser:", err)
rpc.CustomAbort(500, "Internal error.") rpc.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
if user != nil { if user != nil {
rpc.Data["ResetUuid"] = user.ResetUuid rpc.Data["ResetUuid"] = user.ResetUuid
rpc.ForwardTo("page_title_reset_password", "reset-password") rpc.ForwardTo("page_title_reset_password", "reset-password")
} else { } else {
rpc.Redirect("/", 302) rpc.Redirect("/", http.StatusFound)
} }
} }
@ -199,18 +200,18 @@ func (rpc *CommonController) ResetPassword() {
resetUuid := rpc.GetString("reset_uuid") resetUuid := rpc.GetString("reset_uuid")
if resetUuid == "" { if resetUuid == "" {
rpc.CustomAbort(400, "Reset uuid is blank.") rpc.CustomAbort(http.StatusBadRequest, "Reset uuid is blank.")
} }
queryUser := models.User{ResetUuid: resetUuid} queryUser := models.User{ResetUuid: resetUuid}
user, err := dao.GetUser(queryUser) user, err := dao.GetUser(queryUser)
if err != nil { if err != nil {
beego.Error("Error occurred in GetUser:", err) beego.Error("Error occurred in GetUser:", err)
rpc.CustomAbort(500, "Internal error.") rpc.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
if user == nil { if user == nil {
beego.Error("User does not exist") beego.Error("User does not exist")
rpc.CustomAbort(400, "User does not exist") rpc.CustomAbort(http.StatusBadRequest, "User does not exist")
} }
password := rpc.GetString("password") password := rpc.GetString("password")
@ -220,9 +221,9 @@ func (rpc *CommonController) ResetPassword() {
err = dao.ResetUserPassword(*user) err = dao.ResetUserPassword(*user)
if err != nil { if err != nil {
beego.Error("Error occurred in ResetUserPassword:", err) beego.Error("Error occurred in ResetUserPassword:", err)
rpc.CustomAbort(500, "Internal error.") rpc.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
} else { } else {
rpc.CustomAbort(400, "password_is_required") rpc.CustomAbort(http.StatusBadRequest, "password_is_required")
} }
} }

7
controllers/register.go
View File

@ -15,6 +15,7 @@
package controllers package controllers
import ( import (
"net/http"
"os" "os"
"strings" "strings"
@ -33,7 +34,7 @@ func (rc *RegisterController) Get() {
if authMode == "" || authMode == "db_auth" { if authMode == "" || authMode == "db_auth" {
rc.ForwardTo("page_title_registration", "register") rc.ForwardTo("page_title_registration", "register")
} else { } else {
rc.Redirect("/signIn", 404) rc.Redirect("/signIn", http.StatusNotFound)
} }
} }
@ -49,7 +50,7 @@ func (rc *CommonController) SignUp() {
_, err := dao.Register(user) _, err := dao.Register(user)
if err != nil { if err != nil {
beego.Error("Error occurred in Register:", err) beego.Error("Error occurred in Register:", err)
rc.CustomAbort(500, "Internal error.") rc.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
} }
@ -68,7 +69,7 @@ func (rc *CommonController) UserExists() {
exist, err := dao.UserExists(user, target) exist, err := dao.UserExists(user, target)
if err != nil { if err != nil {
beego.Error("Error occurred in UserExists:", err) beego.Error("Error occurred in UserExists:", err)
rc.CustomAbort(500, "Internal error.") rc.CustomAbort(http.StatusInternalServerError, "Internal error.")
} }
rc.Data["json"] = exist rc.Data["json"] = exist
rc.ServeJSON() rc.ServeJSON()

5
service/auth.go
View File

@ -16,6 +16,7 @@ package service
import ( import (
"log" "log"
"net/http"
"github.com/vmware/harbor/models" "github.com/vmware/harbor/models"
"github.com/vmware/harbor/opt_auth" "github.com/vmware/harbor/opt_auth"
@ -46,7 +47,7 @@ func (a *AuthController) Auth() {
if len(scope) == 0 && !authenticated { if len(scope) == 0 && !authenticated {
log.Printf("login request with invalid credentials") log.Printf("login request with invalid credentials")
a.CustomAbort(401, "") a.CustomAbort(http.StatusUnauthorized, "")
} }
access := svc_utils.GetResourceActions(scope) access := svc_utils.GetResourceActions(scope)
for _, a := range access { for _, a := range access {
@ -61,7 +62,7 @@ func (a *AuthController) serveToken(username, service string, access []*token.Re
rawToken, err := svc_utils.MakeToken(username, service, access) rawToken, err := svc_utils.MakeToken(username, service, access)
if err != nil { if err != nil {
log.Printf("Failed to make token, error: %v", err) log.Printf("Failed to make token, error: %v", err)
writer.WriteHeader(500) writer.WriteHeader(http.StatusInternalServerError)
return return
} }
tk := make(map[string]string) tk := make(map[string]string)

6
service/utils/registry_utils.go
View File

@ -50,9 +50,9 @@ func RegistryApiGet(url, username string) ([]byte, error) {
return nil, err return nil, err
} }
defer response.Body.Close() defer response.Body.Close()
if response.StatusCode == 200 { if response.StatusCode == http.StatusOK {
return result, nil return result, nil
} else if response.StatusCode == 401 { } else if response.StatusCode == http.StatusUnauthorized {
authenticate := response.Header.Get("WWW-Authenticate") authenticate := response.Header.Get("WWW-Authenticate")
str := strings.Split(authenticate, " ")[1] str := strings.Split(authenticate, " ")[1]
log.Println("url: " + url) log.Println("url: " + url)
@ -94,7 +94,7 @@ func RegistryApiGet(url, username string) ([]byte, error) {
if err != nil { if err != nil {
return nil, err return nil, err
} }
if response.StatusCode != 200 { if response.StatusCode != http.StatusOK {
errMsg := fmt.Sprintf("Unexpected return code from registry: %d", response.StatusCode) errMsg := fmt.Sprintf("Unexpected return code from registry: %d", response.StatusCode)
log.Printf(errMsg) log.Printf(errMsg)
return nil, fmt.Errorf(errMsg) return nil, fmt.Errorf(errMsg)

6
utils/registry_utils.go
View File

@ -55,9 +55,9 @@ func HttpGet(url, sessionId, username, password string) ([]byte, error) {
return nil, err return nil, err
} }
defer response.Body.Close() defer response.Body.Close()
if response.StatusCode == 200 { if response.StatusCode == http.StatusOK {
return result, nil return result, nil
} else if response.StatusCode == 401 { } else if response.StatusCode == http.StatusUnauthorized {
authenticate := response.Header.Get("WWW-Authenticate") authenticate := response.Header.Get("WWW-Authenticate")
str := strings.Split(authenticate, " ")[1] str := strings.Split(authenticate, " ")[1]
beego.Trace("url: " + url) beego.Trace("url: " + url)
@ -106,7 +106,7 @@ func HttpGet(url, sessionId, username, password string) ([]byte, error) {
if err != nil { if err != nil {
return nil, err return nil, err
} }
if response.StatusCode == 200 { if response.StatusCode == http.StatusOK {
tt := make(map[string]string) tt := make(map[string]string)
json.Unmarshal(result, &tt) json.Unmarshal(result, &tt)
request, err = http.NewRequest("GET", url, nil) request, err = http.NewRequest("GET", url, nil)