Replaced generic map with concrete struct.

modules/private/serv.go

@@ -58,7 +58,6 @@ type ServCommandResults struct {
 // ErrServCommand is an error returned from ServCommmand.
 type ErrServCommand struct {
 	Results    ServCommandResults
-	Type       string
 	Err        string
 	StatusCode int
 }

routers/private/hook.go

@@ -124,17 +124,17 @@ func HookPreReceive(ctx *gitea_context.PrivateContext) {
 	repo, err := models.GetRepositoryByOwnerAndName(ownerName, repoName)
 	if err != nil {
 		log.Error("Unable to get repository: %s/%s Error: %v", ownerName, repoName, err)
-		ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"err": err.Error(),
+		ctx.JSON(http.StatusInternalServerError, private.Response{
+			Err: err.Error(),
 		})
 		return
 	}
 	repo.OwnerName = ownerName
 	gitRepo, err := git.OpenRepository(repo.RepoPath())
 	if err != nil {
 		log.Error("Unable to get git repository for: %s/%s Error: %v", ownerName, repoName, err)
-		ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"err": err.Error(),
+		ctx.JSON(http.StatusInternalServerError, private.Response{
+			Err: err.Error(),
 		})
 		return
 	}
@@ -164,17 +164,17 @@ func HookPreReceive(ctx *gitea_context.PrivateContext) {
 		branchName := strings.TrimPrefix(refFullName, git.BranchPrefix)
 		if branchName == repo.DefaultBranch && newCommitID == git.EmptySHA {
 			log.Warn("Forbidden: Branch: %s is the default branch in %-v and cannot be deleted", branchName, repo)
-			ctx.JSON(http.StatusForbidden, map[string]interface{}{
-				"err": fmt.Sprintf("branch %s is the default branch and cannot be deleted", branchName),
+			ctx.JSON(http.StatusForbidden, private.Response{
+				Err: fmt.Sprintf("branch %s is the default branch and cannot be deleted", branchName),
 			})
 			return
 		}
 
 		protectBranch, err := models.GetProtectedBranchBy(repo.ID, branchName)
 		if err != nil {
 			log.Error("Unable to get protected branch: %s in %-v Error: %v", branchName, repo, err)
-			ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-				"err": err.Error(),
+			ctx.JSON(http.StatusInternalServerError, private.Response{
+				Err: err.Error(),
 			})
 			return
 		}
@@ -191,8 +191,8 @@ func HookPreReceive(ctx *gitea_context.PrivateContext) {
 		// 1. Detect and prevent deletion of the branch
 		if newCommitID == git.EmptySHA {
 			log.Warn("Forbidden: Branch: %s in %-v is protected from deletion", branchName, repo)
-			ctx.JSON(http.StatusForbidden, map[string]interface{}{
-				"err": fmt.Sprintf("branch %s is protected from deletion", branchName),
+			ctx.JSON(http.StatusForbidden, private.Response{
+				Err: fmt.Sprintf("branch %s is protected from deletion", branchName),
 			})
 			return
 		}
@@ -202,14 +202,14 @@ func HookPreReceive(ctx *gitea_context.PrivateContext) {
 			output, err := git.NewCommand("rev-list", "--max-count=1", oldCommitID, "^"+newCommitID).RunInDirWithEnv(repo.RepoPath(), env)
 			if err != nil {
 				log.Error("Unable to detect force push between: %s and %s in %-v Error: %v", oldCommitID, newCommitID, repo, err)
-				ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-					"err": fmt.Sprintf("Fail to detect force push: %v", err),
+				ctx.JSON(http.StatusInternalServerError, private.Response{
+					Err: fmt.Sprintf("Fail to detect force push: %v", err),
 				})
 				return
 			} else if len(output) > 0 {
 				log.Warn("Forbidden: Branch: %s in %-v is protected from force push", branchName, repo)
-				ctx.JSON(http.StatusForbidden, map[string]interface{}{
-					"err": fmt.Sprintf("branch %s is protected from force push", branchName),
+				ctx.JSON(http.StatusForbidden, private.Response{
+					Err: fmt.Sprintf("branch %s is protected from force push", branchName),
 				})
 				return
 
@@ -222,15 +222,15 @@ func HookPreReceive(ctx *gitea_context.PrivateContext) {
 			if err != nil {
 				if !isErrUnverifiedCommit(err) {
 					log.Error("Unable to check commits from %s to %s in %-v: %v", oldCommitID, newCommitID, repo, err)
-					ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-						"err": fmt.Sprintf("Unable to check commits from %s to %s: %v", oldCommitID, newCommitID, err),
+					ctx.JSON(http.StatusInternalServerError, private.Response{
+						Err: fmt.Sprintf("Unable to check commits from %s to %s: %v", oldCommitID, newCommitID, err),
 					})
 					return
 				}
 				unverifiedCommit := err.(*errUnverifiedCommit).sha
 				log.Warn("Forbidden: Branch: %s in %-v is protected from unverified commit %s", branchName, repo, unverifiedCommit)
-				ctx.JSON(http.StatusForbidden, map[string]interface{}{
-					"err": fmt.Sprintf("branch %s is protected from unverified commit %s", branchName, unverifiedCommit),
+				ctx.JSON(http.StatusForbidden, private.Response{
+					Err: fmt.Sprintf("branch %s is protected from unverified commit %s", branchName, unverifiedCommit),
 				})
 				return
 			}
@@ -248,8 +248,8 @@ func HookPreReceive(ctx *gitea_context.PrivateContext) {
 			if err != nil {
 				if !models.IsErrFilePathProtected(err) {
 					log.Error("Unable to check file protection for commits from %s to %s in %-v: %v", oldCommitID, newCommitID, repo, err)
-					ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-						"err": fmt.Sprintf("Unable to check file protection for commits from %s to %s: %v", oldCommitID, newCommitID, err),
+					ctx.JSON(http.StatusInternalServerError, private.Response{
+						Err: fmt.Sprintf("Unable to check file protection for commits from %s to %s: %v", oldCommitID, newCommitID, err),
 					})
 					return
 				}
@@ -276,16 +276,16 @@ func HookPreReceive(ctx *gitea_context.PrivateContext) {
 				// We are changing a protected file and we're not allowed to do that
 				if changedProtectedfiles {
 					log.Warn("Forbidden: Branch: %s in %-v is protected from changing file %s", branchName, repo, protectedFilePath)
-					ctx.JSON(http.StatusForbidden, map[string]interface{}{
-						"err": fmt.Sprintf("branch %s is protected from changing file %s", branchName, protectedFilePath),
+					ctx.JSON(http.StatusForbidden, private.Response{
+						Err: fmt.Sprintf("branch %s is protected from changing file %s", branchName, protectedFilePath),
 					})
 					return
 				}
 
 				// Or we're simply not able to push to this protected branch
 				log.Warn("Forbidden: User %d is not allowed to push to protected branch: %s in %-v", opts.UserID, branchName, repo)
-				ctx.JSON(http.StatusForbidden, map[string]interface{}{
-					"err": fmt.Sprintf("Not allowed to push to protected branch %s", branchName),
+				ctx.JSON(http.StatusForbidden, private.Response{
+					Err: fmt.Sprintf("Not allowed to push to protected branch %s", branchName),
 				})
 				return
 			}
@@ -295,24 +295,24 @@ func HookPreReceive(ctx *gitea_context.PrivateContext) {
 			pr, err := models.GetPullRequestByID(opts.PullRequestID)
 			if err != nil {
 				log.Error("Unable to get PullRequest %d Error: %v", opts.PullRequestID, err)
-				ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-					"err": fmt.Sprintf("Unable to get PullRequest %d Error: %v", opts.PullRequestID, err),
+				ctx.JSON(http.StatusInternalServerError, private.Response{
+					Err: fmt.Sprintf("Unable to get PullRequest %d Error: %v", opts.PullRequestID, err),
 				})
 				return
 			}
 			user, err := models.GetUserByID(opts.UserID)
 			if err != nil {
 				log.Error("Unable to get User id %d Error: %v", opts.UserID, err)
-				ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-					"err": fmt.Sprintf("Unable to get User id %d Error: %v", opts.UserID, err),
+				ctx.JSON(http.StatusInternalServerError, private.Response{
+					Err: fmt.Sprintf("Unable to get User id %d Error: %v", opts.UserID, err),
 				})
 				return
 			}
 			perm, err := models.GetUserRepoPermission(repo, user)
 			if err != nil {
 				log.Error("Unable to get Repo permission of repo %s/%s of User %s", repo.OwnerName, repo.Name, user.Name, err)
-				ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-					"err": fmt.Sprintf("Unable to get Repo permission of repo %s/%s of User %s: %v", repo.OwnerName, repo.Name, user.Name, err),
+				ctx.JSON(http.StatusInternalServerError, private.Response{
+					Err: fmt.Sprintf("Unable to get Repo permission of repo %s/%s of User %s: %v", repo.OwnerName, repo.Name, user.Name, err),
 				})
 				return
 			}
@@ -321,16 +321,16 @@ func HookPreReceive(ctx *gitea_context.PrivateContext) {
 			allowedMerge, err := pull_service.IsUserAllowedToMerge(pr, perm, user)
 			if err != nil {
 				log.Error("Error calculating if allowed to merge: %v", err)
-				ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-					"err": fmt.Sprintf("Error calculating if allowed to merge: %v", err),
+				ctx.JSON(http.StatusInternalServerError, private.Response{
+					Err: fmt.Sprintf("Error calculating if allowed to merge: %v", err),
 				})
 				return
 			}
 
 			if !allowedMerge {
 				log.Warn("Forbidden: User %d is not allowed to push to protected branch: %s in %-v and is not allowed to merge pr #%d", opts.UserID, branchName, repo, pr.Index)
-				ctx.JSON(http.StatusForbidden, map[string]interface{}{
-					"err": fmt.Sprintf("Not allowed to push to protected branch %s", branchName),
+				ctx.JSON(http.StatusForbidden, private.Response{
+					Err: fmt.Sprintf("Not allowed to push to protected branch %s", branchName),
 				})
 				return
 			}
@@ -343,8 +343,8 @@ func HookPreReceive(ctx *gitea_context.PrivateContext) {
 			// Now if we're not an admin - we can't overwrite protected files so fail now
 			if changedProtectedfiles {
 				log.Warn("Forbidden: Branch: %s in %-v is protected from changing file %s", branchName, repo, protectedFilePath)
-				ctx.JSON(http.StatusForbidden, map[string]interface{}{
-					"err": fmt.Sprintf("branch %s is protected from changing file %s", branchName, protectedFilePath),
+				ctx.JSON(http.StatusForbidden, private.Response{
+					Err: fmt.Sprintf("branch %s is protected from changing file %s", branchName, protectedFilePath),
 				})
 				return
 			}
@@ -353,14 +353,14 @@ func HookPreReceive(ctx *gitea_context.PrivateContext) {
 			if err := pull_service.CheckPRReadyToMerge(pr, true); err != nil {
 				if models.IsErrNotAllowedToMerge(err) {
 					log.Warn("Forbidden: User %d is not allowed push to protected branch %s in %-v and pr #%d is not ready to be merged: %s", opts.UserID, branchName, repo, pr.Index, err.Error())
-					ctx.JSON(http.StatusForbidden, map[string]interface{}{
-						"err": fmt.Sprintf("Not allowed to push to protected branch %s and pr #%d is not ready to be merged: %s", branchName, opts.PullRequestID, err.Error()),
+					ctx.JSON(http.StatusForbidden, private.Response{
+						Err: fmt.Sprintf("Not allowed to push to protected branch %s and pr #%d is not ready to be merged: %s", branchName, opts.PullRequestID, err.Error()),
 					})
 					return
 				}
 				log.Error("Unable to check if mergable: protected branch %s in %-v and pr #%d. Error: %v", opts.UserID, branchName, repo, pr.Index, err)
-				ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-					"err": fmt.Sprintf("Unable to get status of pull request %d. Error: %v", opts.PullRequestID, err),
+				ctx.JSON(http.StatusInternalServerError, private.Response{
+					Err: fmt.Sprintf("Unable to get status of pull request %d. Error: %v", opts.PullRequestID, err),
 				})
 				return
 			}
@@ -549,8 +549,8 @@ func SetDefaultBranch(ctx *gitea_context.PrivateContext) {
 	repo, err := models.GetRepositoryByOwnerAndName(ownerName, repoName)
 	if err != nil {
 		log.Error("Failed to get repository: %s/%s Error: %v", ownerName, repoName, err)
-		ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Err": fmt.Sprintf("Failed to get repository: %s/%s Error: %v", ownerName, repoName, err),
+		ctx.JSON(http.StatusInternalServerError, private.Response{
+			Err: fmt.Sprintf("Failed to get repository: %s/%s Error: %v", ownerName, repoName, err),
 		})
 		return
 	}
@@ -561,25 +561,25 @@ func SetDefaultBranch(ctx *gitea_context.PrivateContext) {
 	repo.DefaultBranch = branch
 	gitRepo, err := git.OpenRepository(repo.RepoPath())
 	if err != nil {
-		ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Err": fmt.Sprintf("Failed to get git repository: %s/%s Error: %v", ownerName, repoName, err),
+		ctx.JSON(http.StatusInternalServerError, private.Response{
+			Err: fmt.Sprintf("Failed to get git repository: %s/%s Error: %v", ownerName, repoName, err),
 		})
 		return
 	}
 	if err := gitRepo.SetDefaultBranch(repo.DefaultBranch); err != nil {
 		if !git.IsErrUnsupportedVersion(err) {
 			gitRepo.Close()
-			ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-				"Err": fmt.Sprintf("Unable to set default branch on repository: %s/%s Error: %v", ownerName, repoName, err),
+			ctx.JSON(http.StatusInternalServerError, private.Response{
+				Err: fmt.Sprintf("Unable to set default branch on repository: %s/%s Error: %v", ownerName, repoName, err),
 			})
 			return
 		}
 	}
 	gitRepo.Close()
 
 	if err := repo.UpdateDefaultBranch(); err != nil {
-		ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Err": fmt.Sprintf("Unable to set default branch on repository: %s/%s Error: %v", ownerName, repoName, err),
+		ctx.JSON(http.StatusInternalServerError, private.Response{
+			Err: fmt.Sprintf("Unable to set default branch on repository: %s/%s Error: %v", ownerName, repoName, err),
 		})
 		return
 	}

routers/private/key.go

@@ -10,6 +10,7 @@ import (
 
 	"code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/modules/context"
+	"code.gitea.io/gitea/modules/private"
 	"code.gitea.io/gitea/modules/timeutil"
 )
 
@@ -18,8 +19,8 @@ func UpdatePublicKeyInRepo(ctx *context.PrivateContext) {
 	keyID := ctx.ParamsInt64(":id")
 	repoID := ctx.ParamsInt64(":repoid")
 	if err := models.UpdatePublicKeyUpdated(keyID); err != nil {
-		ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"err": err.Error(),
+		ctx.JSON(http.StatusInternalServerError, private.Response{
+			Err: err.Error(),
 		})
 		return
 	}
@@ -30,15 +31,15 @@ func UpdatePublicKeyInRepo(ctx *context.PrivateContext) {
 			ctx.PlainText(http.StatusOK, []byte("success"))
 			return
 		}
-		ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"err": err.Error(),
+		ctx.JSON(http.StatusInternalServerError, private.Response{
+			Err: err.Error(),
 		})
 		return
 	}
 	deployKey.UpdatedUnix = timeutil.TimeStampNow()
 	if err = models.UpdateDeployKeyCols(deployKey, "updated_unix"); err != nil {
-		ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"err": err.Error(),
+		ctx.JSON(http.StatusInternalServerError, private.Response{
+			Err: err.Error(),
 		})
 		return
 	}
@@ -53,8 +54,8 @@ func AuthorizedPublicKeyByContent(ctx *context.PrivateContext) {
 
 	publicKey, err := models.SearchPublicKeyByContent(content)
 	if err != nil {
-		ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"err": err.Error(),
+		ctx.JSON(http.StatusInternalServerError, private.Response{
+			Err: err.Error(),
 		})
 		return
 	}

routers/private/mail.go

@@ -23,8 +23,8 @@ import (
 // It doesn't wait before each message will be processed
 func SendEmail(ctx *context.PrivateContext) {
 	if setting.MailService == nil {
-		ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"err": "Mail service is not enabled.",
+		ctx.JSON(http.StatusInternalServerError, private.Response{
+			Err: "Mail service is not enabled.",
 		})
 		return
 	}
@@ -35,8 +35,8 @@ func SendEmail(ctx *context.PrivateContext) {
 	json := jsoniter.ConfigCompatibleWithStandardLibrary
 	if err := json.NewDecoder(rd).Decode(&mail); err != nil {
 		log.Error("%v", err)
-		ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"err": err,
+		ctx.JSON(http.StatusInternalServerError, private.Response{
+			Err: err.Error(),
 		})
 		return
 	}
@@ -48,8 +48,8 @@ func SendEmail(ctx *context.PrivateContext) {
 			if err != nil {
 				err := fmt.Sprintf("Failed to get user information: %v", err)
 				log.Error(err)
-				ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-					"err": err,
+				ctx.JSON(http.StatusInternalServerError, private.Response{
+					Err: err,
 				})
 				return
 			}
@@ -68,8 +68,8 @@ func SendEmail(ctx *context.PrivateContext) {
 		if err != nil {
 			err := fmt.Sprintf("Failed to find users: %v", err)
 			log.Error(err)
-			ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-				"err": err,
+			ctx.JSON(http.StatusInternalServerError, private.Response{
+				Err: err,
 			})
 			return
 		}