Merge branch 'master' into slick2

Conflicts: project/build.scala src/main/scala/app/IndexController.scala src/main/scala/app/RepositorySettingsController.scala src/main/scala/model/Account.scala src/main/scala/model/BasicTemplate.scala src/main/scala/model/Issue.scala src/main/scala/model/IssueComment.scala src/main/scala/model/package.scala src/main/scala/service/IssuesService.scala src/main/scala/service/PullRequestService.scala src/main/scala/service/RepositoryService.scala src/main/scala/service/WikiService.scala src/main/scala/servlet/TransactionFilter.scala src/main/scala/util/Notifier.scala
2025-11-10 07:25:50 +01:00 · 2014-07-06 17:02:49 +09:00
parent 5c70cd654c 92e4e12655
commit 9cfa8c594b
287 changed files with 98327 additions and 61369 deletions
--- a/src/main/scala/app/AccountController.scala
+++ b/src/main/scala/app/AccountController.scala
@@ -292,7 +292,7 @@ trait AccountControllerBase extends AccountManagementControllerBase {
   * Create new repository.
   */
  post("/new", newRepositoryForm)(usersOnly { form =>
-    LockUtil.lock(s"${form.owner}/${form.name}/create"){
+    LockUtil.lock(s"${form.owner}/${form.name}"){
      if(getRepository(form.owner, form.name, context.baseUrl).isEmpty){
        val ownerAccount  = getAccountByUserName(form.owner).get
        val loginAccount  = context.loginAccount.get
@@ -355,7 +355,7 @@ trait AccountControllerBase extends AccountManagementControllerBase {
    val loginAccount   = context.loginAccount.get
    val loginUserName  = loginAccount.userName

-    LockUtil.lock(s"${loginUserName}/${repository.name}/create"){
+    LockUtil.lock(s"${loginUserName}/${repository.name}"){
      if(repository.owner == loginUserName || getRepository(loginAccount.userName, repository.name, baseUrl).isDefined){
        // redirect to the repository if repository already exists
        redirect(s"/${loginUserName}/${repository.name}")
--- a/src/main/scala/app/DashboardController.scala
+++ b/src/main/scala/app/DashboardController.scala
@@ -1,109 +1,109 @@
-package app
-
-import service._
-import util.{UsersAuthenticator, Keys}
-import util.Implicits._
-
-class DashboardController extends DashboardControllerBase
-  with IssuesService with PullRequestService with RepositoryService with AccountService
-  with UsersAuthenticator
-
-trait DashboardControllerBase extends ControllerBase {
-  self: IssuesService with PullRequestService with RepositoryService with UsersAuthenticator =>
-
-  get("/dashboard/issues/repos")(usersOnly {
-    searchIssues("all")
-  })
-
-  get("/dashboard/issues/assigned")(usersOnly {
-    searchIssues("assigned")
-  })
-
-  get("/dashboard/issues/created_by")(usersOnly {
-    searchIssues("created_by")
-  })
-
-  get("/dashboard/pulls")(usersOnly {
-    searchPullRequests("created_by", None)
-  })
-
-  get("/dashboard/pulls/owned")(usersOnly {
-    searchPullRequests("created_by", None)
-  })
-
-  get("/dashboard/pulls/public")(usersOnly {
-    searchPullRequests("not_created_by", None)
-  })
-
-  get("/dashboard/pulls/for/:owner/:repository")(usersOnly {
-    searchPullRequests("all", Some(params("owner") + "/" + params("repository")))
-  })
-
-  private def searchIssues(filter: String) = {
-    import IssuesService._
-
-    // condition
-    val condition = session.putAndGet(Keys.Session.DashboardIssues,
-      if(request.hasQueryString) IssueSearchCondition(request)
-      else session.getAs[IssueSearchCondition](Keys.Session.DashboardIssues).getOrElse(IssueSearchCondition())
-    )
-
-    val userName = context.loginAccount.get.userName
-    val repositories = getUserRepositories(userName, context.baseUrl).map(repo => repo.owner -> repo.name)
-    val filterUser = Map(filter -> userName)
-    val page = IssueSearchCondition.page(request)
-    // 
-    dashboard.html.issues(
-        issues.html.listparts(
-            searchIssue(condition, filterUser, false, (page - 1) * IssueLimit, IssueLimit, repositories: _*),
-            page,
-            countIssue(condition.copy(state = "open"), filterUser, false, repositories: _*),
-            countIssue(condition.copy(state = "closed"), filterUser, false, repositories: _*),
-            condition),
-        countIssue(condition, Map.empty, false, repositories: _*),
-        countIssue(condition, Map("assigned" -> userName), false, repositories: _*),
-        countIssue(condition, Map("created_by" -> userName), false, repositories: _*),
-        countIssueGroupByRepository(condition, filterUser, false, repositories: _*),
-        condition,
-        filter)    
-    
-  }
-
-  private def searchPullRequests(filter: String, repository: Option[String]) = {
-    import IssuesService._
-    import PullRequestService._
-
-    // condition
-    val condition = session.putAndGet(Keys.Session.DashboardPulls, {
-      if(request.hasQueryString) IssueSearchCondition(request)
-      else session.getAs[IssueSearchCondition](Keys.Session.DashboardPulls).getOrElse(IssueSearchCondition())
-    }.copy(repo = repository))
-
-    val userName = context.loginAccount.get.userName
-    val repositories = getUserRepositories(userName, context.baseUrl).map(repo => repo.owner -> repo.name)
-    val filterUser = Map(filter -> userName)
-    val page = IssueSearchCondition.page(request)
-
-    val counts = countIssueGroupByRepository(
-      IssueSearchCondition().copy(state = condition.state), Map.empty, true, repositories: _*)
-
-    dashboard.html.pulls(
-      pulls.html.listparts(
-        searchIssue(condition, filterUser, true, (page - 1) * PullRequestLimit, PullRequestLimit, repositories: _*),
-        page,
-        countIssue(condition.copy(state = "open"), filterUser, true, repositories: _*),
-        countIssue(condition.copy(state = "closed"), filterUser, true, repositories: _*),
-        condition,
-        None,
-        false),
-      getPullRequestCountGroupByUser(condition.state == "closed", userName, None),
-      getRepositoryNamesOfUser(userName).map { RepoName =>
-        (userName, RepoName, counts.collectFirst { case (_, RepoName, count) => count }.getOrElse(0))
-      }.sortBy(_._3).reverse,
-      condition,
-      filter)
-
-  }
-
-
-}
+package app
+
+import service._
+import util.{UsersAuthenticator, Keys}
+import util.Implicits._
+
+class DashboardController extends DashboardControllerBase
+  with IssuesService with PullRequestService with RepositoryService with AccountService
+  with UsersAuthenticator
+
+trait DashboardControllerBase extends ControllerBase {
+  self: IssuesService with PullRequestService with RepositoryService with UsersAuthenticator =>
+
+  get("/dashboard/issues/repos")(usersOnly {
+    searchIssues("all")
+  })
+
+  get("/dashboard/issues/assigned")(usersOnly {
+    searchIssues("assigned")
+  })
+
+  get("/dashboard/issues/created_by")(usersOnly {
+    searchIssues("created_by")
+  })
+
+  get("/dashboard/pulls")(usersOnly {
+    searchPullRequests("created_by", None)
+  })
+
+  get("/dashboard/pulls/owned")(usersOnly {
+    searchPullRequests("created_by", None)
+  })
+
+  get("/dashboard/pulls/public")(usersOnly {
+    searchPullRequests("not_created_by", None)
+  })
+
+  get("/dashboard/pulls/for/:owner/:repository")(usersOnly {
+    searchPullRequests("all", Some(params("owner") + "/" + params("repository")))
+  })
+
+  private def searchIssues(filter: String) = {
+    import IssuesService._
+
+    // condition
+    val condition = session.putAndGet(Keys.Session.DashboardIssues,
+      if(request.hasQueryString) IssueSearchCondition(request)
+      else session.getAs[IssueSearchCondition](Keys.Session.DashboardIssues).getOrElse(IssueSearchCondition())
+    )
+
+    val userName = context.loginAccount.get.userName
+    val repositories = getUserRepositories(userName, context.baseUrl).map(repo => repo.owner -> repo.name)
+    val filterUser = Map(filter -> userName)
+    val page = IssueSearchCondition.page(request)
+    // 
+    dashboard.html.issues(
+        issues.html.listparts(
+            searchIssue(condition, filterUser, false, (page - 1) * IssueLimit, IssueLimit, repositories: _*),
+            page,
+            countIssue(condition.copy(state = "open"), filterUser, false, repositories: _*),
+            countIssue(condition.copy(state = "closed"), filterUser, false, repositories: _*),
+            condition),
+        countIssue(condition, Map.empty, false, repositories: _*),
+        countIssue(condition, Map("assigned" -> userName), false, repositories: _*),
+        countIssue(condition, Map("created_by" -> userName), false, repositories: _*),
+        countIssueGroupByRepository(condition, filterUser, false, repositories: _*),
+        condition,
+        filter)    
+    
+  }
+
+  private def searchPullRequests(filter: String, repository: Option[String]) = {
+    import IssuesService._
+    import PullRequestService._
+
+    // condition
+    val condition = session.putAndGet(Keys.Session.DashboardPulls, {
+      if(request.hasQueryString) IssueSearchCondition(request)
+      else session.getAs[IssueSearchCondition](Keys.Session.DashboardPulls).getOrElse(IssueSearchCondition())
+    }.copy(repo = repository))
+
+    val userName = context.loginAccount.get.userName
+    val repositories = getUserRepositories(userName, context.baseUrl).map(repo => repo.owner -> repo.name)
+    val filterUser = Map(filter -> userName)
+    val page = IssueSearchCondition.page(request)
+
+    val counts = countIssueGroupByRepository(
+      IssueSearchCondition().copy(state = condition.state), Map.empty, true, repositories: _*)
+
+    dashboard.html.pulls(
+      pulls.html.listparts(
+        searchIssue(condition, filterUser, true, (page - 1) * PullRequestLimit, PullRequestLimit, repositories: _*),
+        page,
+        countIssue(condition.copy(state = "open"), filterUser, true, repositories: _*),
+        countIssue(condition.copy(state = "closed"), filterUser, true, repositories: _*),
+        condition,
+        None,
+        false),
+      getPullRequestCountGroupByUser(condition.state == "closed", None, None),
+      getRepositoryNamesOfUser(userName).map { RepoName =>
+        (userName, RepoName, counts.collectFirst { case (_, RepoName, count) => count }.getOrElse(0))
+      }.sortBy(_._3).reverse,
+      condition,
+      filter)
+
+  }
+
+
+}
--- a/src/main/scala/app/IndexController.scala
+++ b/src/main/scala/app/IndexController.scala
@@ -22,8 +22,8 @@ trait IndexControllerBase extends ControllerBase {
    val loginAccount = context.loginAccount

    html.index(getRecentActivities(),
-      getVisibleRepositories(loginAccount, context.baseUrl),
-      loginAccount.map{ account => getUserRepositories(account.userName, context.baseUrl) }.getOrElse(Nil)
+      getVisibleRepositories(loginAccount, context.baseUrl, withoutPhysicalInfo = true),
+      loginAccount.map{ account => getUserRepositories(account.userName, context.baseUrl, withoutPhysicalInfo = true) }.getOrElse(Nil)
    )
  }

--- a/src/main/scala/app/IssuesController.scala
+++ b/src/main/scala/app/IssuesController.scala
@@ -1,403 +1,403 @@
-package app
-
-import jp.sf.amateras.scalatra.forms._
-
-import service._
-import IssuesService._
-import util._
-import util.Implicits._
-import util.ControlUtil._
-import org.scalatra.Ok
-import model.Issue
-
-class IssuesController extends IssuesControllerBase
-  with IssuesService with RepositoryService with AccountService with LabelsService with MilestonesService with ActivityService
-  with ReadableUsersAuthenticator with ReferrerAuthenticator with CollaboratorsAuthenticator
-
-trait IssuesControllerBase extends ControllerBase {
-  self: IssuesService with RepositoryService with AccountService with LabelsService with MilestonesService with ActivityService
-    with ReadableUsersAuthenticator with ReferrerAuthenticator with CollaboratorsAuthenticator =>
-
-  case class IssueCreateForm(title: String, content: Option[String],
-    assignedUserName: Option[String], milestoneId: Option[Int], labelNames: Option[String])
-  case class IssueEditForm(title: String, content: Option[String])
-  case class CommentForm(issueId: Int, content: String)
-  case class IssueStateForm(issueId: Int, content: Option[String])
-
-  val issueCreateForm = mapping(
-      "title"            -> trim(label("Title", text(required))),
-      "content"          -> trim(optional(text())),
-      "assignedUserName" -> trim(optional(text())),
-      "milestoneId"      -> trim(optional(number())),
-      "labelNames"       -> trim(optional(text()))
-    )(IssueCreateForm.apply)
-
-  val issueEditForm = mapping(
-      "title"   -> trim(label("Title", text(required))),
-      "content" -> trim(optional(text()))
-    )(IssueEditForm.apply)
-
-  val commentForm = mapping(
-      "issueId" -> label("Issue Id", number()),
-      "content" -> trim(label("Comment", text(required)))
-    )(CommentForm.apply)
-
-  val issueStateForm = mapping(
-      "issueId" -> label("Issue Id", number()),
-      "content" -> trim(optional(text()))
-    )(IssueStateForm.apply)
-
-  get("/:owner/:repository/issues")(referrersOnly {
-    searchIssues("all", _)
-  })
-
-  get("/:owner/:repository/issues/assigned/:userName")(referrersOnly {
-    searchIssues("assigned", _)
-  })
-
-  get("/:owner/:repository/issues/created_by/:userName")(referrersOnly {
-    searchIssues("created_by", _)
-  })
-
-  get("/:owner/:repository/issues/:id")(referrersOnly { repository =>
-    defining(repository.owner, repository.name, params("id")){ case (owner, name, issueId) =>
-      getIssue(owner, name, issueId) map {
-        issues.html.issue(
-          _,
-          getComments(owner, name, issueId.toInt),
-          getIssueLabels(owner, name, issueId.toInt),
-          (getCollaborators(owner, name) ::: (if(getAccountByUserName(owner).get.isGroupAccount) Nil else List(owner))).sorted,
-          getMilestonesWithIssueCount(owner, name),
-          getLabels(owner, name),
-          hasWritePermission(owner, name, context.loginAccount),
-          repository)
-      } getOrElse NotFound
-    }
-  })
-
-  get("/:owner/:repository/issues/new")(readableUsersOnly { repository =>
-    defining(repository.owner, repository.name){ case (owner, name) =>
-      issues.html.create(
-        (getCollaborators(owner, name) ::: (if(getAccountByUserName(owner).get.isGroupAccount) Nil else List(owner))).sorted,
-          getMilestones(owner, name),
-          getLabels(owner, name),
-          hasWritePermission(owner, name, context.loginAccount),
-          repository)
-    }
-  })
-
-  post("/:owner/:repository/issues/new", issueCreateForm)(readableUsersOnly { (form, repository) =>
-    defining(repository.owner, repository.name){ case (owner, name) =>
-      val writable = hasWritePermission(owner, name, context.loginAccount)
-      val userName = context.loginAccount.get.userName
-
-      // insert issue
-      val issueId = createIssue(owner, name, userName, form.title, form.content,
-        if(writable) form.assignedUserName else None,
-        if(writable) form.milestoneId else None)
-
-      // insert labels
-      if(writable){
-        form.labelNames.map { value =>
-          val labels = getLabels(owner, name)
-          value.split(",").foreach { labelName =>
-            labels.find(_.labelName == labelName).map { label =>
-              registerIssueLabel(owner, name, issueId, label.labelId)
-            }
-          }
-        }
-      }
-
-      // record activity
-      recordCreateIssueActivity(owner, name, userName, issueId, form.title)
-
-      // extract references and create refer comment
-      getIssue(owner, name, issueId.toString).foreach { issue =>
-        createReferComment(owner, name, issue, form.title + " " + form.content.getOrElse(""))
-      }
-
-      // notifications
-      Notifier().toNotify(repository, issueId, form.content.getOrElse("")){
-        Notifier.msgIssue(s"${context.baseUrl}/${owner}/${name}/issues/${issueId}")
-      }
-
-      redirect(s"/${owner}/${name}/issues/${issueId}")
-    }
-  })
-
-  ajaxPost("/:owner/:repository/issues/edit/:id", issueEditForm)(readableUsersOnly { (form, repository) =>
-    defining(repository.owner, repository.name){ case (owner, name) =>
-      getIssue(owner, name, params("id")).map { issue =>
-        if(isEditable(owner, name, issue.openedUserName)){
-          // update issue
-          updateIssue(owner, name, issue.issueId, form.title, form.content)
-          // extract references and create refer comment
-          createReferComment(owner, name, issue, form.title + " " + form.content.getOrElse(""))
-
-          redirect(s"/${owner}/${name}/issues/_data/${issue.issueId}")
-        } else Unauthorized
-      } getOrElse NotFound
-    }
-  })
-
-  post("/:owner/:repository/issue_comments/new", commentForm)(readableUsersOnly { (form, repository) =>
-    handleComment(form.issueId, Some(form.content), repository)() 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) =>
-    handleComment(form.issueId, form.content, repository)() 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(isEditable(owner, name, comment.commentedUserName)){
-          updateComment(comment.commentId, form.content)
-          redirect(s"/${owner}/${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(isEditable(owner, name, comment.commentedUserName)){
-          Ok(deleteComment(comment.commentId))
-        } else Unauthorized
-      } getOrElse NotFound
-    }
-  })
-
-  ajaxGet("/:owner/:repository/issues/_data/:id")(readableUsersOnly { repository =>
-    getIssue(repository.owner, repository.name, params("id")) map { x =>
-      if(isEditable(x.userName, x.repositoryName, x.openedUserName)){
-        params.get("dataType") collect {
-          case t if t == "html" => issues.html.editissue(
-              x.title, x.content, x.issueId, x.userName, x.repositoryName)
-        } getOrElse {
-          contentType = formats("json")
-          org.json4s.jackson.Serialization.write(
-              Map("title"   -> x.title,
-                  "content" -> view.Markdown.toHtml(x.content getOrElse "No description given.",
-                      repository, false, true)
-              ))
-        }
-      } else Unauthorized
-    } getOrElse NotFound
-  })
-
-  ajaxGet("/:owner/:repository/issue_comments/_data/:id")(readableUsersOnly { repository =>
-    getComment(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" => issues.html.editcomment(
-              x.content, x.commentId, x.userName, x.repositoryName)
-        } getOrElse {
-          contentType = formats("json")
-          org.json4s.jackson.Serialization.write(
-              Map("content" -> view.Markdown.toHtml(x.content,
-                  repository, false, true)
-              ))
-        }
-      } else Unauthorized
-    } getOrElse NotFound
-  })
-
-  ajaxPost("/:owner/:repository/issues/:id/label/new")(collaboratorsOnly { repository =>
-    defining(params("id").toInt){ issueId =>
-      registerIssueLabel(repository.owner, repository.name, issueId, params("labelId").toInt)
-      issues.html.labellist(getIssueLabels(repository.owner, repository.name, issueId))
-    }
-  })
-
-  ajaxPost("/:owner/:repository/issues/:id/label/delete")(collaboratorsOnly { repository =>
-    defining(params("id").toInt){ issueId =>
-      deleteIssueLabel(repository.owner, repository.name, issueId, params("labelId").toInt)
-      issues.html.labellist(getIssueLabels(repository.owner, repository.name, issueId))
-    }
-  })
-
-  ajaxPost("/:owner/:repository/issues/:id/assign")(collaboratorsOnly { repository =>
-    updateAssignedUserName(repository.owner, repository.name, params("id").toInt, assignedUserName("assignedUserName"))
-    Ok("updated")
-  })
-
-  ajaxPost("/:owner/:repository/issues/:id/milestone")(collaboratorsOnly { repository =>
-    updateMilestoneId(repository.owner, repository.name, params("id").toInt, milestoneId("milestoneId"))
-    milestoneId("milestoneId").map { milestoneId =>
-      getMilestonesWithIssueCount(repository.owner, repository.name)
-          .find(_._1.milestoneId == milestoneId).map { case (_, openCount, closeCount) =>
-        issues.milestones.html.progress(openCount + closeCount, closeCount, false)
-      } getOrElse NotFound
-    } getOrElse Ok()
-  })
-
-  post("/:owner/:repository/issues/batchedit/state")(collaboratorsOnly { repository =>
-    defining(params.get("value")){ action =>
-      executeBatch(repository) {
-        handleComment(_, None, repository)( _ => action)
-      }
-    }
-  })
-
-  post("/:owner/:repository/issues/batchedit/label")(collaboratorsOnly { repository =>
-    params("value").toIntOpt.map{ labelId =>
-      executeBatch(repository) { issueId =>
-        getIssueLabel(repository.owner, repository.name, issueId, labelId) getOrElse {
-          registerIssueLabel(repository.owner, repository.name, issueId, labelId)
-        }
-      }
-    } getOrElse NotFound
-  })
-
-  post("/:owner/:repository/issues/batchedit/assign")(collaboratorsOnly { repository =>
-    defining(assignedUserName("value")){ value =>
-      executeBatch(repository) {
-        updateAssignedUserName(repository.owner, repository.name, _, value)
-      }
-    }
-  })
-
-  post("/:owner/:repository/issues/batchedit/milestone")(collaboratorsOnly { repository =>
-    defining(milestoneId("value")){ value =>
-      executeBatch(repository) {
-        updateMilestoneId(repository.owner, repository.name, _, value)
-      }
-    }
-  })
-
-  get("/:owner/:repository/_attached/:file")(referrersOnly { repository =>
-    (Directory.getAttachedDir(repository.owner, repository.name) match {
-      case dir if(dir.exists && dir.isDirectory) =>
-        dir.listFiles.find(_.getName.startsWith(params("file") + ".")).map { file =>
-          contentType = FileUtil.getMimeType(file.getName)
-          file
-        }
-      case _ => None
-    }) getOrElse NotFound
-  })
-
-  val assignedUserName = (key: String) => params.get(key) filter (_.trim != "")
-  val milestoneId: String => Option[Int] = (key: String) => params.get(key).flatMap(_.toIntOpt)
-
-  private def isEditable(owner: String, repository: String, author: String)(implicit context: app.Context): Boolean =
-    hasWritePermission(owner, repository, context.loginAccount) || author == context.loginAccount.get.userName
-
-  private def executeBatch(repository: RepositoryService.RepositoryInfo)(execute: Int => Unit) = {
-    params("checked").split(',') map(_.toInt) foreach execute
-    redirect(s"/${repository.owner}/${repository.name}/issues")
-  }
-
-  private def createReferComment(owner: String, repository: String, fromIssue: Issue, message: String) = {
-    StringUtil.extractIssueId(message).foreach { issueId =>
-      if(getIssue(owner, repository, issueId).isDefined){
-        createComment(owner, repository, context.loginAccount.get.userName, issueId.toInt,
-                      fromIssue.issueId + ":" + fromIssue.title, "refer")
-      }
-    }
-  }
-
-  /**
-   * @see [[https://github.com/takezoe/gitbucket/wiki/CommentAction]]
-   */
-  private def handleComment(issueId: Int, content: Option[String], repository: RepositoryService.RepositoryInfo)
-      (getAction: model.Issue => Option[String] =
-           p1 => params.get("action").filter(_ => isEditable(p1.userName, p1.repositoryName, p1.openedUserName))) = {
-
-    defining(repository.owner, repository.name){ case (owner, name) =>
-      val userName = context.loginAccount.get.userName
-
-      getIssue(owner, name, issueId.toString) map { issue =>
-        val (action, recordActivity) =
-          getAction(issue)
-            .collect {
-            case "close"  => true  -> (Some("close")  ->
-              Some(if(issue.isPullRequest) recordClosePullRequestActivity _ else recordCloseIssueActivity _))
-            case "reopen" => false -> (Some("reopen") ->
-              Some(recordReopenIssueActivity _))
-          }
-            .map { case (closed, t) =>
-            updateClosed(owner, name, issueId, closed)
-            t
-          }
-            .getOrElse(None -> None)
-
-        val commentId = content
-          .map       ( _ -> action.map( _ + "_comment" ).getOrElse("comment") )
-          .getOrElse ( action.get.capitalize -> action.get )
-        match {
-          case (content, action) => createComment(owner, name, userName, issueId, content, action)
-        }
-
-        // record activity
-        content foreach {
-          (if(issue.isPullRequest) recordCommentPullRequestActivity _ else recordCommentIssueActivity _)
-          (owner, name, userName, issueId, _)
-        }
-        recordActivity foreach ( _ (owner, name, userName, issueId, issue.title) )
-
-        // extract references and create refer comment
-        content.map { content =>
-          createReferComment(owner, name, issue, content)
-        }
-
-        // notifications
-        Notifier() match {
-          case f =>
-            content foreach {
-              f.toNotify(repository, issueId, _){
-                Notifier.msgComment(s"${context.baseUrl}/${owner}/${name}/${
-                  if(issue.isPullRequest) "pull" else "issues"}/${issueId}#comment-${commentId}")
-              }
-            }
-            action foreach {
-              f.toNotify(repository, issueId, _){
-                Notifier.msgStatus(s"${context.baseUrl}/${owner}/${name}/issues/${issueId}")
-              }
-            }
-        }
-
-        issue -> commentId
-      }
-    }
-  }
-
-  private def searchIssues(filter: String, repository: RepositoryService.RepositoryInfo) = {
-    defining(repository.owner, repository.name){ case (owner, repoName) =>
-      val filterUser = Map(filter -> params.getOrElse("userName", ""))
-      val page       = IssueSearchCondition.page(request)
-      val sessionKey = Keys.Session.Issues(owner, repoName)
-
-      // retrieve search condition
-      val condition = session.putAndGet(sessionKey,
-        if(request.hasQueryString) IssueSearchCondition(request)
-        else session.getAs[IssueSearchCondition](sessionKey).getOrElse(IssueSearchCondition())
-      )
-
-      issues.html.list(
-          searchIssue(condition, filterUser, false, (page - 1) * IssueLimit, IssueLimit, owner -> repoName),
-          page,
-          (getCollaborators(owner, repoName) :+ owner).sorted,
-          getMilestones(owner, repoName),
-          getLabels(owner, repoName),
-          countIssue(condition.copy(state = "open"), filterUser, false, owner -> repoName),
-          countIssue(condition.copy(state = "closed"), filterUser, false, owner -> repoName),
-          countIssue(condition, Map.empty, false, owner -> repoName),
-          context.loginAccount.map(x => countIssue(condition, Map("assigned" -> x.userName), false, owner -> repoName)),
-          context.loginAccount.map(x => countIssue(condition, Map("created_by" -> x.userName), false, owner -> repoName)),
-          countIssueGroupByLabels(owner, repoName, condition, filterUser),
-          condition,
-          filter,
-          repository,
-          hasWritePermission(owner, repoName, context.loginAccount))
-    }
-  }
-
-}
+package app
+
+import jp.sf.amateras.scalatra.forms._
+
+import service._
+import IssuesService._
+import util._
+import util.Implicits._
+import util.ControlUtil._
+import org.scalatra.Ok
+import model.Issue
+
+class IssuesController extends IssuesControllerBase
+  with IssuesService with RepositoryService with AccountService with LabelsService with MilestonesService with ActivityService
+  with ReadableUsersAuthenticator with ReferrerAuthenticator with CollaboratorsAuthenticator
+
+trait IssuesControllerBase extends ControllerBase {
+  self: IssuesService with RepositoryService with AccountService with LabelsService with MilestonesService with ActivityService
+    with ReadableUsersAuthenticator with ReferrerAuthenticator with CollaboratorsAuthenticator =>
+
+  case class IssueCreateForm(title: String, content: Option[String],
+    assignedUserName: Option[String], milestoneId: Option[Int], labelNames: Option[String])
+  case class IssueEditForm(title: String, content: Option[String])
+  case class CommentForm(issueId: Int, content: String)
+  case class IssueStateForm(issueId: Int, content: Option[String])
+
+  val issueCreateForm = mapping(
+      "title"            -> trim(label("Title", text(required))),
+      "content"          -> trim(optional(text())),
+      "assignedUserName" -> trim(optional(text())),
+      "milestoneId"      -> trim(optional(number())),
+      "labelNames"       -> trim(optional(text()))
+    )(IssueCreateForm.apply)
+
+  val issueEditForm = mapping(
+      "title"   -> trim(label("Title", text(required))),
+      "content" -> trim(optional(text()))
+    )(IssueEditForm.apply)
+
+  val commentForm = mapping(
+      "issueId" -> label("Issue Id", number()),
+      "content" -> trim(label("Comment", text(required)))
+    )(CommentForm.apply)
+
+  val issueStateForm = mapping(
+      "issueId" -> label("Issue Id", number()),
+      "content" -> trim(optional(text()))
+    )(IssueStateForm.apply)
+
+  get("/:owner/:repository/issues")(referrersOnly {
+    searchIssues("all", _)
+  })
+
+  get("/:owner/:repository/issues/assigned/:userName")(referrersOnly {
+    searchIssues("assigned", _)
+  })
+
+  get("/:owner/:repository/issues/created_by/:userName")(referrersOnly {
+    searchIssues("created_by", _)
+  })
+
+  get("/:owner/:repository/issues/:id")(referrersOnly { repository =>
+    defining(repository.owner, repository.name, params("id")){ case (owner, name, issueId) =>
+      getIssue(owner, name, issueId) map {
+        issues.html.issue(
+          _,
+          getComments(owner, name, issueId.toInt),
+          getIssueLabels(owner, name, issueId.toInt),
+          (getCollaborators(owner, name) ::: (if(getAccountByUserName(owner).get.isGroupAccount) Nil else List(owner))).sorted,
+          getMilestonesWithIssueCount(owner, name),
+          getLabels(owner, name),
+          hasWritePermission(owner, name, context.loginAccount),
+          repository)
+      } getOrElse NotFound
+    }
+  })
+
+  get("/:owner/:repository/issues/new")(readableUsersOnly { repository =>
+    defining(repository.owner, repository.name){ case (owner, name) =>
+      issues.html.create(
+        (getCollaborators(owner, name) ::: (if(getAccountByUserName(owner).get.isGroupAccount) Nil else List(owner))).sorted,
+          getMilestones(owner, name),
+          getLabels(owner, name),
+          hasWritePermission(owner, name, context.loginAccount),
+          repository)
+    }
+  })
+
+  post("/:owner/:repository/issues/new", issueCreateForm)(readableUsersOnly { (form, repository) =>
+    defining(repository.owner, repository.name){ case (owner, name) =>
+      val writable = hasWritePermission(owner, name, context.loginAccount)
+      val userName = context.loginAccount.get.userName
+
+      // insert issue
+      val issueId = createIssue(owner, name, userName, form.title, form.content,
+        if(writable) form.assignedUserName else None,
+        if(writable) form.milestoneId else None)
+
+      // insert labels
+      if(writable){
+        form.labelNames.map { value =>
+          val labels = getLabels(owner, name)
+          value.split(",").foreach { labelName =>
+            labels.find(_.labelName == labelName).map { label =>
+              registerIssueLabel(owner, name, issueId, label.labelId)
+            }
+          }
+        }
+      }
+
+      // record activity
+      recordCreateIssueActivity(owner, name, userName, issueId, form.title)
+
+      // extract references and create refer comment
+      getIssue(owner, name, issueId.toString).foreach { issue =>
+        createReferComment(owner, name, issue, form.title + " " + form.content.getOrElse(""))
+      }
+
+      // notifications
+      Notifier().toNotify(repository, issueId, form.content.getOrElse("")){
+        Notifier.msgIssue(s"${context.baseUrl}/${owner}/${name}/issues/${issueId}")
+      }
+
+      redirect(s"/${owner}/${name}/issues/${issueId}")
+    }
+  })
+
+  ajaxPost("/:owner/:repository/issues/edit/:id", issueEditForm)(readableUsersOnly { (form, repository) =>
+    defining(repository.owner, repository.name){ case (owner, name) =>
+      getIssue(owner, name, params("id")).map { issue =>
+        if(isEditable(owner, name, issue.openedUserName)){
+          // update issue
+          updateIssue(owner, name, issue.issueId, form.title, form.content)
+          // extract references and create refer comment
+          createReferComment(owner, name, issue, form.title + " " + form.content.getOrElse(""))
+
+          redirect(s"/${owner}/${name}/issues/_data/${issue.issueId}")
+        } else Unauthorized
+      } getOrElse NotFound
+    }
+  })
+
+  post("/:owner/:repository/issue_comments/new", commentForm)(readableUsersOnly { (form, repository) =>
+    handleComment(form.issueId, Some(form.content), repository)() 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) =>
+    handleComment(form.issueId, form.content, repository)() 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(isEditable(owner, name, comment.commentedUserName)){
+          updateComment(comment.commentId, form.content)
+          redirect(s"/${owner}/${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(isEditable(owner, name, comment.commentedUserName)){
+          Ok(deleteComment(comment.commentId))
+        } else Unauthorized
+      } getOrElse NotFound
+    }
+  })
+
+  ajaxGet("/:owner/:repository/issues/_data/:id")(readableUsersOnly { repository =>
+    getIssue(repository.owner, repository.name, params("id")) map { x =>
+      if(isEditable(x.userName, x.repositoryName, x.openedUserName)){
+        params.get("dataType") collect {
+          case t if t == "html" => issues.html.editissue(
+              x.title, x.content, x.issueId, x.userName, x.repositoryName)
+        } getOrElse {
+          contentType = formats("json")
+          org.json4s.jackson.Serialization.write(
+              Map("title"   -> x.title,
+                  "content" -> view.Markdown.toHtml(x.content getOrElse "No description given.",
+                      repository, false, true)
+              ))
+        }
+      } else Unauthorized
+    } getOrElse NotFound
+  })
+
+  ajaxGet("/:owner/:repository/issue_comments/_data/:id")(readableUsersOnly { repository =>
+    getComment(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" => issues.html.editcomment(
+              x.content, x.commentId, x.userName, x.repositoryName)
+        } getOrElse {
+          contentType = formats("json")
+          org.json4s.jackson.Serialization.write(
+              Map("content" -> view.Markdown.toHtml(x.content,
+                  repository, false, true)
+              ))
+        }
+      } else Unauthorized
+    } getOrElse NotFound
+  })
+
+  ajaxPost("/:owner/:repository/issues/:id/label/new")(collaboratorsOnly { repository =>
+    defining(params("id").toInt){ issueId =>
+      registerIssueLabel(repository.owner, repository.name, issueId, params("labelId").toInt)
+      issues.html.labellist(getIssueLabels(repository.owner, repository.name, issueId))
+    }
+  })
+
+  ajaxPost("/:owner/:repository/issues/:id/label/delete")(collaboratorsOnly { repository =>
+    defining(params("id").toInt){ issueId =>
+      deleteIssueLabel(repository.owner, repository.name, issueId, params("labelId").toInt)
+      issues.html.labellist(getIssueLabels(repository.owner, repository.name, issueId))
+    }
+  })
+
+  ajaxPost("/:owner/:repository/issues/:id/assign")(collaboratorsOnly { repository =>
+    updateAssignedUserName(repository.owner, repository.name, params("id").toInt, assignedUserName("assignedUserName"))
+    Ok("updated")
+  })
+
+  ajaxPost("/:owner/:repository/issues/:id/milestone")(collaboratorsOnly { repository =>
+    updateMilestoneId(repository.owner, repository.name, params("id").toInt, milestoneId("milestoneId"))
+    milestoneId("milestoneId").map { milestoneId =>
+      getMilestonesWithIssueCount(repository.owner, repository.name)
+          .find(_._1.milestoneId == milestoneId).map { case (_, openCount, closeCount) =>
+        issues.milestones.html.progress(openCount + closeCount, closeCount, false)
+      } getOrElse NotFound
+    } getOrElse Ok()
+  })
+
+  post("/:owner/:repository/issues/batchedit/state")(collaboratorsOnly { repository =>
+    defining(params.get("value")){ action =>
+      executeBatch(repository) {
+        handleComment(_, None, repository)( _ => action)
+      }
+    }
+  })
+
+  post("/:owner/:repository/issues/batchedit/label")(collaboratorsOnly { repository =>
+    params("value").toIntOpt.map{ labelId =>
+      executeBatch(repository) { issueId =>
+        getIssueLabel(repository.owner, repository.name, issueId, labelId) getOrElse {
+          registerIssueLabel(repository.owner, repository.name, issueId, labelId)
+        }
+      }
+    } getOrElse NotFound
+  })
+
+  post("/:owner/:repository/issues/batchedit/assign")(collaboratorsOnly { repository =>
+    defining(assignedUserName("value")){ value =>
+      executeBatch(repository) {
+        updateAssignedUserName(repository.owner, repository.name, _, value)
+      }
+    }
+  })
+
+  post("/:owner/:repository/issues/batchedit/milestone")(collaboratorsOnly { repository =>
+    defining(milestoneId("value")){ value =>
+      executeBatch(repository) {
+        updateMilestoneId(repository.owner, repository.name, _, value)
+      }
+    }
+  })
+
+  get("/:owner/:repository/_attached/:file")(referrersOnly { repository =>
+    (Directory.getAttachedDir(repository.owner, repository.name) match {
+      case dir if(dir.exists && dir.isDirectory) =>
+        dir.listFiles.find(_.getName.startsWith(params("file") + ".")).map { file =>
+          contentType = FileUtil.getMimeType(file.getName)
+          file
+        }
+      case _ => None
+    }) getOrElse NotFound
+  })
+
+  val assignedUserName = (key: String) => params.get(key) filter (_.trim != "")
+  val milestoneId: String => Option[Int] = (key: String) => params.get(key).flatMap(_.toIntOpt)
+
+  private def isEditable(owner: String, repository: String, author: String)(implicit context: app.Context): Boolean =
+    hasWritePermission(owner, repository, context.loginAccount) || author == context.loginAccount.get.userName
+
+  private def executeBatch(repository: RepositoryService.RepositoryInfo)(execute: Int => Unit) = {
+    params("checked").split(',') map(_.toInt) foreach execute
+    redirect(s"/${repository.owner}/${repository.name}/issues")
+  }
+
+  private def createReferComment(owner: String, repository: String, fromIssue: Issue, message: String) = {
+    StringUtil.extractIssueId(message).foreach { issueId =>
+      if(getIssue(owner, repository, issueId).isDefined){
+        createComment(owner, repository, context.loginAccount.get.userName, issueId.toInt,
+                      fromIssue.issueId + ":" + fromIssue.title, "refer")
+      }
+    }
+  }
+
+  /**
+   * @see [[https://github.com/takezoe/gitbucket/wiki/CommentAction]]
+   */
+  private def handleComment(issueId: Int, content: Option[String], repository: RepositoryService.RepositoryInfo)
+      (getAction: model.Issue => Option[String] =
+           p1 => params.get("action").filter(_ => isEditable(p1.userName, p1.repositoryName, p1.openedUserName))) = {
+
+    defining(repository.owner, repository.name){ case (owner, name) =>
+      val userName = context.loginAccount.get.userName
+
+      getIssue(owner, name, issueId.toString) map { issue =>
+        val (action, recordActivity) =
+          getAction(issue)
+            .collect {
+            case "close"  => true  -> (Some("close")  ->
+              Some(if(issue.isPullRequest) recordClosePullRequestActivity _ else recordCloseIssueActivity _))
+            case "reopen" => false -> (Some("reopen") ->
+              Some(recordReopenIssueActivity _))
+          }
+            .map { case (closed, t) =>
+            updateClosed(owner, name, issueId, closed)
+            t
+          }
+            .getOrElse(None -> None)
+
+        val commentId = content
+          .map       ( _ -> action.map( _ + "_comment" ).getOrElse("comment") )
+          .getOrElse ( action.get.capitalize -> action.get )
+        match {
+          case (content, action) => createComment(owner, name, userName, issueId, content, action)
+        }
+
+        // record activity
+        content foreach {
+          (if(issue.isPullRequest) recordCommentPullRequestActivity _ else recordCommentIssueActivity _)
+          (owner, name, userName, issueId, _)
+        }
+        recordActivity foreach ( _ (owner, name, userName, issueId, issue.title) )
+
+        // extract references and create refer comment
+        content.map { content =>
+          createReferComment(owner, name, issue, content)
+        }
+
+        // notifications
+        Notifier() match {
+          case f =>
+            content foreach {
+              f.toNotify(repository, issueId, _){
+                Notifier.msgComment(s"${context.baseUrl}/${owner}/${name}/${
+                  if(issue.isPullRequest) "pull" else "issues"}/${issueId}#comment-${commentId}")
+              }
+            }
+            action foreach {
+              f.toNotify(repository, issueId, _){
+                Notifier.msgStatus(s"${context.baseUrl}/${owner}/${name}/issues/${issueId}")
+              }
+            }
+        }
+
+        issue -> commentId
+      }
+    }
+  }
+
+  private def searchIssues(filter: String, repository: RepositoryService.RepositoryInfo) = {
+    defining(repository.owner, repository.name){ case (owner, repoName) =>
+      val filterUser = Map(filter -> params.getOrElse("userName", ""))
+      val page       = IssueSearchCondition.page(request)
+      val sessionKey = Keys.Session.Issues(owner, repoName)
+
+      // retrieve search condition
+      val condition = session.putAndGet(sessionKey,
+        if(request.hasQueryString) IssueSearchCondition(request)
+        else session.getAs[IssueSearchCondition](sessionKey).getOrElse(IssueSearchCondition())
+      )
+
+      issues.html.list(
+          searchIssue(condition, filterUser, false, (page - 1) * IssueLimit, IssueLimit, owner -> repoName),
+          page,
+          (getCollaborators(owner, repoName) :+ owner).sorted,
+          getMilestones(owner, repoName),
+          getLabels(owner, repoName),
+          countIssue(condition.copy(state = "open"), filterUser, false, owner -> repoName),
+          countIssue(condition.copy(state = "closed"), filterUser, false, owner -> repoName),
+          countIssue(condition, Map.empty, false, owner -> repoName),
+          context.loginAccount.map(x => countIssue(condition, Map("assigned" -> x.userName), false, owner -> repoName)),
+          context.loginAccount.map(x => countIssue(condition, Map("created_by" -> x.userName), false, owner -> repoName)),
+          countIssueGroupByLabels(owner, repoName, condition, filterUser),
+          condition,
+          filter,
+          repository,
+          hasWritePermission(owner, repoName, context.loginAccount))
+    }
+  }
+
+}
--- a/src/main/scala/app/PullRequestsController.scala
+++ b/src/main/scala/app/PullRequestsController.scala
@@ -13,7 +13,6 @@ import org.eclipse.jgit.lib.{ObjectId, CommitBuilder, PersonIdent}
 import service.IssuesService._
 import service.PullRequestService._
 import util.JGitUtil.DiffInfo
-import service.RepositoryService.RepositoryTreeNode
 import util.JGitUtil.CommitInfo
 import org.slf4j.LoggerFactory
 import org.eclipse.jgit.merge.MergeStrategy
@@ -124,7 +123,7 @@ trait PullRequestsControllerBase extends ControllerBase {
    params("id").toIntOpt.flatMap { issueId =>
      val owner = repository.owner
      val name  = repository.name
-      LockUtil.lock(s"${owner}/${name}/merge"){
+      LockUtil.lock(s"${owner}/${name}"){
        getPullRequest(owner, name, issueId).map { case (issue, pullreq) =>
          using(Git.open(getRepositoryDir(owner, name))) { git =>
            // mark issue as merged and close.
@@ -367,7 +366,7 @@ trait PullRequestsControllerBase extends ControllerBase {
   */
  private def checkConflict(userName: String, repositoryName: String, branch: String,
                            requestUserName: String, requestRepositoryName: String, requestBranch: String): Boolean = {
-    LockUtil.lock(s"${userName}/${repositoryName}/merge-check"){
+    LockUtil.lock(s"${userName}/${repositoryName}"){
      using(Git.open(getRepositoryDir(requestUserName, requestRepositoryName))) { git =>
        val remoteRefName = s"refs/heads/${branch}"
        val tmpRefName = s"refs/merge-check/${userName}/${branch}"
@@ -403,7 +402,7 @@ trait PullRequestsControllerBase extends ControllerBase {
  private def checkConflictInPullRequest(userName: String, repositoryName: String, branch: String,
                                         requestUserName: String, requestRepositoryName: String, requestBranch: String,
                                         issueId: Int): Boolean = {
-    LockUtil.lock(s"${userName}/${repositoryName}/merge") {
+    LockUtil.lock(s"${userName}/${repositoryName}") {
      using(Git.open(getRepositoryDir(userName, repositoryName))) { git =>
        // merge
        val merger = MergeStrategy.RECURSIVE.newMerger(git.getRepository, true)
@@ -466,7 +465,7 @@ trait PullRequestsControllerBase extends ControllerBase {

      pulls.html.list(
        searchIssue(condition, filterUser, true, (page - 1) * PullRequestLimit, PullRequestLimit, owner -> repoName),
-        getPullRequestCountGroupByUser(condition.state == "closed", owner, Some(repoName)),
+        getPullRequestCountGroupByUser(condition.state == "closed", Some(owner), Some(repoName)),
        userName,
        page,
        countIssue(condition.copy(state = "open"  ), filterUser, true, owner -> repoName),
--- a/src/main/scala/app/RepositorySettingsController.scala
+++ b/src/main/scala/app/RepositorySettingsController.scala
@@ -4,12 +4,14 @@ import service._
 import util.Directory._
 import util.ControlUtil._
 import util.Implicits._
-import util.{UsersAuthenticator, OwnerAuthenticator}
+import util.{LockUtil, UsersAuthenticator, OwnerAuthenticator}
 import util.JGitUtil.CommitInfo
 import jp.sf.amateras.scalatra.forms._
 import org.apache.commons.io.FileUtils
 import org.scalatra.i18n.Messages
 import service.WebHookService.WebHookPayload
+import util.JGitUtil.CommitInfo
+import util.ControlUtil._
 import org.eclipse.jgit.api.Git

 class RepositorySettingsController extends RepositorySettingsControllerBase
@@ -186,15 +188,17 @@ trait RepositorySettingsControllerBase extends ControllerBase {
  post("/:owner/:repository/settings/transfer", transferForm)(ownerOnly { (form, repository) =>
    // Change repository owner
    if(repository.owner != form.newOwner){
-      // Update database
-      renameRepository(repository.owner, repository.name, form.newOwner, repository.name)
-      // Move git repository
-      defining(getRepositoryDir(repository.owner, repository.name)){ dir =>
-        FileUtils.moveDirectory(dir, getRepositoryDir(form.newOwner, repository.name))
-      }
-      // Move wiki repository
-      defining(getWikiRepositoryDir(repository.owner, repository.name)){ dir =>
-        FileUtils.moveDirectory(dir, getWikiRepositoryDir(form.newOwner, repository.name))
+      LockUtil.lock(s"${repository.owner}/${repository.name}"){
+        // Update database
+        renameRepository(repository.owner, repository.name, form.newOwner, repository.name)
+        // Move git repository
+        defining(getRepositoryDir(repository.owner, repository.name)){ dir =>
+          FileUtils.moveDirectory(dir, getRepositoryDir(form.newOwner, repository.name))
+        }
+        // Move wiki repository
+        defining(getWikiRepositoryDir(repository.owner, repository.name)){ dir =>
+          FileUtils.moveDirectory(dir, getWikiRepositoryDir(form.newOwner, repository.name))
+        }
      }
    }
    redirect(s"/${form.newOwner}/${repository.name}")
@@ -204,12 +208,13 @@ trait RepositorySettingsControllerBase extends ControllerBase {
   * Delete the repository.
   */
  post("/:owner/:repository/settings/delete")(ownerOnly { repository =>
-    deleteRepository(repository.owner, repository.name)
-
-    FileUtils.deleteDirectory(getRepositoryDir(repository.owner, repository.name))
-    FileUtils.deleteDirectory(getWikiRepositoryDir(repository.owner, repository.name))
-    FileUtils.deleteDirectory(getTemporaryDir(repository.owner, repository.name))
+    LockUtil.lock(s"${repository.owner}/${repository.name}"){
+      deleteRepository(repository.owner, repository.name)

+      FileUtils.deleteDirectory(getRepositoryDir(repository.owner, repository.name))
+      FileUtils.deleteDirectory(getWikiRepositoryDir(repository.owner, repository.name))
+      FileUtils.deleteDirectory(getTemporaryDir(repository.owner, repository.name))
+    }
    redirect(s"/${repository.owner}")
  })

--- a/src/main/scala/app/SystemSettingsController.scala
+++ b/src/main/scala/app/SystemSettingsController.scala
@@ -3,8 +3,13 @@ package app
 import service.{AccountService, SystemSettingsService}
 import SystemSettingsService._
 import util.AdminAuthenticator
+import util.Directory._
+import util.ControlUtil._
 import jp.sf.amateras.scalatra.forms._
 import ssh.SshServer
+import org.apache.commons.io.FileUtils
+import java.io.FileInputStream
+import plugin.{Plugin, PluginSystem}

 class SystemSettingsController extends SystemSettingsControllerBase
  with AccountService with AdminAuthenticator
@@ -47,6 +52,11 @@ trait SystemSettingsControllerBase extends ControllerBase {
    } else Nil
  }

+  private val pluginForm = mapping(
+    "pluginId" -> list(trim(label("", text())))
+  )(PluginForm.apply)
+
+  case class PluginForm(pluginIds: List[String])

  get("/admin/system")(adminOnly {
    admin.html.system(flash.get("info"))
@@ -71,4 +81,104 @@ trait SystemSettingsControllerBase extends ControllerBase {
    redirect("/admin/system")
  })

+// TODO Enable commented code to enable plug-in system
+//  get("/admin/plugins")(adminOnly {
+//    val installedPlugins = plugin.PluginSystem.plugins
+//    val updatablePlugins = getAvailablePlugins(installedPlugins).filter(_.status == "updatable")
+//    admin.plugins.html.installed(installedPlugins, updatablePlugins)
+//  })
+//
+//  post("/admin/plugins/_update", pluginForm)(adminOnly { form =>
+//    deletePlugins(form.pluginIds)
+//    installPlugins(form.pluginIds)
+//    redirect("/admin/plugins")
+//  })
+//
+//  post("/admin/plugins/_delete", pluginForm)(adminOnly { form =>
+//    deletePlugins(form.pluginIds)
+//    redirect("/admin/plugins")
+//  })
+//
+//  get("/admin/plugins/available")(adminOnly {
+//    val installedPlugins = plugin.PluginSystem.plugins
+//    val availablePlugins = getAvailablePlugins(installedPlugins).filter(_.status == "available")
+//    admin.plugins.html.available(availablePlugins)
+//  })
+//
+//  post("/admin/plugins/_install", pluginForm)(adminOnly { form =>
+//    installPlugins(form.pluginIds)
+//    redirect("/admin/plugins")
+//  })
+
+//  get("/admin/plugins/console")(adminOnly {
+//    admin.plugins.html.console()
+//  })
+//
+//  post("/admin/plugins/console")(adminOnly {
+//    val script = request.getParameter("script")
+//    val result = plugin.JavaScriptPlugin.evaluateJavaScript(script)
+//    Ok(result)
+//  })
+
+  // TODO Move these methods to PluginSystem or Service?
+  private def deletePlugins(pluginIds: List[String]): Unit = {
+    pluginIds.foreach { pluginId =>
+      plugin.PluginSystem.uninstall(pluginId)
+      val dir = new java.io.File(PluginHome, pluginId)
+      if(dir.exists && dir.isDirectory){
+        FileUtils.deleteQuietly(dir)
+        PluginSystem.uninstall(pluginId)
+      }
+    }
+  }
+
+  private def installPlugins(pluginIds: List[String]): Unit = {
+    val dir = getPluginCacheDir()
+    val installedPlugins = plugin.PluginSystem.plugins
+    getAvailablePlugins(installedPlugins).filter(x => pluginIds.contains(x.id)).foreach { plugin =>
+      val pluginDir = new java.io.File(PluginHome, plugin.id)
+      if(!pluginDir.exists){
+        FileUtils.copyDirectory(new java.io.File(dir, plugin.repository + "/" + plugin.id), pluginDir)
+      }
+      PluginSystem.installPlugin(plugin.id)
+    }
+  }
+
+  private def getAvailablePlugins(installedPlugins: List[Plugin]): List[SystemSettingsControllerBase.AvailablePlugin] = {
+    val repositoryRoot = getPluginCacheDir()
+
+    if(repositoryRoot.exists && repositoryRoot.isDirectory){
+      PluginSystem.repositories.flatMap { repo =>
+        val repoDir = new java.io.File(repositoryRoot, repo.id)
+        if(repoDir.exists && repoDir.isDirectory){
+          repoDir.listFiles.filter(d => d.isDirectory && !d.getName.startsWith(".")).map { plugin =>
+            val propertyFile = new java.io.File(plugin, "plugin.properties")
+            val properties = new java.util.Properties()
+            if(propertyFile.exists && propertyFile.isFile){
+              using(new FileInputStream(propertyFile)){ in =>
+                properties.load(in)
+              }
+            }
+            SystemSettingsControllerBase.AvailablePlugin(
+              repository  = repo.id,
+              id          = properties.getProperty("id"),
+              version     = properties.getProperty("version"),
+              author      = properties.getProperty("author"),
+              url         = properties.getProperty("url"),
+              description = properties.getProperty("description"),
+              status      = installedPlugins.find(_.id == properties.getProperty("id")) match {
+                case Some(x) if(PluginSystem.isUpdatable(x.version, properties.getProperty("version")))=> "updatable"
+                case Some(x) => "installed"
+                case None    => "available"
+              })
+          }
+        } else Nil
+      }
+    } else Nil
+  }
+}
+
+object SystemSettingsControllerBase {
+  case class AvailablePlugin(repository: String, id: String, version: String,
+                             author: String, url: String, description: String, status: String)
 }