diff --git a/src/main/scala/gitbucket/core/controller/AccountController.scala b/src/main/scala/gitbucket/core/controller/AccountController.scala index f861b40..660f5da 100644 --- a/src/main/scala/gitbucket/core/controller/AccountController.scala +++ b/src/main/scala/gitbucket/core/controller/AccountController.scala @@ -629,7 +629,9 @@ } get("/groups/new")(usersOnly { - html.creategroup(List(GroupMember("", context.loginAccount.get.userName, true))) + context.withLoginAccount { loginAccount => + html.creategroup(List(GroupMember("", loginAccount.userName, true))) + } }) post("/groups/new", newGroupForm)(usersOnly { form => @@ -716,83 +718,92 @@ * Show the new repository form. */ get("/new")(usersOnly { - html.newrepo(getGroupsByUserName(context.loginAccount.get.userName), context.settings.isCreateRepoOptionPublic) + context.withLoginAccount { loginAccount => + html.newrepo(getGroupsByUserName(loginAccount.userName), context.settings.isCreateRepoOptionPublic) + } }) /** * Create new repository. */ post("/new", newRepositoryForm)(usersOnly { form => - if (context.settings.repositoryOperation.create || context.loginAccount.get.isAdmin) { - LockUtil.lock(s"${form.owner}/${form.name}") { - if (getRepository(form.owner, form.name).isDefined) { - // redirect to the repository if repository already exists - redirect(s"/${form.owner}/${form.name}") - } else if (!canCreateRepository(form.owner, context.loginAccount.get)) { - // Permission error - Forbidden() - } else { - // create repository asynchronously - createRepository( - context.loginAccount.get, - form.owner, - form.name, - form.description, - form.isPrivate, - form.initOption, - form.sourceUrl - ) - // redirect to the repository - redirect(s"/${form.owner}/${form.name}") - } - } - } else Forbidden() + context.withLoginAccount { + loginAccount => + if (context.settings.repositoryOperation.create || loginAccount.isAdmin) { + LockUtil.lock(s"${form.owner}/${form.name}") { + if (getRepository(form.owner, form.name).isDefined) { + // redirect to the repository if repository already exists + redirect(s"/${form.owner}/${form.name}") + } else if (!canCreateRepository(form.owner, loginAccount)) { + // Permission error + Forbidden() + } else { + // create repository asynchronously + createRepository( + loginAccount, + form.owner, + form.name, + form.description, + form.isPrivate, + form.initOption, + form.sourceUrl + ) + // redirect to the repository + redirect(s"/${form.owner}/${form.name}") + } + } + } else Forbidden() + } }) get("/:owner/:repository/fork")(readableUsersOnly { repository => - val loginAccount = context.loginAccount.get - if (repository.repository.options.allowFork && (context.settings.repositoryOperation.fork || loginAccount.isAdmin)) { - val loginUserName = loginAccount.userName - val groups = getGroupsByUserName(loginUserName) - groups match { - case _: List[String] => - val managerPermissions = groups.map { group => - val members = getGroupMembers(group) - context.loginAccount.exists( - x => - members.exists { member => - member.userName == x.userName && member.isManager + context.withLoginAccount { + loginAccount => + if (repository.repository.options.allowFork && (context.settings.repositoryOperation.fork || loginAccount.isAdmin)) { + val loginUserName = loginAccount.userName + val groups = getGroupsByUserName(loginUserName) + groups match { + case _: List[String] => + val managerPermissions = groups.map { group => + val members = getGroupMembers(group) + context.loginAccount.exists( + x => + members.exists { member => + member.userName == x.userName && member.isManager + } + ) } - ) + helper.html.forkrepository( + repository, + (groups zip managerPermissions).sortBy(_._1) + ) + case _ => redirect(s"/${loginUserName}") } - helper.html.forkrepository( - repository, - (groups zip managerPermissions).sortBy(_._1) - ) - case _ => redirect(s"/${loginUserName}") - } - } else BadRequest() + } else BadRequest() + } }) post("/:owner/:repository/fork", accountForm)(readableUsersOnly { (form, repository) => - val loginAccount = context.loginAccount.get - if (repository.repository.options.allowFork && (context.settings.repositoryOperation.fork || loginAccount.isAdmin)) { - val loginUserName = loginAccount.userName - val accountName = form.accountName + context.withLoginAccount { + loginAccount => + if (repository.repository.options.allowFork && (context.settings.repositoryOperation.fork || loginAccount.isAdmin)) { + val loginUserName = loginAccount.userName + val accountName = form.accountName - if (getRepository(accountName, repository.name).isDefined) { - // redirect to the repository if repository already exists - redirect(s"/${accountName}/${repository.name}") - } else if (!canCreateRepository(accountName, loginAccount)) { - // Permission error - Forbidden() - } else { - // fork repository asynchronously - forkRepository(accountName, repository, loginUserName) - // redirect to the repository - redirect(s"/${accountName}/${repository.name}") - } - } else Forbidden() + if (getRepository(accountName, repository.name).isDefined) { + // redirect to the repository if repository already exists + redirect(s"/${accountName}/${repository.name}") + } else if (!canCreateRepository(accountName, loginAccount)) { + // Permission error + Forbidden() + } else { + // fork repository asynchronously + forkRepository(accountName, repository, loginUserName) + // redirect to the repository + redirect(s"/${accountName}/${repository.name}") + } + } else Forbidden() + } }) private def existsAccount: Constraint = new Constraint() { diff --git a/src/main/scala/gitbucket/core/controller/ControllerBase.scala b/src/main/scala/gitbucket/core/controller/ControllerBase.scala index dce356c..28c4673 100644 --- a/src/main/scala/gitbucket/core/controller/ControllerBase.scala +++ b/src/main/scala/gitbucket/core/controller/ControllerBase.scala @@ -303,6 +303,13 @@ } val sidebarCollapse = request.getSession.getAttribute("sidebar-collapse") != null + def withLoginAccount(f: Account => Any): Any = { + loginAccount match { + case Some(loginAccount) => f(loginAccount) + case None => Unauthorized() + } + } + /** * Get object from cache. * diff --git a/src/main/scala/gitbucket/core/controller/DashboardController.scala b/src/main/scala/gitbucket/core/controller/DashboardController.scala index ae86de4..576619f 100644 --- a/src/main/scala/gitbucket/core/controller/DashboardController.scala +++ b/src/main/scala/gitbucket/core/controller/DashboardController.scala @@ -1,6 +1,7 @@ package gitbucket.core.controller import gitbucket.core.dashboard.html +import gitbucket.core.model.Account import gitbucket.core.service._ import gitbucket.core.util.{Keys, UsersAuthenticator} import gitbucket.core.util.Implicits._ @@ -34,45 +35,63 @@ with UsersAuthenticator => get("/dashboard/repos")(usersOnly { - val repos = getVisibleRepositories( - context.loginAccount, - None, - withoutPhysicalInfo = true, - limit = context.settings.limitVisibleRepositories - ) - html.repos(getGroupNames(context.loginAccount.get.userName), repos, repos) + context.withLoginAccount { loginAccount => + val repos = getVisibleRepositories( + context.loginAccount, + None, + withoutPhysicalInfo = true, + limit = context.settings.limitVisibleRepositories + ) + html.repos(getGroupNames(loginAccount.userName), repos, repos) + } }) get("/dashboard/issues")(usersOnly { - searchIssues("created_by") + context.withLoginAccount { loginAccount => + searchIssues(loginAccount, "created_by") + } }) get("/dashboard/issues/assigned")(usersOnly { - searchIssues("assigned") + context.withLoginAccount { loginAccount => + searchIssues(loginAccount, "assigned") + } }) get("/dashboard/issues/created_by")(usersOnly { - searchIssues("created_by") + context.withLoginAccount { loginAccount => + searchIssues(loginAccount, "created_by") + } }) get("/dashboard/issues/mentioned")(usersOnly { - searchIssues("mentioned") + context.withLoginAccount { loginAccount => + searchIssues(loginAccount, "mentioned") + } }) get("/dashboard/pulls")(usersOnly { - searchPullRequests("created_by") + context.withLoginAccount { loginAccount => + searchPullRequests(loginAccount, "created_by") + } }) get("/dashboard/pulls/created_by")(usersOnly { - searchPullRequests("created_by") + context.withLoginAccount { loginAccount => + searchPullRequests(loginAccount, "created_by") + } }) get("/dashboard/pulls/assigned")(usersOnly { - searchPullRequests("assigned") + context.withLoginAccount { loginAccount => + searchPullRequests(loginAccount, "assigned") + } }) get("/dashboard/pulls/mentioned")(usersOnly { - searchPullRequests("mentioned") + context.withLoginAccount { loginAccount => + searchPullRequests(loginAccount, "mentioned") + } }) private def getOrCreateCondition(key: String, filter: String, userName: String) = { @@ -85,10 +104,10 @@ } } - private def searchIssues(filter: String) = { + private def searchIssues(loginAccount: Account, filter: String) = { import IssuesService._ - val userName = context.loginAccount.get.userName + val userName = loginAccount.userName val condition = getOrCreateCondition(Keys.Session.DashboardIssues, filter, userName) val userRepos = getUserRepositories(userName, true).map(repo => repo.owner -> repo.name) val page = IssueSearchCondition.page(request) @@ -115,11 +134,11 @@ ) } - private def searchPullRequests(filter: String) = { + private def searchPullRequests(loginAccount: Account, filter: String) = { import IssuesService._ import PullRequestService._ - val userName = context.loginAccount.get.userName + val userName = loginAccount.userName val condition = getOrCreateCondition(Keys.Session.DashboardPulls, filter, userName) val allRepos = getAllRepositories(userName) val page = IssueSearchCondition.page(request) diff --git a/src/main/scala/gitbucket/core/controller/IssuesController.scala b/src/main/scala/gitbucket/core/controller/IssuesController.scala index 5732424..12908d1 100644 --- a/src/main/scala/gitbucket/core/controller/IssuesController.scala +++ b/src/main/scala/gitbucket/core/controller/IssuesController.scala @@ -1,6 +1,7 @@ package gitbucket.core.controller import gitbucket.core.issues.html +import gitbucket.core.model.Account import gitbucket.core.service.IssuesService._ import gitbucket.core.service._ import gitbucket.core.util.SyntaxSugars._ @@ -95,212 +96,224 @@ }) get("/:owner/:repository/issues/:id")(referrersOnly { repository => - defining(repository.owner, repository.name, params("id")) { - case (owner, name, issueId) => - getIssue(owner, name, issueId) map { - issue => - if (issue.isPullRequest) { - redirect(s"/${repository.owner}/${repository.name}/pull/${issueId}") - } else { - html.issue( - issue, - getComments(owner, name, issueId.toInt), - getIssueLabels(owner, name, issueId.toInt), - getAssignableUserNames(owner, name), - getMilestonesWithIssueCount(owner, name), - getPriorities(owner, name), - getLabels(owner, name), - isIssueEditable(repository), - isIssueManageable(repository), - isIssueCommentManageable(repository), - repository - ) - } - } getOrElse NotFound() - } + val issueId = params("id") + getIssue(repository.owner, repository.name, issueId) map { + issue => + if (issue.isPullRequest) { + redirect(s"/${repository.owner}/${repository.name}/pull/${issueId}") + } else { + html.issue( + issue, + getComments(repository.owner, repository.name, issueId.toInt), + getIssueLabels(repository.owner, repository.name, issueId.toInt), + getAssignableUserNames(repository.owner, repository.name), + getMilestonesWithIssueCount(repository.owner, repository.name), + getPriorities(repository.owner, repository.name), + getLabels(repository.owner, repository.name), + isIssueEditable(repository), + isIssueManageable(repository), + isIssueCommentManageable(repository), + repository + ) + } + } getOrElse NotFound() }) get("/:owner/:repository/issues/new")(readableUsersOnly { repository => if (isIssueEditable(repository)) { // TODO Should this check is provided by authenticator? - defining(repository.owner, repository.name) { - case (owner, name) => - html.create( - getAssignableUserNames(owner, name), - getMilestones(owner, name), - getPriorities(owner, name), - getDefaultPriority(owner, name), - getLabels(owner, name), - isIssueManageable(repository), - getContentTemplate(repository, "ISSUE_TEMPLATE"), - repository - ) - } + html.create( + getAssignableUserNames(repository.owner, repository.name), + getMilestones(repository.owner, repository.name), + getPriorities(repository.owner, repository.name), + getDefaultPriority(repository.owner, repository.name), + getLabels(repository.owner, repository.name), + isIssueManageable(repository), + getContentTemplate(repository, "ISSUE_TEMPLATE"), + repository + ) } else Unauthorized() }) post("/:owner/:repository/issues/new", issueCreateForm)(readableUsersOnly { (form, repository) => - if (isIssueEditable(repository)) { // TODO Should this check is provided by authenticator? - val issue = createIssue( - repository, - form.title, - form.content, - form.assignedUserName, - form.milestoneId, - form.priorityId, - form.labelNames.toSeq.flatMap(_.split(",")), - context.loginAccount.get - ) - - redirect(s"/${issue.userName}/${issue.repositoryName}/issues/${issue.issueId}") - } else Unauthorized() + context.withLoginAccount { + loginAccount => + if (isIssueEditable(repository)) { // TODO Should this check is provided by authenticator? + val issue = createIssue( + repository, + form.title, + form.content, + form.assignedUserName, + form.milestoneId, + form.priorityId, + form.labelNames.toSeq.flatMap(_.split(",")), + loginAccount + ) + redirect(s"/${issue.userName}/${issue.repositoryName}/issues/${issue.issueId}") + } else Unauthorized() + } }) ajaxPost("/:owner/:repository/issues/edit_title/:id", issueTitleEditForm)(readableUsersOnly { (title, repository) => - defining(repository.owner, repository.name) { - case (owner, name) => - getIssue(owner, name, params("id")).map { + context.withLoginAccount { + loginAccount => + getIssue(repository.owner, repository.name, params("id")).map { issue => - if (isEditableContent(owner, name, issue.openedUserName)) { + if (isEditableContent(repository.owner, repository.name, issue.openedUserName, loginAccount)) { if (issue.title != title) { // update issue - updateIssue(owner, name, issue.issueId, title, issue.content) + updateIssue(repository.owner, repository.name, issue.issueId, title, issue.content) // extract references and create refer comment - createReferComment(owner, name, issue.copy(title = title), title, context.loginAccount.get) + createReferComment(repository.owner, repository.name, issue.copy(title = title), title, loginAccount) createComment( - owner, - name, - context.loginAccount.get.userName, + repository.owner, + repository.name, + loginAccount.userName, issue.issueId, issue.title + "\r\n" + title, "change_title" ) } - redirect(s"/${owner}/${name}/issues/_data/${issue.issueId}") + redirect(s"/${repository.owner}/${repository.name}/issues/_data/${issue.issueId}") } else Unauthorized() } getOrElse NotFound() } }) ajaxPost("/:owner/:repository/issues/edit/:id", issueEditForm)(readableUsersOnly { (content, repository) => - defining(repository.owner, repository.name) { - case (owner, name) => - getIssue(owner, name, params("id")).map { issue => - if (isEditableContent(owner, name, issue.openedUserName)) { + context.withLoginAccount { + loginAccount => + getIssue(repository.owner, repository.name, params("id")).map { issue => + if (isEditableContent(repository.owner, repository.name, issue.openedUserName, loginAccount)) { // update issue - updateIssue(owner, name, issue.issueId, issue.title, content) + updateIssue(repository.owner, repository.name, issue.issueId, issue.title, content) // extract references and create refer comment - createReferComment(owner, name, issue, content.getOrElse(""), context.loginAccount.get) + createReferComment(repository.owner, repository.name, issue, content.getOrElse(""), loginAccount) - redirect(s"/${owner}/${name}/issues/_data/${issue.issueId}") + redirect(s"/${repository.owner}/${repository.name}/issues/_data/${issue.issueId}") } else Unauthorized() } getOrElse NotFound() } }) post("/:owner/:repository/issue_comments/new", commentForm)(readableUsersOnly { (form, repository) => - getIssue(repository.owner, repository.name, form.issueId.toString).flatMap { issue => - val actionOpt = - params.get("action").filter(_ => isEditableContent(issue.userName, issue.repositoryName, issue.openedUserName)) - handleComment(issue, Some(form.content), repository, actionOpt) map { - case (issue, id) => - redirect( - s"/${repository.owner}/${repository.name}/${if (issue.isPullRequest) "pull" else "issues"}/${form.issueId}#comment-${id}" - ) - } - } getOrElse NotFound() + context.withLoginAccount { + loginAccount => + getIssue(repository.owner, repository.name, form.issueId.toString).flatMap { issue => + val actionOpt = + params + .get("action") + .filter(_ => isEditableContent(issue.userName, issue.repositoryName, issue.openedUserName, loginAccount)) + handleComment(issue, Some(form.content), repository, actionOpt) map { + case (issue, id) => + redirect( + s"/${repository.owner}/${repository.name}/${if (issue.isPullRequest) "pull" else "issues"}/${form.issueId}#comment-${id}" + ) + } + } getOrElse NotFound() + } }) post("/:owner/:repository/issue_comments/state", issueStateForm)(readableUsersOnly { (form, repository) => - getIssue(repository.owner, repository.name, form.issueId.toString).flatMap { issue => - val actionOpt = - params.get("action").filter(_ => isEditableContent(issue.userName, issue.repositoryName, issue.openedUserName)) - handleComment(issue, form.content, repository, actionOpt) map { - case (issue, id) => - redirect( - s"/${repository.owner}/${repository.name}/${if (issue.isPullRequest) "pull" else "issues"}/${form.issueId}#comment-${id}" - ) - } - } getOrElse NotFound() + context.withLoginAccount { + loginAccount => + getIssue(repository.owner, repository.name, form.issueId.toString).flatMap { issue => + val actionOpt = + params + .get("action") + .filter(_ => isEditableContent(issue.userName, issue.repositoryName, issue.openedUserName, loginAccount)) + handleComment(issue, form.content, repository, actionOpt) map { + case (issue, id) => + redirect( + s"/${repository.owner}/${repository.name}/${if (issue.isPullRequest) "pull" else "issues"}/${form.issueId}#comment-${id}" + ) + } + } getOrElse NotFound() + } }) ajaxPost("/:owner/:repository/issue_comments/edit/:id", commentForm)(readableUsersOnly { (form, repository) => - defining(repository.owner, repository.name) { - case (owner, name) => - getComment(owner, name, params("id")).map { comment => - if (isEditableContent(owner, name, comment.commentedUserName)) { + context.withLoginAccount { + loginAccount => + getComment(repository.owner, repository.name, params("id")).map { comment => + if (isEditableContent(repository.owner, repository.name, comment.commentedUserName, loginAccount)) { updateComment(comment.issueId, comment.commentId, form.content) - redirect(s"/${owner}/${name}/issue_comments/_data/${comment.commentId}") + redirect(s"/${repository.owner}/${repository.name}/issue_comments/_data/${comment.commentId}") } else Unauthorized() } getOrElse NotFound() } }) ajaxPost("/:owner/:repository/issue_comments/delete/:id")(readableUsersOnly { repository => - defining(repository.owner, repository.name) { - case (owner, name) => - getComment(owner, name, params("id")).map { comment => - if (isDeletableComment(owner, name, comment.commentedUserName)) { - Ok(deleteComment(repository.owner, repository.name, comment.issueId, comment.commentId)) - } else Unauthorized() - } getOrElse NotFound() + context.withLoginAccount { loginAccount => + getComment(repository.owner, repository.name, params("id")).map { comment => + if (isDeletableComment(repository.owner, repository.name, comment.commentedUserName, loginAccount)) { + Ok(deleteComment(repository.owner, repository.name, comment.issueId, comment.commentId)) + } else Unauthorized() + } getOrElse NotFound() } }) ajaxGet("/:owner/:repository/issues/_data/:id")(readableUsersOnly { repository => - getIssue(repository.owner, repository.name, params("id")) map { - x => - if (isEditableContent(x.userName, x.repositoryName, x.openedUserName)) { - params.get("dataType") collect { - case t if t == "html" => html.editissue(x.content, x.issueId, repository) - } getOrElse { - contentType = formats("json") - org.json4s.jackson.Serialization.write( - Map( - "title" -> x.title, - "content" -> Markdown.toHtml( - markdown = x.content getOrElse "No description given.", - repository = repository, - branch = repository.repository.defaultBranch, - enableWikiLink = false, - enableRefsLink = true, - enableAnchor = true, - enableLineBreaks = true, - enableTaskList = true, - hasWritePermission = true + context.withLoginAccount { + loginAccount => + getIssue(repository.owner, repository.name, params("id")) map { + x => + if (isEditableContent(x.userName, x.repositoryName, x.openedUserName, loginAccount)) { + params.get("dataType") collect { + case t if t == "html" => html.editissue(x.content, x.issueId, repository) + } getOrElse { + contentType = formats("json") + org.json4s.jackson.Serialization.write( + Map( + "title" -> x.title, + "content" -> Markdown.toHtml( + markdown = x.content getOrElse "No description given.", + repository = repository, + branch = repository.repository.defaultBranch, + enableWikiLink = false, + enableRefsLink = true, + enableAnchor = true, + enableLineBreaks = true, + enableTaskList = true, + hasWritePermission = true + ) + ) ) - ) - ) - } - } else Unauthorized() - } getOrElse NotFound() + } + } else Unauthorized() + } getOrElse NotFound() + } }) ajaxGet("/:owner/:repository/issue_comments/_data/:id")(readableUsersOnly { repository => - getComment(repository.owner, repository.name, params("id")) map { - x => - if (isEditableContent(x.userName, x.repositoryName, x.commentedUserName)) { - params.get("dataType") collect { - case t if t == "html" => html.editcomment(x.content, x.commentId, repository) - } getOrElse { - contentType = formats("json") - org.json4s.jackson.Serialization.write( - Map( - "content" -> view.Markdown.toHtml( - markdown = x.content, - repository = repository, - branch = repository.repository.defaultBranch, - enableWikiLink = false, - enableRefsLink = true, - enableAnchor = true, - enableLineBreaks = true, - enableTaskList = true, - hasWritePermission = true + context.withLoginAccount { + loginAccount => + getComment(repository.owner, repository.name, params("id")) map { + x => + if (isEditableContent(x.userName, x.repositoryName, x.commentedUserName, loginAccount)) { + params.get("dataType") collect { + case t if t == "html" => html.editcomment(x.content, x.commentId, repository) + } getOrElse { + contentType = formats("json") + org.json4s.jackson.Serialization.write( + Map( + "content" -> view.Markdown.toHtml( + markdown = x.content, + repository = repository, + branch = repository.repository.defaultBranch, + enableWikiLink = false, + enableRefsLink = true, + enableAnchor = true, + enableLineBreaks = true, + enableTaskList = true, + hasWritePermission = true + ) + ) ) - ) - ) - } - } else Unauthorized() - } getOrElse NotFound() + } + } else Unauthorized() + } getOrElse NotFound() + } }) ajaxPost("/:owner/:repository/issues/new/label")(writableUsersOnly { repository => @@ -353,26 +366,27 @@ }) post("/:owner/:repository/issues/batchedit/state")(writableUsersOnly { repository => - defining(params.get("value")) { - action => - action match { - case Some("open") => - executeBatch(repository) { issueId => - getIssue(repository.owner, repository.name, issueId.toString).foreach { issue => - handleComment(issue, None, repository, Some("reopen")) - } - } - case Some("close") => - executeBatch(repository) { issueId => - getIssue(repository.owner, repository.name, issueId.toString).foreach { issue => - handleComment(issue, None, repository, Some("close")) - } - } - case _ => BadRequest() + val action = params.get("value") + action match { + case Some("open") => + executeBatch(repository) { issueId => + getIssue(repository.owner, repository.name, issueId.toString).foreach { issue => + handleComment(issue, None, repository, Some("reopen")) + } } if (params("uri").nonEmpty) { redirect(params("uri")) } + case Some("close") => + executeBatch(repository) { issueId => + getIssue(repository.owner, repository.name, issueId.toString).foreach { issue => + handleComment(issue, None, repository, Some("close")) + } + } + if (params("uri").nonEmpty) { + redirect(params("uri")) + } + case _ => BadRequest() } }) @@ -390,29 +404,26 @@ }) post("/:owner/:repository/issues/batchedit/assign")(writableUsersOnly { repository => - defining(assignedUserName("value")) { value => - executeBatch(repository) { - updateAssignedUserName(repository.owner, repository.name, _, value, true) - } - if (params("uri").nonEmpty) { - redirect(params("uri")) - } + val value = assignedUserName("value") + executeBatch(repository) { + updateAssignedUserName(repository.owner, repository.name, _, value, true) + } + if (params("uri").nonEmpty) { + redirect(params("uri")) } }) post("/:owner/:repository/issues/batchedit/milestone")(writableUsersOnly { repository => - defining(milestoneId("value")) { value => - executeBatch(repository) { - updateMilestoneId(repository.owner, repository.name, _, value, true) - } + val value = milestoneId("value") + executeBatch(repository) { + updateMilestoneId(repository.owner, repository.name, _, value, true) } }) post("/:owner/:repository/issues/batchedit/priority")(writableUsersOnly { repository => - defining(priorityId("value")) { value => - executeBatch(repository) { - updatePriorityId(repository.owner, repository.name, _, value, true) - } + val value = priorityId("value") + executeBatch(repository) { + updatePriorityId(repository.owner, repository.name, _, value, true) } }) @@ -464,48 +475,51 @@ } private def searchIssues(repository: RepositoryService.RepositoryInfo) = { - defining(repository.owner, repository.name) { - case (owner, repoName) => - val page = IssueSearchCondition.page(request) - // retrieve search condition - val condition = IssueSearchCondition(request) - // search issues - val issues = - searchIssue(condition, IssueSearchOption.Issues, (page - 1) * IssueLimit, IssueLimit, owner -> repoName) + val page = IssueSearchCondition.page(request) + // retrieve search condition + val condition = IssueSearchCondition(request) + // search issues + val issues = + searchIssue( + condition, + IssueSearchOption.Issues, + (page - 1) * IssueLimit, + IssueLimit, + repository.owner -> repository.name + ) - html.list( - "issues", - issues.map(issue => (issue, None)), - page, - getAssignableUserNames(owner, repoName), - getMilestones(owner, repoName), - getPriorities(owner, repoName), - getLabels(owner, repoName), - countIssue(condition.copy(state = "open"), IssueSearchOption.Issues, owner -> repoName), - countIssue(condition.copy(state = "closed"), IssueSearchOption.Issues, owner -> repoName), - condition, - repository, - isIssueEditable(repository), - isIssueManageable(repository) - ) - } + html.list( + "issues", + issues.map(issue => (issue, None)), + page, + getAssignableUserNames(repository.owner, repository.name), + getMilestones(repository.owner, repository.name), + getPriorities(repository.owner, repository.name), + getLabels(repository.owner, repository.name), + countIssue(condition.copy(state = "open"), IssueSearchOption.Issues, repository.owner -> repository.name), + countIssue(condition.copy(state = "closed"), IssueSearchOption.Issues, repository.owner -> repository.name), + condition, + repository, + isIssueEditable(repository), + isIssueManageable(repository) + ) } /** * Tests whether an issue or a comment is editable by a logged-in user. */ - private def isEditableContent(owner: String, repository: String, author: String)( + private def isEditableContent(owner: String, repository: String, author: String, loginAccount: Account)( implicit context: Context ): Boolean = { - hasDeveloperRole(owner, repository, context.loginAccount) || author == context.loginAccount.get.userName + hasDeveloperRole(owner, repository, context.loginAccount) || author == loginAccount.userName } /** * Tests whether an issue comment is deletable by a logged-in user. */ - private def isDeletableComment(owner: String, repository: String, author: String)( + private def isDeletableComment(owner: String, repository: String, author: String, loginAccount: Account)( implicit context: Context ): Boolean = { - hasOwnerRole(owner, repository, context.loginAccount) || author == context.loginAccount.get.userName + hasOwnerRole(owner, repository, context.loginAccount) || author == loginAccount.userName } } diff --git a/src/main/scala/gitbucket/core/controller/PullRequestsController.scala b/src/main/scala/gitbucket/core/controller/PullRequestsController.scala index 3b1377a..96c6747 100644 --- a/src/main/scala/gitbucket/core/controller/PullRequestsController.scala +++ b/src/main/scala/gitbucket/core/controller/PullRequestsController.scala @@ -8,7 +8,6 @@ import gitbucket.core.service.PullRequestService._ import gitbucket.core.service.RepositoryService.RepositoryInfo import gitbucket.core.service._ -import gitbucket.core.util.SyntaxSugars._ import gitbucket.core.util.Directory._ import gitbucket.core.util.Implicits._ import gitbucket.core.util._ @@ -111,24 +110,29 @@ get("/:owner/:repository/pull/:id")(referrersOnly { repository => params("id").toIntOpt.flatMap { issueId => - val owner = repository.owner - val name = repository.name - getPullRequest(owner, name, issueId) map { + getPullRequest(repository.owner, repository.name, issueId) map { case (issue, pullreq) => val (commits, diffs) = - getRequestCompareInfo(owner, name, pullreq.commitIdFrom, owner, name, pullreq.commitIdTo) + getRequestCompareInfo( + repository.owner, + repository.name, + pullreq.commitIdFrom, + repository.owner, + repository.name, + pullreq.commitIdTo + ) html.conversation( issue, pullreq, commits.flatten, - getPullRequestComments(owner, name, issue.issueId, commits.flatten), + getPullRequestComments(repository.owner, repository.name, issue.issueId, commits.flatten), diffs.size, - getIssueLabels(owner, name, issueId), - getAssignableUserNames(owner, name), - getMilestonesWithIssueCount(owner, name), - getPriorities(owner, name), - getLabels(owner, name), + getIssueLabels(repository.owner, repository.name, issueId), + getAssignableUserNames(repository.owner, repository.name), + getMilestonesWithIssueCount(repository.owner, repository.name), + getPriorities(repository.owner, repository.name), + getLabels(repository.owner, repository.name), isEditable(repository), isManageable(repository), hasDeveloperRole(pullreq.requestUserName, pullreq.requestRepositoryName, context.loginAccount), @@ -162,12 +166,17 @@ get("/:owner/:repository/pull/:id/commits")(referrersOnly { repository => params("id").toIntOpt.flatMap { issueId => - val owner = repository.owner - val name = repository.name - getPullRequest(owner, name, issueId) map { + getPullRequest(repository.owner, repository.name, issueId) map { case (issue, pullreq) => val (commits, diffs) = - getRequestCompareInfo(owner, name, pullreq.commitIdFrom, owner, name, pullreq.commitIdTo) + getRequestCompareInfo( + repository.owner, + repository.name, + pullreq.commitIdFrom, + repository.owner, + repository.name, + pullreq.commitIdTo + ) val commitsWithStatus = commits.map { day => day.map { commit => @@ -179,7 +188,7 @@ issue, pullreq, commitsWithStatus, - getPullRequestComments(owner, name, issue.issueId, commits.flatten), + getPullRequestComments(repository.owner, repository.name, issue.issueId, commits.flatten), diffs.size, isManageable(repository), repository @@ -191,19 +200,24 @@ get("/:owner/:repository/pull/:id/files")(referrersOnly { repository => params("id").toIntOpt.flatMap { issueId => - val owner = repository.owner - val name = repository.name - getPullRequest(owner, name, issueId) map { + getPullRequest(repository.owner, repository.name, issueId) map { case (issue, pullreq) => val (commits, diffs) = - getRequestCompareInfo(owner, name, pullreq.commitIdFrom, owner, name, pullreq.commitIdTo) + getRequestCompareInfo( + repository.owner, + repository.name, + pullreq.commitIdFrom, + repository.owner, + repository.name, + pullreq.commitIdTo + ) html.files( issue, pullreq, diffs, commits.flatten, - getPullRequestComments(owner, name, issue.issueId, commits.flatten), + getPullRequestComments(repository.owner, repository.name, issue.issueId, commits.flatten), isManageable(repository), repository ) @@ -214,20 +228,20 @@ ajaxGet("/:owner/:repository/pull/:id/mergeguide")(referrersOnly { repository => params("id").toIntOpt.flatMap { issueId => - val owner = repository.owner - val name = repository.name - getPullRequest(owner, name, issueId) map { + getPullRequest(repository.owner, repository.name, issueId) map { case (issue, pullreq) => - val conflictMessage = LockUtil.lock(s"${owner}/${name}") { - checkConflict(owner, name, pullreq.branch, issueId) + val conflictMessage = LockUtil.lock(s"${repository.owner}/${repository.name}") { + checkConflict(repository.owner, repository.name, pullreq.branch, issueId) } - val hasMergePermission = hasDeveloperRole(owner, name, context.loginAccount) - val branchProtection = getProtectedBranchInfo(owner, name, pullreq.branch) + val hasMergePermission = hasDeveloperRole(repository.owner, repository.name, context.loginAccount) + val branchProtection = getProtectedBranchInfo(repository.owner, repository.name, pullreq.branch) val mergeStatus = PullRequestService.MergeStatus( conflictMessage = conflictMessage, - commitStatuses = getCommitStatuses(owner, name, pullreq.commitIdTo), + commitStatuses = getCommitStatuses(repository.owner, repository.name, pullreq.commitIdTo), branchProtection = branchProtection, - branchIsOutOfDate = JGitUtil.getShaByRef(owner, name, pullreq.branch) != Some(pullreq.commitIdFrom), + branchIsOutOfDate = JGitUtil.getShaByRef(repository.owner, repository.name, pullreq.branch) != Some( + pullreq.commitIdFrom + ), needStatusCheck = context.loginAccount .map { u => branchProtection.needStatusCheck(u.userName) @@ -363,23 +377,22 @@ }) post("/:owner/:repository/pull/:id/merge", mergeForm)(writableUsersOnly { (form, repository) => - params("id").toIntOpt.flatMap { issueId => - val owner = repository.owner - val name = repository.name - - mergePullRequest( - repository, - issueId, - context.loginAccount.get, - form.message, - form.strategy, - form.isDraft, - context.settings - ) match { - case Right(objectId) => redirect(s"/${owner}/${name}/pull/${issueId}") - case Left(message) => Some(BadRequest(message)) - } - } getOrElse NotFound() + context.withLoginAccount { loginAccount => + params("id").toIntOpt.flatMap { issueId => + mergePullRequest( + repository, + issueId, + loginAccount, + form.message, + form.strategy, + form.isDraft, + context.settings + ) match { + case Right(objectId) => redirect(s"/${repository.owner}/${repository.name}/pull/${issueId}") + case Left(message) => Some(BadRequest(message)) + } + } getOrElse NotFound() + } }) get("/:owner/:repository/compare")(referrersOnly { forkedRepository => @@ -549,15 +562,14 @@ }) post("/:owner/:repository/pulls/new", pullRequestForm)(readableUsersOnly { (form, repository) => - defining(repository.owner, repository.name) { - case (owner, name) => + context.withLoginAccount { + loginAccount => val manageable = isManageable(repository) - val loginUserName = context.loginAccount.get.userName val issueId = insertIssue( owner = repository.owner, repository = repository.name, - loginUser = loginUserName, + loginUser = loginAccount.userName, title = form.title, content = form.content, assignedUserName = if (manageable) form.assignedUserName else None, @@ -576,14 +588,14 @@ commitIdFrom = form.commitIdFrom, commitIdTo = form.commitIdTo, isDraft = form.isDraft, - loginAccount = context.loginAccount.get, + loginAccount = loginAccount, settings = context.settings ) // insert labels if (manageable) { form.labelNames.foreach { value => - val labels = getLabels(owner, name) + val labels = getLabels(repository.owner, repository.name) value.split(",").foreach { labelName => labels.find(_.labelName == labelName).map { label => registerIssueLabel(repository.owner, repository.name, issueId, label.labelId) @@ -592,7 +604,7 @@ } } - redirect(s"/${owner}/${name}/pull/${issueId}") + redirect(s"/${repository.owner}/${repository.name}/pull/${issueId}") } }) @@ -639,44 +651,42 @@ html.proposals(proposedBranches, targetRepository, repository) }) - private def searchPullRequests(userName: Option[String], repository: RepositoryService.RepositoryInfo) = - defining(repository.owner, repository.name) { - case (owner, repoName) => - val page = IssueSearchCondition.page(request) - // retrieve search condition - val condition = IssueSearchCondition(request) - // search issues - val issues = searchIssue( - condition, - IssueSearchOption.PullRequests, - (page - 1) * PullRequestLimit, - PullRequestLimit, - owner -> repoName - ) - // commit status - val status = issues.map { issue => - issue.commitId.flatMap { commitId => - getCommitStatusWithSummary(owner, repoName, commitId) - } - } - - gitbucket.core.issues.html.list( - "pulls", - issues.zip(status), - page, - getAssignableUserNames(owner, repoName), - getMilestones(owner, repoName), - getPriorities(owner, repoName), - getLabels(owner, repoName), - countIssue(condition.copy(state = "open"), IssueSearchOption.PullRequests, owner -> repoName), - countIssue(condition.copy(state = "closed"), IssueSearchOption.PullRequests, owner -> repoName), - condition, - repository, - isEditable(repository), - isManageable(repository) - ) + private def searchPullRequests(userName: Option[String], repository: RepositoryService.RepositoryInfo) = { + val page = IssueSearchCondition.page(request) + // retrieve search condition + val condition = IssueSearchCondition(request) + // search issues + val issues = searchIssue( + condition, + IssueSearchOption.PullRequests, + (page - 1) * PullRequestLimit, + PullRequestLimit, + repository.owner -> repository.name + ) + // commit status + val status = issues.map { issue => + issue.commitId.flatMap { commitId => + getCommitStatusWithSummary(repository.owner, repository.name, commitId) + } } + gitbucket.core.issues.html.list( + "pulls", + issues.zip(status), + page, + getAssignableUserNames(repository.owner, repository.name), + getMilestones(repository.owner, repository.name), + getPriorities(repository.owner, repository.name), + getLabels(repository.owner, repository.name), + countIssue(condition.copy(state = "open"), IssueSearchOption.PullRequests, repository.owner -> repository.name), + countIssue(condition.copy(state = "closed"), IssueSearchOption.PullRequests, repository.owner -> repository.name), + condition, + repository, + isEditable(repository), + isManageable(repository) + ) + } + /** * Tests whether an logged-in user can manage pull requests. */ diff --git a/src/main/scala/gitbucket/core/controller/ReleasesController.scala b/src/main/scala/gitbucket/core/controller/ReleasesController.scala index 437e5b3..de326e9 100644 --- a/src/main/scala/gitbucket/core/controller/ReleasesController.scala +++ b/src/main/scala/gitbucket/core/controller/ReleasesController.scala @@ -106,32 +106,33 @@ }) post("/:owner/:repository/releases/:tag/create", releaseForm)(writableUsersOnly { (form, repository) => - val tagName = params("tag") - val loginAccount = context.loginAccount.get + context.withLoginAccount { + loginAccount => + val tagName = params("tag") + // Insert into RELEASE + createRelease(repository.owner, repository.name, form.name, form.content, tagName, loginAccount) - // Insert into RELEASE - createRelease(repository.owner, repository.name, form.name, form.content, tagName, loginAccount) + // Insert into RELEASE_ASSET + val files = params.toMap.collect { + case (name, value) if name.startsWith("file:") => + val Array(_, fileId) = name.split(":") + (fileId, value) + } + files.foreach { + case (fileId, fileName) => + val size = + new File( + getReleaseFilesDir(repository.owner, repository.name), + FileUtil.checkFilename(tagName + "/" + fileId) + ).length + createReleaseAsset(repository.owner, repository.name, tagName, fileId, fileName, size, loginAccount) + } - // Insert into RELEASE_ASSET - val files = params.toMap.collect { - case (name, value) if name.startsWith("file:") => - val Array(_, fileId) = name.split(":") - (fileId, value) + val releaseInfo = ReleaseInfo(repository.owner, repository.name, loginAccount.userName, form.name, tagName) + recordActivity(releaseInfo) + + redirect(s"/${repository.owner}/${repository.name}/releases/${tagName}") } - files.foreach { - case (fileId, fileName) => - val size = - new File( - getReleaseFilesDir(repository.owner, repository.name), - FileUtil.checkFilename(tagName + "/" + fileId) - ).length - createReleaseAsset(repository.owner, repository.name, tagName, fileId, fileName, size, loginAccount) - } - - val releaseInfo = ReleaseInfo(repository.owner, repository.name, loginAccount.userName, form.name, tagName) - recordActivity(releaseInfo) - - redirect(s"/${repository.owner}/${repository.name}/releases/${tagName}") }) get("/:owner/:repository/changelog/*...*")(writableUsersOnly { repository => @@ -168,48 +169,50 @@ }).getOrElse(NotFound()) }) - post("/:owner/:repository/releases/:tag/edit", releaseForm)(writableUsersOnly { - (form, repository) => - val tagName = params("tag") - val loginAccount = context.loginAccount.get + post("/:owner/:repository/releases/:tag/edit", releaseForm)(writableUsersOnly { (form, repository) => + context.withLoginAccount { + loginAccount => + val tagName = params("tag") - getRelease(repository.owner, repository.name, tagName) - .map { release => - // Update RELEASE - updateRelease(repository.owner, repository.name, tagName, form.name, form.content) + getRelease(repository.owner, repository.name, tagName) + .map { + release => + // Update RELEASE + updateRelease(repository.owner, repository.name, tagName, form.name, form.content) - // Delete and Insert RELEASE_ASSET - val assets = getReleaseAssets(repository.owner, repository.name, tagName) - deleteReleaseAssets(repository.owner, repository.name, tagName) + // Delete and Insert RELEASE_ASSET + val assets = getReleaseAssets(repository.owner, repository.name, tagName) + deleteReleaseAssets(repository.owner, repository.name, tagName) - val files = params.toMap.collect { - case (name, value) if name.startsWith("file:") => - val Array(_, fileId) = name.split(":") - (fileId, value) + val files = params.toMap.collect { + case (name, value) if name.startsWith("file:") => + val Array(_, fileId) = name.split(":") + (fileId, value) + } + files.foreach { + case (fileId, fileName) => + val size = + new File( + getReleaseFilesDir(repository.owner, repository.name), + FileUtil.checkFilename(tagName + "/" + fileId) + ).length + createReleaseAsset(repository.owner, repository.name, tagName, fileId, fileName, size, loginAccount) + } + + assets.foreach { asset => + if (!files.exists { case (fileId, _) => fileId == asset.fileName }) { + val file = new File( + getReleaseFilesDir(repository.owner, repository.name), + FileUtil.checkFilename(release.tag + "/" + asset.fileName) + ) + FileUtils.forceDelete(file) + } + } + + redirect(s"/${release.userName}/${release.repositoryName}/releases/${tagName}") } - files.foreach { - case (fileId, fileName) => - val size = - new File( - getReleaseFilesDir(repository.owner, repository.name), - FileUtil.checkFilename(tagName + "/" + fileId) - ).length - createReleaseAsset(repository.owner, repository.name, tagName, fileId, fileName, size, loginAccount) - } - - assets.foreach { asset => - if (!files.exists { case (fileId, _) => fileId == asset.fileName }) { - val file = new File( - getReleaseFilesDir(repository.owner, repository.name), - FileUtil.checkFilename(release.tag + "/" + asset.fileName) - ) - FileUtils.forceDelete(file) - } - } - - redirect(s"/${release.userName}/${release.repositoryName}/releases/${tagName}") - } - .getOrElse(NotFound()) + .getOrElse(NotFound()) + } }) post("/:owner/:repository/releases/:tag/delete")(writableUsersOnly { repository => diff --git a/src/main/scala/gitbucket/core/controller/RepositorySettingsController.scala b/src/main/scala/gitbucket/core/controller/RepositorySettingsController.scala index e03e045..ae5621f 100644 --- a/src/main/scala/gitbucket/core/controller/RepositorySettingsController.scala +++ b/src/main/scala/gitbucket/core/controller/RepositorySettingsController.scala @@ -385,54 +385,62 @@ * Rename repository. */ post("/:owner/:repository/settings/rename", renameForm)(ownerOnly { (form, repository) => - if (context.settings.repositoryOperation.rename || context.loginAccount.get.isAdmin) { - if (repository.name != form.repositoryName) { - // Update database and move git repository - renameRepository(repository.owner, repository.name, repository.owner, form.repositoryName) - // Record activity log - val renameInfo = RenameRepositoryInfo( - repository.owner, - form.repositoryName, - context.loginAccount.get.userName, - repository.name - ) - recordActivity(renameInfo) - } - redirect(s"/${repository.owner}/${form.repositoryName}") - } else Forbidden() + context.withLoginAccount { + loginAccount => + if (context.settings.repositoryOperation.rename || loginAccount.isAdmin) { + if (repository.name != form.repositoryName) { + // Update database and move git repository + renameRepository(repository.owner, repository.name, repository.owner, form.repositoryName) + // Record activity log + val renameInfo = RenameRepositoryInfo( + repository.owner, + form.repositoryName, + loginAccount.userName, + repository.name + ) + recordActivity(renameInfo) + } + redirect(s"/${repository.owner}/${form.repositoryName}") + } else Forbidden() + } }) /** * Transfer repository ownership. */ post("/:owner/:repository/settings/transfer", transferForm)(ownerOnly { (form, repository) => - if (context.settings.repositoryOperation.transfer || context.loginAccount.get.isAdmin) { - // Change repository owner - if (repository.owner != form.newOwner) { - // Update database and move git repository - renameRepository(repository.owner, repository.name, form.newOwner, repository.name) - // Record activity log - val renameInfo = RenameRepositoryInfo( - form.newOwner, - repository.name, - context.loginAccount.get.userName, - repository.owner - ) - recordActivity(renameInfo) - } - redirect(s"/${form.newOwner}/${repository.name}") - } else Forbidden() + context.withLoginAccount { + loginAccount => + if (context.settings.repositoryOperation.transfer || loginAccount.isAdmin) { + // Change repository owner + if (repository.owner != form.newOwner) { + // Update database and move git repository + renameRepository(repository.owner, repository.name, form.newOwner, repository.name) + // Record activity log + val renameInfo = RenameRepositoryInfo( + form.newOwner, + repository.name, + loginAccount.userName, + repository.owner + ) + recordActivity(renameInfo) + } + redirect(s"/${form.newOwner}/${repository.name}") + } else Forbidden() + } }) /** * Delete the repository. */ post("/:owner/:repository/settings/delete")(ownerOnly { repository => - if (context.settings.repositoryOperation.delete || context.loginAccount.get.isAdmin) { - // Delete the repository and related files - deleteRepository(repository.repository) - redirect(s"/${repository.owner}") - } else Forbidden() + context.withLoginAccount { loginAccount => + if (context.settings.repositoryOperation.delete || loginAccount.isAdmin) { + // Delete the repository and related files + deleteRepository(repository.repository) + redirect(s"/${repository.owner}") + } else Forbidden() + } }) /** diff --git a/src/main/scala/gitbucket/core/controller/RepositoryViewerController.scala b/src/main/scala/gitbucket/core/controller/RepositoryViewerController.scala index 3884798..67c9789 100644 --- a/src/main/scala/gitbucket/core/controller/RepositoryViewerController.scala +++ b/src/main/scala/gitbucket/core/controller/RepositoryViewerController.scala @@ -10,7 +10,6 @@ import gitbucket.core.service.RepositoryCommitFileService.CommitFile import gitbucket.core.util._ import gitbucket.core.util.StringUtil._ -import gitbucket.core.util.SyntaxSugars._ import gitbucket.core.util.Implicits._ import gitbucket.core.util.Directory._ import gitbucket.core.model.{Account, WebHook} @@ -221,11 +220,8 @@ gitbucket.core.repo.html.creating(owner, repository) } else { params.get("go-get") match { - case Some("1") => - defining(request.paths) { paths => - getRepository(owner, repository).map(gitbucket.core.html.goget(_)) getOrElse NotFound() - } - case _ => referrersOnly(fileList(_)) + case Some("1") => getRepository(owner, repository).map(gitbucket.core.html.goget(_)) getOrElse NotFound() + case _ => referrersOnly(fileList(_)) } } } @@ -306,74 +302,99 @@ }) get("/:owner/:repository/new/*")(writableUsersOnly { repository => - val (branch, path) = repository.splitPath(multiParams("splat").head) - val protectedBranch = getProtectedBranchInfo(repository.owner, repository.name, branch) - .needStatusCheck(context.loginAccount.get.userName) + context.withLoginAccount { + loginAccount => + val (branch, path) = repository.splitPath(multiParams("splat").head) + val protectedBranch = getProtectedBranchInfo(repository.owner, repository.name, branch) + .needStatusCheck(loginAccount.userName) - Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { git => - val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(branch)) + Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { git => + val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(branch)) - html.editor( - branch = branch, - repository = repository, - pathList = if (path.length == 0) Nil else path.split("/").toList, - fileName = None, - content = JGitUtil.ContentInfo("text", None, None, Some("UTF-8")), - protectedBranch = protectedBranch, - commit = revCommit.getName - ) + html.editor( + branch = branch, + repository = repository, + pathList = if (path.length == 0) Nil else path.split("/").toList, + fileName = None, + content = JGitUtil.ContentInfo("text", None, None, Some("UTF-8")), + protectedBranch = protectedBranch, + commit = revCommit.getName + ) + } } }) get("/:owner/:repository/upload/*")(writableUsersOnly { repository => - val (branch, path) = repository.splitPath(multiParams("splat").head) - val protectedBranch = getProtectedBranchInfo(repository.owner, repository.name, branch) - .needStatusCheck(context.loginAccount.get.userName) - Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { git => - val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(branch)) - html.upload( - branch, - repository, - if (path.length == 0) Nil else path.split("/").toList, - protectedBranch, - revCommit.name - ) + context.withLoginAccount { + loginAccount => + val (branch, path) = repository.splitPath(multiParams("splat").head) + val protectedBranch = getProtectedBranchInfo(repository.owner, repository.name, branch) + .needStatusCheck(loginAccount.userName) + Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { git => + val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(branch)) + html.upload( + branch, + repository, + if (path.length == 0) Nil else path.split("/").toList, + protectedBranch, + revCommit.name + ) + } } }) post("/:owner/:repository/upload", uploadForm)(writableUsersOnly { (form, repository) => - val files = form.uploadFiles.split("\n").map { line => - val i = line.indexOf(':') - CommitFile(line.substring(0, i).trim, line.substring(i + 1).trim) + context.withLoginAccount { + loginAccount => + val files = form.uploadFiles + .split("\n") + .map { line => + val i = line.indexOf(':') + CommitFile(line.substring(0, i).trim, line.substring(i + 1).trim) + } + .toSeq + + val newFiles = files.map { file => + file.copy(name = if (form.path.length == 0) file.name else s"${form.path}/${file.name}") + }.toSeq + + if (form.newBranch) { + val newBranchName = createNewBranchForPullRequest(repository, form.branch, loginAccount) + val objectId = _commit(newBranchName, files, newFiles, loginAccount) + val issueId = + createIssueAndPullRequest( + repository, + form.branch, + newBranchName, + form.commit, + objectId.name, + form.message, + loginAccount + ) + redirect(s"/${repository.owner}/${repository.name}/pull/${issueId}") + } else { + _commit(form.branch, files, newFiles, loginAccount) + if (form.path.length == 0) { + redirect(s"/${repository.owner}/${repository.name}/tree/${form.branch}") + } else { + redirect(s"/${repository.owner}/${repository.name}/tree/${form.branch}/${form.path}") + } + } } - val newFiles = files.map { file => - file.copy(name = if (form.path.length == 0) file.name else s"${form.path}/${file.name}") - } - - if (form.newBranch) { - val newBranchName = createNewBranchForPullRequest(repository, form.branch) - val objectId = _commit(newBranchName) - val issueId = - createIssueAndPullRequest(repository, form.branch, newBranchName, form.commit, objectId.name, form.message) - redirect(s"/${repository.owner}/${repository.name}/pull/${issueId}") - } else { - _commit(form.branch) - if (form.path.length == 0) { - redirect(s"/${repository.owner}/${repository.name}/tree/${form.branch}") - } else { - redirect(s"/${repository.owner}/${repository.name}/tree/${form.branch}/${form.path}") - } - } - - def _commit(branchName: String): ObjectId = { + def _commit( + branchName: String, + files: Seq[CommitFile], + newFiles: Seq[CommitFile], + loginAccount: Account + ): ObjectId = { commitFiles( repository = repository, branch = branchName, path = form.path, files = files.toIndexedSeq, message = form.message.getOrElse("Add files via upload"), - loginAccount = context.loginAccount.get, + loginAccount = loginAccount, settings = context.settings ) { case (git, headTip, builder, inserter) => @@ -396,32 +417,36 @@ }) get("/:owner/:repository/edit/*")(writableUsersOnly { repository => - val (branch, path) = repository.splitPath(multiParams("splat").head) - val protectedBranch = getProtectedBranchInfo(repository.owner, repository.name, branch) - .needStatusCheck(context.loginAccount.get.userName) + context.withLoginAccount { + loginAccount => + val (branch, path) = repository.splitPath(multiParams("splat").head) + val protectedBranch = getProtectedBranchInfo(repository.owner, repository.name, branch) + .needStatusCheck(loginAccount.userName) - Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { - git => - val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(branch)) + Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { + git => + val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(branch)) - getPathObjectId(git, path, revCommit).map { - objectId => - val paths = path.split("/") - val info = EditorConfigUtil.getEditorConfigInfo(git, branch, path) + getPathObjectId(git, path, revCommit) + .map { + objectId => + val paths = path.split("/") + val info = EditorConfigUtil.getEditorConfigInfo(git, branch, path) - html.editor( - branch = branch, - repository = repository, - pathList = paths.take(paths.size - 1).toList, - fileName = Some(paths.last), - content = JGitUtil.getContentInfo(git, path, objectId), - protectedBranch = protectedBranch, - commit = revCommit.getName, - newLineMode = info.newLineMode, - useSoftTabs = info.useSoftTabs, - tabSize = info.tabSize - ) - } getOrElse NotFound() + html.editor( + branch = branch, + repository = repository, + pathList = paths.take(paths.size - 1).toList, + fileName = Some(paths.last), + content = JGitUtil.getContentInfo(git, path, objectId), + protectedBranch = protectedBranch, + commit = revCommit.getName, + newLineMode = info.newLineMode, + useSoftTabs = info.useSoftTabs, + tabSize = info.tabSize + ) + } getOrElse NotFound() + } } }) @@ -446,21 +471,32 @@ }) post("/:owner/:repository/create", editorForm)(writableUsersOnly { (form, repository) => - if (form.newBranch) { - val newBranchName = createNewBranchForPullRequest(repository, form.branch) - val objectId = _commit(newBranchName) - val issueId = - createIssueAndPullRequest(repository, form.branch, newBranchName, form.commit, objectId.name, form.message) - redirect(s"/${repository.owner}/${repository.name}/pull/${issueId}") - } else { - _commit(form.branch) - redirect( - s"/${repository.owner}/${repository.name}/blob/${form.branch}/${if (form.path.length == 0) urlEncode(form.newFileName) - else s"${form.path}/${urlEncode(form.newFileName)}"}" - ) + context.withLoginAccount { + loginAccount => + if (form.newBranch) { + val newBranchName = createNewBranchForPullRequest(repository, form.branch, loginAccount) + val objectId = _commit(newBranchName, loginAccount) + val issueId = + createIssueAndPullRequest( + repository, + form.branch, + newBranchName, + form.commit, + objectId.name, + form.message, + loginAccount + ) + redirect(s"/${repository.owner}/${repository.name}/pull/${issueId}") + } else { + _commit(form.branch, loginAccount) + redirect( + s"/${repository.owner}/${repository.name}/blob/${form.branch}/${if (form.path.length == 0) urlEncode(form.newFileName) + else s"${form.path}/${urlEncode(form.newFileName)}"}" + ) + } } - def _commit(branchName: String): ObjectId = { + def _commit(branchName: String, loginAccount: Account): ObjectId = { commitFile( repository = repository, branch = branchName, @@ -471,28 +507,39 @@ charset = form.charset, message = form.message.getOrElse(s"Create ${form.newFileName}"), commit = form.commit, - loginAccount = context.loginAccount.get, + loginAccount = loginAccount, settings = context.settings ) } }) post("/:owner/:repository/update", editorForm)(writableUsersOnly { (form, repository) => - if (form.newBranch) { - val newBranchName = createNewBranchForPullRequest(repository, form.branch) - val objectId = _commit(newBranchName) - val issueId = - createIssueAndPullRequest(repository, form.branch, newBranchName, form.commit, objectId.name, form.message) - redirect(s"/${repository.owner}/${repository.name}/pull/${issueId}") - } else { - _commit(form.branch) - redirect( - s"/${repository.owner}/${repository.name}/blob/${urlEncode(form.branch)}/${if (form.path.length == 0) urlEncode(form.newFileName) - else s"${form.path}/${urlEncode(form.newFileName)}"}" - ) + context.withLoginAccount { + loginAccount => + if (form.newBranch) { + val newBranchName = createNewBranchForPullRequest(repository, form.branch, loginAccount) + val objectId = _commit(newBranchName, loginAccount) + val issueId = + createIssueAndPullRequest( + repository, + form.branch, + newBranchName, + form.commit, + objectId.name, + form.message, + loginAccount + ) + redirect(s"/${repository.owner}/${repository.name}/pull/${issueId}") + } else { + _commit(form.branch, loginAccount) + redirect( + s"/${repository.owner}/${repository.name}/blob/${urlEncode(form.branch)}/${if (form.path.length == 0) urlEncode(form.newFileName) + else s"${form.path}/${urlEncode(form.newFileName)}"}" + ) + } } - def _commit(branchName: String): ObjectId = { + def _commit(branchName: String, loginAccount: Account): ObjectId = { commitFile( repository = repository, branch = branchName, @@ -507,28 +554,39 @@ form.message.getOrElse(s"Rename ${form.oldFileName.get} to ${form.newFileName}") }, commit = form.commit, - loginAccount = context.loginAccount.get, + loginAccount = loginAccount, settings = context.settings ) } }) post("/:owner/:repository/remove", deleteForm)(writableUsersOnly { (form, repository) => - if (form.newBranch) { - val newBranchName = createNewBranchForPullRequest(repository, form.branch) - val objectId = _commit(newBranchName) - val issueId = - createIssueAndPullRequest(repository, form.branch, newBranchName, form.commit, objectId.name, form.message) - redirect(s"/${repository.owner}/${repository.name}/pull/${issueId}") - } else { - _commit(form.branch) - redirect( - s"/${repository.owner}/${repository.name}/tree/${form.branch}${if (form.path.length == 0) "" - else "/" + form.path}" - ) + context.withLoginAccount { + loginAccount => + if (form.newBranch) { + val newBranchName = createNewBranchForPullRequest(repository, form.branch, loginAccount) + val objectId = _commit(newBranchName, loginAccount) + val issueId = + createIssueAndPullRequest( + repository, + form.branch, + newBranchName, + form.commit, + objectId.name, + form.message, + loginAccount + ) + redirect(s"/${repository.owner}/${repository.name}/pull/${issueId}") + } else { + _commit(form.branch, loginAccount) + redirect( + s"/${repository.owner}/${repository.name}/tree/${form.branch}${if (form.path.length == 0) "" + else "/" + form.path}" + ) + } } - def _commit(branchName: String): ObjectId = { + def _commit(branchName: String, loginAccount: Account): ObjectId = { commitFile( repository = repository, branch = branchName, @@ -539,23 +597,27 @@ charset = "", message = form.message.getOrElse(s"Delete ${form.fileName}"), commit = form.commit, - loginAccount = context.loginAccount.get, + loginAccount = loginAccount, settings = context.settings ) } }) - private def getNewBranchName(repository: RepositoryInfo): String = { + private def getNewBranchName(repository: RepositoryInfo, loginAccount: Account): String = { var i = 1 - val branchNamePrefix = cutTail(context.loginAccount.get.userName.replaceAll("[^a-zA-Z0-9-_]", "-"), 25) + val branchNamePrefix = cutTail(loginAccount.userName.replaceAll("[^a-zA-Z0-9-_]", "-"), 25) while (repository.branchList.exists(p => p.contains(s"$branchNamePrefix-patch-$i"))) { i += 1 } s"$branchNamePrefix-patch-$i" } - private def createNewBranchForPullRequest(repository: RepositoryInfo, baseBranchName: String): String = { - val newBranchName = getNewBranchName(repository) + private def createNewBranchForPullRequest( + repository: RepositoryInfo, + baseBranchName: String, + loginAccount: Account + ): String = { + val newBranchName = getNewBranchName(repository, loginAccount) Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { git => JGitUtil.createBranch(git, baseBranchName, newBranchName) } @@ -563,7 +625,7 @@ val settings = loadSystemSettings() callWebHookOf(repository.owner, repository.name, WebHook.Create, settings) { for { - sender <- context.loginAccount + sender <- Some(loginAccount) owner <- getAccountByUserName(repository.owner) } yield { WebHookCreatePayload( @@ -584,12 +646,13 @@ requestBranch: String, commitIdFrom: String, commitIdTo: String, - commitMessage: Option[String] + commitMessage: Option[String], + loginAccount: Account ): Int = { val issueId = insertIssue( owner = repository.owner, repository = repository.name, - loginUser = context.loginAccount.get.userName, + loginUser = loginAccount.userName, title = requestBranch, content = commitMessage, assignedUserName = None, @@ -607,7 +670,7 @@ commitIdFrom = commitIdFrom, commitIdTo = commitIdTo, isDraft = false, - loginAccount = context.loginAccount.get, + loginAccount = loginAccount, settings = context.settings ) issueId @@ -720,26 +783,24 @@ try { Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { git => - defining(JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(id))) { - revCommit => - val diffs = JGitUtil.getDiffs(git, None, id, true, false) - val oldCommitId = JGitUtil.getParentCommitId(git, id) + val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(id)) + val diffs = JGitUtil.getDiffs(git, None, id, true, false) + val oldCommitId = JGitUtil.getParentCommitId(git, id) - html.commit( - id, - new JGitUtil.CommitInfo(revCommit), - JGitUtil.getBranchesOfCommit(git, revCommit.getName), - JGitUtil.getTagsOfCommit(git, revCommit.getName), - getCommitStatusWithSummary(repository.owner, repository.name, revCommit.getName), - getCommitComments(repository.owner, repository.name, id, true), - repository, - diffs, - oldCommitId, - hasDeveloperRole(repository.owner, repository.name, context.loginAccount), - flash.get("info"), - flash.get("error") - ) - } + html.commit( + id, + new JGitUtil.CommitInfo(revCommit), + JGitUtil.getBranchesOfCommit(git, revCommit.getName), + JGitUtil.getTagsOfCommit(git, revCommit.getName), + getCommitStatusWithSummary(repository.owner, repository.name, revCommit.getName), + getCommitComments(repository.owner, repository.name, id, true), + repository, + diffs, + oldCommitId, + hasDeveloperRole(repository.owner, repository.name, context.loginAccount), + flash.get("info"), + flash.get("error") + ) } } catch { case e: MissingObjectException => NotFound() @@ -772,20 +833,22 @@ }) post("/:owner/:repository/commit/:id/comment/new", commentForm)(readableUsersOnly { (form, repository) => - val id = params("id") - createCommitComment( - repository, - id, - context.loginAccount.get, - form.content, - form.fileName, - form.oldLineNumber, - form.newLineNumber, - form.diff, - form.issueId - ) + context.withLoginAccount { loginAccount => + val id = params("id") + createCommitComment( + repository, + id, + loginAccount, + form.content, + form.fileName, + form.oldLineNumber, + form.newLineNumber, + form.diff, + form.issueId + ) - redirect(s"/${repository.owner}/${repository.name}/commit/${id}") + redirect(s"/${repository.owner}/${repository.name}/commit/${id}") + } }) ajaxGet("/:owner/:repository/commit/:id/comment/_form")(readableUsersOnly { repository => @@ -807,72 +870,77 @@ }) ajaxPost("/:owner/:repository/commit/:id/comment/_data/new", commentForm)(readableUsersOnly { (form, repository) => - val id = params("id") - val commentId = createCommitComment( - repository, - id, - context.loginAccount.get, - form.content, - form.fileName, - form.oldLineNumber, - form.newLineNumber, - form.diff, - form.issueId - ) + context.withLoginAccount { + loginAccount => + val id = params("id") + val commentId = createCommitComment( + repository, + id, + loginAccount, + form.content, + form.fileName, + form.oldLineNumber, + form.newLineNumber, + form.diff, + form.issueId + ) - val comment = getCommitComment(repository.owner, repository.name, commentId.toString).get - helper.html - .commitcomment(comment, hasDeveloperRole(repository.owner, repository.name, context.loginAccount), repository) + val comment = getCommitComment(repository.owner, repository.name, commentId.toString).get + helper.html + .commitcomment(comment, hasDeveloperRole(repository.owner, repository.name, context.loginAccount), repository) + } }) ajaxGet("/:owner/:repository/commit_comments/_data/:id")(readableUsersOnly { repository => - getCommitComment(repository.owner, repository.name, params("id")) map { - x => - if (isEditable(x.userName, x.repositoryName, x.commentedUserName)) { - params.get("dataType") collect { - case t if t == "html" => html.editcomment(x.content, x.commentId, repository) - } getOrElse { - contentType = formats("json") - org.json4s.jackson.Serialization.write( - Map( - "content" -> view.Markdown.toHtml( - markdown = x.content, - repository = repository, - branch = repository.repository.defaultBranch, - enableWikiLink = false, - enableRefsLink = true, - enableAnchor = true, - enableLineBreaks = true, - enableTaskList = true, - hasWritePermission = true + context.withLoginAccount { + loginAccount => + getCommitComment(repository.owner, repository.name, params("id")) map { + x => + if (isEditable(x.userName, x.repositoryName, x.commentedUserName, loginAccount)) { + params.get("dataType") collect { + case t if t == "html" => html.editcomment(x.content, x.commentId, repository) + } getOrElse { + contentType = formats("json") + org.json4s.jackson.Serialization.write( + Map( + "content" -> view.Markdown.toHtml( + markdown = x.content, + repository = repository, + branch = repository.repository.defaultBranch, + enableWikiLink = false, + enableRefsLink = true, + enableAnchor = true, + enableLineBreaks = true, + enableTaskList = true, + hasWritePermission = true + ) + ) ) - ) - ) - } - } else Unauthorized() - } getOrElse NotFound() + } + } else Unauthorized() + } getOrElse NotFound() + } }) ajaxPost("/:owner/:repository/commit_comments/edit/:id", commentForm)(readableUsersOnly { (form, repository) => - defining(repository.owner, repository.name) { - case (owner, name) => - getCommitComment(owner, name, params("id")).map { comment => - if (isEditable(owner, name, comment.commentedUserName)) { + context.withLoginAccount { + loginAccount => + getCommitComment(repository.owner, repository.name, params("id")).map { comment => + if (isEditable(repository.owner, repository.name, comment.commentedUserName, loginAccount)) { updateCommitComment(comment.commentId, form.content) - redirect(s"/${owner}/${name}/commit_comments/_data/${comment.commentId}") + redirect(s"/${repository.owner}/${repository.name}/commit_comments/_data/${comment.commentId}") } else Unauthorized() } getOrElse NotFound() } }) ajaxPost("/:owner/:repository/commit_comments/delete/:id")(readableUsersOnly { repository => - defining(repository.owner, repository.name) { - case (owner, name) => - getCommitComment(owner, name, params("id")).map { comment => - if (isEditable(owner, name, comment.commentedUserName)) { - Ok(deleteCommitComment(comment.commentId)) - } else Unauthorized() - } getOrElse NotFound() + context.withLoginAccount { loginAccount => + getCommitComment(repository.owner, repository.name, params("id")).map { comment => + if (isEditable(repository.owner, repository.name, comment.commentedUserName, loginAccount)) { + Ok(deleteCommitComment(comment.commentId)) + } else Unauthorized() + } getOrElse NotFound() } }) @@ -995,16 +1063,19 @@ * Deletes branch. */ get("/:owner/:repository/delete/*")(writableUsersOnly { repository => - val branchName = multiParams("splat").head - val userName = context.loginAccount.get.userName - if (repository.repository.defaultBranch != branchName) { - Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { git => - git.branchDelete().setForce(true).setBranchNames(branchName).call() - val deleteBranchInfo = DeleteBranchInfo(repository.owner, repository.name, userName, branchName) - recordActivity(deleteBranchInfo) - } + context.withLoginAccount { + loginAccount => + val branchName = multiParams("splat").head + if (repository.repository.defaultBranch != branchName) { + Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { git => + git.branchDelete().setForce(true).setBranchNames(branchName).call() + val deleteBranchInfo = + DeleteBranchInfo(repository.owner, repository.name, loginAccount.userName, branchName) + recordActivity(deleteBranchInfo) + } + } + redirect(s"/${repository.owner}/${repository.name}/branches") } - redirect(s"/${repository.owner}/${repository.name}/branches") }) /** @@ -1090,54 +1161,53 @@ // get specified commit JGitUtil.getDefaultBranch(git, repository, revstr).map { case (objectId, revision) => - defining(JGitUtil.getRevCommitFromId(git, objectId)) { revCommit => - val lastModifiedCommit = - if (path == ".") revCommit else JGitUtil.getLastModifiedCommit(git, revCommit, path) - val commitCount = JGitUtil.getCommitCount(git, lastModifiedCommit.getName) - // get files - val files = JGitUtil.getFileList( - git, - revision, - path, - context.settings.baseUrl, - commitCount, - context.settings.repositoryViewer.maxFiles - ) - val parentPath = if (path == ".") Nil else path.split("/").toList - // process README - val readme = files // files should be sorted alphabetically. - .find { file => - !file.isDirectory && RepositoryService.readmeFiles.contains(file.name.toLowerCase) - } - .map { file => - val path = (file.name :: parentPath.reverse).reverse - path -> StringUtil.convertFromByteArray( - JGitUtil - .getContentFromId(Git.open(getRepositoryDir(repository.owner, repository.name)), file.id, true) - .get - ) - } + val revCommit = JGitUtil.getRevCommitFromId(git, objectId) + val lastModifiedCommit = + if (path == ".") revCommit else JGitUtil.getLastModifiedCommit(git, revCommit, path) + val commitCount = JGitUtil.getCommitCount(git, lastModifiedCommit.getName) + // get files + val files = JGitUtil.getFileList( + git, + revision, + path, + context.settings.baseUrl, + commitCount, + context.settings.repositoryViewer.maxFiles + ) + val parentPath = if (path == ".") Nil else path.split("/").toList + // process README + val readme = files // files should be sorted alphabetically. + .find { file => + !file.isDirectory && RepositoryService.readmeFiles.contains(file.name.toLowerCase) + } + .map { file => + val path = (file.name :: parentPath.reverse).reverse + path -> StringUtil.convertFromByteArray( + JGitUtil + .getContentFromId(Git.open(getRepositoryDir(repository.owner, repository.name)), file.id, true) + .get + ) + } - html.files( - revision, - repository, - if (path == ".") Nil else path.split("/").toList, // current path - new JGitUtil.CommitInfo(lastModifiedCommit), // last modified commit - getCommitStatusWithSummary(repository.owner, repository.name, lastModifiedCommit.getName), - commitCount, - files, - readme, - hasDeveloperRole(repository.owner, repository.name, context.loginAccount), - getPullRequestFromBranch( - repository.owner, - repository.name, - revstr, - repository.repository.defaultBranch - ), - flash.get("info"), - flash.get("error") - ) - } + html.files( + revision, + repository, + if (path == ".") Nil else path.split("/").toList, // current path + new JGitUtil.CommitInfo(lastModifiedCommit), // last modified commit + getCommitStatusWithSummary(repository.owner, repository.name, lastModifiedCommit.getName), + commitCount, + files, + readme, + hasDeveloperRole(repository.owner, repository.name, context.loginAccount), + getPullRequestFromBranch( + repository.owner, + repository.name, + revstr, + repository.repository.defaultBranch + ), + flash.get("info"), + flash.get("error") + ) } getOrElse NotFound() } } @@ -1257,8 +1327,9 @@ } } - private def isEditable(owner: String, repository: String, author: String)(implicit context: Context): Boolean = - hasDeveloperRole(owner, repository, context.loginAccount) || author == context.loginAccount.get.userName + private def isEditable(owner: String, repository: String, author: String, loginAccount: Account): Boolean = { + hasDeveloperRole(owner, repository, Some(loginAccount)) || author == loginAccount.userName + } private def conflict: Constraint = new Constraint() { override def validate(name: String, value: String, messages: Messages): Option[String] = { diff --git a/src/main/scala/gitbucket/core/controller/SystemSettingsController.scala b/src/main/scala/gitbucket/core/controller/SystemSettingsController.scala index ef0b723..6663d2f 100644 --- a/src/main/scala/gitbucket/core/controller/SystemSettingsController.scala +++ b/src/main/scala/gitbucket/core/controller/SystemSettingsController.scala @@ -9,7 +9,6 @@ import gitbucket.core.ssh.SshServer import gitbucket.core.util.Implicits._ import gitbucket.core.util.StringUtil._ -import gitbucket.core.util.SyntaxSugars._ import gitbucket.core.util.{AdminAuthenticator, Mailer} import org.apache.commons.io.IOUtils import org.apache.commons.mail.EmailException @@ -463,31 +462,28 @@ }) get("/admin/users/:groupName/_editgroup")(adminOnly { - defining(params("groupName")) { groupName => - html.usergroup(getAccountByUserName(groupName, true), getGroupMembers(groupName)) - } + val groupName = params("groupName") + html.usergroup(getAccountByUserName(groupName, true), getGroupMembers(groupName)) }) post("/admin/users/:groupName/_editgroup", editGroupForm)(adminOnly { form => - defining( - params("groupName"), - form.members - .split(",") - .map { - _.split(":") match { - case Array(userName, isManager) => (userName, isManager.toBoolean) - } + val groupName = params("groupName") + val members = form.members + .split(",") + .map { + _.split(":") match { + case Array(userName, isManager) => (userName, isManager.toBoolean) } - .toList - ) { - case (groupName, members) => - getAccountByUserName(groupName, true).map { - account => - updateGroup(groupName, form.description, form.url, form.isRemoved) + } + .toList - if (form.isRemoved) { - // Remove from GROUP_MEMBER - updateGroupMembers(form.groupName, Nil) + getAccountByUserName(groupName, true).map { + account => + updateGroup(groupName, form.description, form.url, form.isRemoved) + + if (form.isRemoved) { + // Remove from GROUP_MEMBER + updateGroupMembers(form.groupName, Nil) // // Remove repositories // getRepositoryNamesOfUser(form.groupName).foreach { repositoryName => // deleteRepository(groupName, repositoryName) @@ -495,9 +491,9 @@ // FileUtils.deleteDirectory(getWikiRepositoryDir(groupName, repositoryName)) // FileUtils.deleteDirectory(getTemporaryDir(groupName, repositoryName)) // } - } else { - // Update GROUP_MEMBER - updateGroupMembers(form.groupName, members) + } else { + // Update GROUP_MEMBER + updateGroupMembers(form.groupName, members) // // Update COLLABORATOR for group repositories // getRepositoryNamesOfUser(form.groupName).foreach { repositoryName => // removeCollaborators(form.groupName, repositoryName) @@ -505,13 +501,12 @@ // addCollaborator(form.groupName, repositoryName, userName) // } // } - } + } - updateImage(form.groupName, form.fileId, form.clearImage) - redirect("/admin/users") + updateImage(form.groupName, form.fileId, form.clearImage) + redirect("/admin/users") - } getOrElse NotFound() - } + } getOrElse NotFound() }) get("/admin/data")(adminOnly { @@ -559,12 +554,11 @@ protected def disableByNotYourself(paramName: String): Constraint = new Constraint() { override def validate(name: String, value: String, messages: Messages): Option[String] = { - params.get(paramName).flatMap { userName => - if (userName == context.loginAccount.get.userName && params.get("removed") == Some("true")) - Some("You can't disable your account yourself") - else - None - } + for { + userName <- params.get(paramName) + loginAccount <- context.loginAccount + if userName == loginAccount.userName && params.get("removed") == Some("true") + } yield "You can't disable your account yourself" } } diff --git a/src/main/scala/gitbucket/core/controller/WikiController.scala b/src/main/scala/gitbucket/core/controller/WikiController.scala index 6ced0fa..b77eb4d 100644 --- a/src/main/scala/gitbucket/core/controller/WikiController.scala +++ b/src/main/scala/gitbucket/core/controller/WikiController.scala @@ -136,32 +136,38 @@ }) get("/:owner/:repository/wiki/:page/_revert/:commitId")(readableUsersOnly { repository => - if (isEditable(repository)) { - val pageName = StringUtil.urlDecode(params("page")) - val Array(from, to) = params("commitId").split("\\.\\.\\.") + context.withLoginAccount { + loginAccount => + if (isEditable(repository)) { + val pageName = StringUtil.urlDecode(params("page")) + val Array(from, to) = params("commitId").split("\\.\\.\\.") - if (revertWikiPage(repository.owner, repository.name, from, to, context.loginAccount.get, Some(pageName))) { - redirect(s"/${repository.owner}/${repository.name}/wiki/${StringUtil.urlEncode(pageName)}") - } else { - flash.update("info", "This patch was not able to be reversed.") - redirect( - s"/${repository.owner}/${repository.name}/wiki/${StringUtil.urlEncode(pageName)}/_compare/${from}...${to}" - ) - } - } else Unauthorized() + if (revertWikiPage(repository.owner, repository.name, from, to, loginAccount, Some(pageName))) { + redirect(s"/${repository.owner}/${repository.name}/wiki/${StringUtil.urlEncode(pageName)}") + } else { + flash.update("info", "This patch was not able to be reversed.") + redirect( + s"/${repository.owner}/${repository.name}/wiki/${StringUtil.urlEncode(pageName)}/_compare/${from}...${to}" + ) + } + } else Unauthorized() + } }) get("/:owner/:repository/wiki/_revert/:commitId")(readableUsersOnly { repository => - if (isEditable(repository)) { - val Array(from, to) = params("commitId").split("\\.\\.\\.") + context.withLoginAccount { + loginAccount => + if (isEditable(repository)) { + val Array(from, to) = params("commitId").split("\\.\\.\\.") - if (revertWikiPage(repository.owner, repository.name, from, to, context.loginAccount.get, None)) { - redirect(s"/${repository.owner}/${repository.name}/wiki") - } else { - flash.update("info", "This patch was not able to be reversed.") - redirect(s"/${repository.owner}/${repository.name}/wiki/_compare/${from}...${to}") - } - } else Unauthorized() + if (revertWikiPage(repository.owner, repository.name, from, to, loginAccount, None)) { + redirect(s"/${repository.owner}/${repository.name}/wiki") + } else { + flash.update("info", "This patch was not able to be reversed.") + redirect(s"/${repository.owner}/${repository.name}/wiki/_compare/${from}...${to}") + } + } else Unauthorized() + } }) get("/:owner/:repository/wiki/:page/_edit")(readableUsersOnly { repository => @@ -172,9 +178,9 @@ }) post("/:owner/:repository/wiki/_edit", editForm)(readableUsersOnly { (form, repository) => - if (isEditable(repository)) { - defining(context.loginAccount.get) { - loginAccount => + context.withLoginAccount { + loginAccount => + if (isEditable(repository)) { saveWikiPage( repository.owner, repository.name, @@ -201,8 +207,8 @@ } else { redirect(s"/${repository.owner}/${repository.name}/wiki") } - } - } else Unauthorized() + } else Unauthorized() + } }) get("/:owner/:repository/wiki/_new")(readableUsersOnly { repository => @@ -212,9 +218,9 @@ }) post("/:owner/:repository/wiki/_new", newForm)(readableUsersOnly { (form, repository) => - if (isEditable(repository)) { - defining(context.loginAccount.get) { - loginAccount => + context.withLoginAccount { + loginAccount => + if (isEditable(repository)) { saveWikiPage( repository.owner, repository.name, @@ -242,16 +248,15 @@ } else { redirect(s"/${repository.owner}/${repository.name}/wiki") } - } - } else Unauthorized() + } else Unauthorized() + } }) get("/:owner/:repository/wiki/:page/_delete")(readableUsersOnly { repository => - if (isEditable(repository)) { - val pageName = StringUtil.urlDecode(params("page")) - - defining(context.loginAccount.get) { - loginAccount => + context.withLoginAccount { + loginAccount => + if (isEditable(repository)) { + val pageName = StringUtil.urlDecode(params("page")) deleteWikiPage( repository.owner, repository.name, @@ -270,8 +275,8 @@ updateLastActivityDate(repository.owner, repository.name) redirect(s"/${repository.owner}/${repository.name}/wiki") - } - } else Unauthorized() + } else Unauthorized() + } }) get("/:owner/:repository/wiki/_pages")(referrersOnly { repository => diff --git a/src/main/scala/gitbucket/core/util/SyntaxSugars.scala b/src/main/scala/gitbucket/core/util/SyntaxSugars.scala index 54312ae..d40a199 100644 --- a/src/main/scala/gitbucket/core/util/SyntaxSugars.scala +++ b/src/main/scala/gitbucket/core/util/SyntaxSugars.scala @@ -1,12 +1,11 @@ package gitbucket.core.util -import scala.language.reflectiveCalls - /** * Provides control facilities. */ object SyntaxSugars { + @deprecated("Use scala.util.Try instead", "4.36.0") def defining[A, B](value: A)(f: A => B): B = f(value) @deprecated("Use scala.util.Try instead", "4.36.0")