Merge branch 'master' into feature-tasklist

Conflicts: src/main/twirl/issues/issuedetail.scala.html
2025-11-08 14:35:52 +01:00 · 2014-10-11 12:07:14 +09:00
parent 26b14ded58 320585a530
commit 1fe448a83b
59 changed files with 1512 additions and 1032 deletions
--- a/src/main/scala/app/DashboardController.scala
+++ b/src/main/scala/app/DashboardController.scala
@@ -50,20 +50,20 @@ trait DashboardControllerBase extends ControllerBase {

    val userName   = context.loginAccount.get.userName
    val userRepos  = getUserRepositories(userName, context.baseUrl, true).map(repo => repo.owner -> repo.name)
-    val filterUser = Map(filter -> userName)
+    //val filterUser = Map(filter -> userName)
    val page = IssueSearchCondition.page(request)

    dashboard.html.issues(
-        issues.html.listparts(
-            searchIssue(condition, filterUser, false, (page - 1) * IssueLimit, IssueLimit, userRepos: _*),
+        dashboard.html.issueslist(
+            searchIssue(condition, false, (page - 1) * IssueLimit, IssueLimit, userRepos: _*),
            page,
-            countIssue(condition.copy(state = "open"  ), filterUser, false, userRepos: _*),
-            countIssue(condition.copy(state = "closed"), filterUser, false, userRepos: _*),
+            countIssue(condition.copy(state = "open"  ), false, userRepos: _*),
+            countIssue(condition.copy(state = "closed"), false, userRepos: _*),
            condition),
-        countIssue(condition, Map.empty, false, userRepos: _*),
-        countIssue(condition, Map("assigned"   -> userName), false, userRepos: _*),
-        countIssue(condition, Map("created_by" -> userName), false, userRepos: _*),
-        countIssueGroupByRepository(condition, filterUser, false, userRepos: _*),
+        countIssue(condition.copy(assigned = None, author = None), false, userRepos: _*),
+        countIssue(condition.copy(assigned = Some(userName), author = None), false, userRepos: _*),
+        countIssue(condition.copy(assigned = None, author = Some(userName)), false, userRepos: _*),
+        countIssueGroupByRepository(condition, false, userRepos: _*),
        condition,
        filter)    
    
@@ -80,24 +80,24 @@ trait DashboardControllerBase extends ControllerBase {
    }.copy(repo = repository))

    val userName   = context.loginAccount.get.userName
-    val allRepos   = getAllRepositories()
+    val allRepos   = getAllRepositories(userName)
    val userRepos  = getUserRepositories(userName, context.baseUrl, true).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, userRepos: _*)
+      IssueSearchCondition().copy(state = condition.state), true, userRepos: _*)

    dashboard.html.pulls(
-      pulls.html.listparts(
-        searchIssue(condition, filterUser, true, (page - 1) * PullRequestLimit, PullRequestLimit, allRepos: _*),
+      dashboard.html.pullslist(
+        searchIssue(condition, true, (page - 1) * PullRequestLimit, PullRequestLimit, allRepos: _*),
        page,
-        countIssue(condition.copy(state = "open"  ), filterUser, true, allRepos: _*),
-        countIssue(condition.copy(state = "closed"), filterUser, true, allRepos: _*),
+        countIssue(condition.copy(state = "open"  ), true, allRepos: _*),
+        countIssue(condition.copy(state = "closed"), true, allRepos: _*),
        condition,
        None,
        false),
-      getPullRequestCountGroupByUser(condition.state == "closed", None, None),
+      getAllPullRequestCountGroupByUser(condition.state == "closed", userName),
      userRepos.map { case (userName, repoName) =>
        (userName, repoName, counts.find { x => x._1 == userName && x._2 == repoName }.map(_._3).getOrElse(0))
      }.sortBy(_._3).reverse,
--- a/src/main/scala/app/IssuesController.scala
+++ b/src/main/scala/app/IssuesController.scala
@@ -21,7 +21,6 @@ trait IssuesControllerBase extends ControllerBase {

  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])

@@ -33,10 +32,12 @@ trait IssuesControllerBase extends ControllerBase {
      "labelNames"       -> trim(optional(text()))
    )(IssueCreateForm.apply)

+  val issueTitleEditForm = mapping(
+    "title" -> trim(label("Title", text(required)))
+    )(x => x)
  val issueEditForm = mapping(
-      "title"   -> trim(label("Title", text(required))),
-      "content" -> trim(optional(text()))
-    )(IssueEditForm.apply)
+    "content" -> trim(optional(text()))
+    )(x => x)

  val commentForm = mapping(
      "issueId" -> label("Issue Id", number()),
@@ -48,16 +49,8 @@ trait IssuesControllerBase extends ControllerBase {
      "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")(referrersOnly { repository =>
+    searchIssues(repository)
  })

  get("/:owner/:repository/issues/:id")(referrersOnly { repository =>
@@ -126,14 +119,29 @@ trait IssuesControllerBase extends ControllerBase {
    }
  })

-  ajaxPost("/:owner/:repository/issues/edit/:id", issueEditForm)(readableUsersOnly { (form, repository) =>
+  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 { issue =>
        if(isEditable(owner, name, issue.openedUserName)){
          // update issue
-          updateIssue(owner, name, issue.issueId, form.title, form.content)
+          updateIssue(owner, name, issue.issueId, title, issue.content)
          // extract references and create refer comment
-          createReferComment(owner, name, issue, form.title + " " + form.content.getOrElse(""))
+          createReferComment(owner, name, issue.copy(title = title), title)
+
+          redirect(s"/${owner}/${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(isEditable(owner, name, issue.openedUserName)){
+          // update issue
+          updateIssue(owner, name, issue.issueId, issue.title, content)
+          // extract references and create refer comment
+          createReferComment(owner, name, issue, content.getOrElse(""))

          redirect(s"/${owner}/${name}/issues/_data/${issue.issueId}")
        } else Unauthorized
@@ -181,7 +189,7 @@ trait IssuesControllerBase extends ControllerBase {
      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)
+              x.content, x.issueId, x.userName, x.repositoryName)
        } getOrElse {
          contentType = formats("json")
          org.json4s.jackson.Serialization.write(
@@ -235,15 +243,17 @@ trait IssuesControllerBase extends ControllerBase {
    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)
+        issues.milestones.html.progress(openCount + closeCount, closeCount)
      } getOrElse NotFound
    } getOrElse Ok()
  })

  post("/:owner/:repository/issues/batchedit/state")(collaboratorsOnly { repository =>
    defining(params.get("value")){ action =>
-      executeBatch(repository) {
-        handleComment(_, None, repository)( _ => action)
+      action match {
+        case Some("open")  => executeBatch(repository) { handleComment(_, None, repository)( _ => Some("reopen")) }
+        case Some("close") => executeBatch(repository) { handleComment(_, None, repository)( _ => Some("close"))  }
+        case _ => // TODO BadRequest
      }
    }
  })
@@ -293,7 +303,10 @@ trait IssuesControllerBase extends ControllerBase {

  private def executeBatch(repository: RepositoryService.RepositoryInfo)(execute: Int => Unit) = {
    params("checked").split(',') map(_.toInt) foreach execute
-    redirect(s"/${repository.owner}/${repository.name}/issues")
+    params("from") match {
+      case "issues" => redirect(s"/${repository.owner}/${repository.name}/issues")
+      case "pulls"  => redirect(s"/${repository.owner}/${repository.name}/pulls")
+    }
  }

  private def createReferComment(owner: String, repository: String, fromIssue: Issue, message: String) = {
@@ -319,15 +332,15 @@ trait IssuesControllerBase extends ControllerBase {
        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 _))
-          }
+              case "close" if(!issue.closed) => true  ->
+                (Some("close")  -> Some(if(issue.isPullRequest) recordClosePullRequestActivity _ else recordCloseIssueActivity _))
+              case "reopen" if(issue.closed) => false ->
+                (Some("reopen") -> Some(recordReopenIssueActivity _))
+            }
            .map { case (closed, t) =>
-            updateClosed(owner, name, issueId, closed)
-            t
-          }
+              updateClosed(owner, name, issueId, closed)
+              t
+            }
            .getOrElse(None -> None)

        val commentId = content
@@ -337,7 +350,7 @@ trait IssuesControllerBase extends ControllerBase {
          case (content, action) => createComment(owner, name, userName, issueId, content, action)
        }

-        // record activity
+        // record comment activity if comment is entered
        content foreach {
          (if(issue.isPullRequest) recordCommentPullRequestActivity _ else recordCommentIssueActivity _)
          (owner, name, userName, issueId, _)
@@ -370,9 +383,8 @@ trait IssuesControllerBase extends ControllerBase {
    }
  }

-  private def searchIssues(filter: String, repository: RepositoryService.RepositoryInfo) = {
+  private def searchIssues(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)

@@ -383,19 +395,15 @@ trait IssuesControllerBase extends ControllerBase {
      )

      issues.html.list(
-          searchIssue(condition, filterUser, false, (page - 1) * IssueLimit, IssueLimit, owner -> repoName),
+          "issues",
+          searchIssue(condition, 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),
+          countIssue(condition.copy(state = "open"  ), false, owner -> repoName),
+          countIssue(condition.copy(state = "closed"), false, owner -> repoName),
          condition,
-          filter,
          repository,
          hasWritePermission(owner, repoName, context.loginAccount))
    }
--- a/src/main/scala/app/LabelsController.scala
+++ b/src/main/scala/app/LabelsController.scala
@@ -2,51 +2,67 @@ package app

 import jp.sf.amateras.scalatra.forms._
 import service._
-import util.CollaboratorsAuthenticator
+import util.{ReferrerAuthenticator, CollaboratorsAuthenticator}
 import util.Implicits._
 import org.scalatra.i18n.Messages
+import org.scalatra.Ok

 class LabelsController extends LabelsControllerBase
-  with LabelsService with RepositoryService with AccountService with CollaboratorsAuthenticator
+  with LabelsService with IssuesService with RepositoryService with AccountService
+with ReferrerAuthenticator with CollaboratorsAuthenticator

 trait LabelsControllerBase extends ControllerBase {
-  self: LabelsService with RepositoryService with CollaboratorsAuthenticator =>
+  self: LabelsService with IssuesService with RepositoryService
+    with ReferrerAuthenticator with CollaboratorsAuthenticator =>

  case class LabelForm(labelName: String, color: String)

-  val newForm = mapping(
-    "newLabelName" -> trim(label("Label name", text(required, labelName, maxlength(100)))),
-    "newColor"     -> trim(label("Color",      text(required, color)))
+  val labelForm = mapping(
+    "labelName"  -> trim(label("Label name", text(required, labelName, maxlength(100)))),
+    "labelColor" -> trim(label("Color",      text(required, color)))
  )(LabelForm.apply)

-  val editForm = mapping(
-    "editLabelName" -> trim(label("Label name", text(required, labelName, maxlength(100)))),
-    "editColor"     -> trim(label("Color",      text(required, color)))
-  )(LabelForm.apply)
-
-  post("/:owner/:repository/issues/label/new", newForm)(collaboratorsOnly { (form, repository) =>
-    createLabel(repository.owner, repository.name, form.labelName, form.color.substring(1))
-    redirect(s"/${repository.owner}/${repository.name}/issues")
+  get("/:owner/:repository/issues/labels")(referrersOnly { repository =>
+    issues.labels.html.list(
+      getLabels(repository.owner, repository.name),
+      countIssueGroupByLabels(repository.owner, repository.name, IssuesService.IssueSearchCondition()),
+      repository,
+      hasWritePermission(repository.owner, repository.name, context.loginAccount))
  })

-  ajaxGet("/:owner/:repository/issues/label/edit")(collaboratorsOnly { repository =>
-    issues.labels.html.editlist(getLabels(repository.owner, repository.name), repository)
+  ajaxGet("/:owner/:repository/issues/labels/new")(collaboratorsOnly { repository =>
+    issues.labels.html.edit(None, repository)
  })

-  ajaxGet("/:owner/:repository/issues/label/:labelId/edit")(collaboratorsOnly { repository =>
+  ajaxPost("/:owner/:repository/issues/labels/new", labelForm)(collaboratorsOnly { (form, repository) =>
+    val labelId = createLabel(repository.owner, repository.name, form.labelName, form.color.substring(1))
+    issues.labels.html.label(
+      getLabel(repository.owner, repository.name, labelId).get,
+      // TODO futility
+      countIssueGroupByLabels(repository.owner, repository.name, IssuesService.IssueSearchCondition()),
+      repository,
+      hasWritePermission(repository.owner, repository.name, context.loginAccount))
+  })
+
+  ajaxGet("/:owner/:repository/issues/labels/:labelId/edit")(collaboratorsOnly { repository =>
    getLabel(repository.owner, repository.name, params("labelId").toInt).map { label =>
      issues.labels.html.edit(Some(label), repository)
    } getOrElse NotFound()
  })

-  ajaxPost("/:owner/:repository/issues/label/:labelId/edit", editForm)(collaboratorsOnly { (form, repository) =>
+  ajaxPost("/:owner/:repository/issues/labels/:labelId/edit", labelForm)(collaboratorsOnly { (form, repository) =>
    updateLabel(repository.owner, repository.name, params("labelId").toInt, form.labelName, form.color.substring(1))
-    issues.labels.html.editlist(getLabels(repository.owner, repository.name), repository)
+    issues.labels.html.label(
+      getLabel(repository.owner, repository.name, params("labelId").toInt).get,
+      // TODO futility
+      countIssueGroupByLabels(repository.owner, repository.name, IssuesService.IssueSearchCondition()),
+      repository,
+      hasWritePermission(repository.owner, repository.name, context.loginAccount))
  })

-  ajaxGet("/:owner/:repository/issues/label/:labelId/delete")(collaboratorsOnly { repository =>
+  ajaxPost("/:owner/:repository/issues/labels/:labelId/delete")(collaboratorsOnly { repository =>
    deleteLabel(repository.owner, repository.name, params("labelId").toInt)
-    issues.labels.html.editlist(getLabels(repository.owner, repository.name), repository)
+    Ok()
  })

  /**
--- a/src/main/scala/app/PullRequestsController.scala
+++ b/src/main/scala/app/PullRequestsController.scala
@@ -62,10 +62,6 @@ trait PullRequestsControllerBase extends ControllerBase {
    searchPullRequests(None, repository)
  })

-  get("/:owner/:repository/pulls/:userName")(referrersOnly { repository =>
-    searchPullRequests(Some(params("userName")), repository)
-  })
-
  get("/:owner/:repository/pull/:id")(referrersOnly { repository =>
    params("id").toIntOpt.flatMap{ issueId =>
      val owner = repository.owner
@@ -453,7 +449,6 @@ trait PullRequestsControllerBase extends ControllerBase {

  private def searchPullRequests(userName: Option[String], repository: RepositoryService.RepositoryInfo) =
    defining(repository.owner, repository.name){ case (owner, repoName) =>
-      val filterUser = userName.map { x => Map("created_by" -> x) } getOrElse Map("all" -> "")
      val page       = IssueSearchCondition.page(request)
      val sessionKey = Keys.Session.Pulls(owner, repoName)

@@ -463,14 +458,15 @@ trait PullRequestsControllerBase extends ControllerBase {
        else session.getAs[IssueSearchCondition](sessionKey).getOrElse(IssueSearchCondition())
      )

-      pulls.html.list(
-        searchIssue(condition, filterUser, true, (page - 1) * PullRequestLimit, PullRequestLimit, owner -> repoName),
-        getPullRequestCountGroupByUser(condition.state == "closed", Some(owner), Some(repoName)),
-        userName,
+      issues.html.list(
+        "pulls",
+        searchIssue(condition, true, (page - 1) * PullRequestLimit, PullRequestLimit, owner -> repoName),
        page,
-        countIssue(condition.copy(state = "open"  ), filterUser, true, owner -> repoName),
-        countIssue(condition.copy(state = "closed"), filterUser, true, owner -> repoName),
-        countIssue(condition, Map.empty, true, owner -> repoName),
+        (getCollaborators(owner, repoName) :+ owner).sorted,
+        getMilestones(owner, repoName),
+        getLabels(owner, repoName),
+        countIssue(condition.copy(state = "open"  ), true, owner -> repoName),
+        countIssue(condition.copy(state = "closed"), true, owner -> repoName),
        condition,
        repository,
        hasWritePermission(owner, repoName, context.loginAccount))
--- a/src/main/scala/app/SystemSettingsController.scala
+++ b/src/main/scala/app/SystemSettingsController.scala
@@ -85,41 +85,55 @@ trait SystemSettingsControllerBase extends ControllerBase {
  })

  get("/admin/plugins")(adminOnly {
-    val installedPlugins = plugin.PluginSystem.plugins
-    val updatablePlugins = getAvailablePlugins(installedPlugins).filter(_.status == "updatable")
-    admin.plugins.html.installed(installedPlugins, updatablePlugins)
+    if(enablePluginSystem){
+      val installedPlugins = plugin.PluginSystem.plugins
+      val updatablePlugins = getAvailablePlugins(installedPlugins).filter(_.status == "updatable")
+      admin.plugins.html.installed(installedPlugins, updatablePlugins)
+    } else NotFound
  })

  post("/admin/plugins/_update", pluginForm)(adminOnly { form =>
-    deletePlugins(form.pluginIds)
-    installPlugins(form.pluginIds)
-    redirect("/admin/plugins")
+    if(enablePluginSystem){
+      deletePlugins(form.pluginIds)
+      installPlugins(form.pluginIds)
+      redirect("/admin/plugins")
+    } else NotFound
  })

  post("/admin/plugins/_delete", pluginForm)(adminOnly { form =>
-    deletePlugins(form.pluginIds)
-    redirect("/admin/plugins")
+    if(enablePluginSystem){
+      deletePlugins(form.pluginIds)
+      redirect("/admin/plugins")
+    } else NotFound
  })

  get("/admin/plugins/available")(adminOnly {
-    val installedPlugins = plugin.PluginSystem.plugins
-    val availablePlugins = getAvailablePlugins(installedPlugins).filter(_.status == "available")
-    admin.plugins.html.available(availablePlugins)
+    if(enablePluginSystem){
+      val installedPlugins = plugin.PluginSystem.plugins
+      val availablePlugins = getAvailablePlugins(installedPlugins).filter(_.status == "available")
+      admin.plugins.html.available(availablePlugins)
+    } else NotFound
  })

  post("/admin/plugins/_install", pluginForm)(adminOnly { form =>
-    installPlugins(form.pluginIds)
-    redirect("/admin/plugins")
+    if(enablePluginSystem){
+      installPlugins(form.pluginIds)
+      redirect("/admin/plugins")
+    } else NotFound
  })

  get("/admin/plugins/console")(adminOnly {
-    admin.plugins.html.console()
+    if(enablePluginSystem){
+      admin.plugins.html.console()
+    } else NotFound
  })

  post("/admin/plugins/console")(adminOnly {
-    val script = request.getParameter("script")
-    val result = plugin.ScalaPlugin.eval(script)
-    Ok()
+    if(enablePluginSystem){
+      val script = request.getParameter("script")
+      val result = plugin.ScalaPlugin.eval(script)
+      Ok()
+    } else NotFound
  })

  // TODO Move these methods to PluginSystem or Service?
--- a/src/main/scala/model/Labels.scala
+++ b/src/main/scala/model/Labels.scala
@@ -31,7 +31,7 @@ case class Label(
    if(Integer.parseInt(r, 16) + Integer.parseInt(g, 16) + Integer.parseInt(b, 16) > 408){
      "000000"
    } else {
-      "FFFFFF"
+      "ffffff"
    }
  }
 }
--- a/src/main/scala/service/IssuesService.scala
+++ b/src/main/scala/service/IssuesService.scala
@@ -43,14 +43,13 @@ trait IssuesService {
   * Returns the count of the search result against  issues.
   *
   * @param condition the search condition
-   * @param filterUser the filter user name (key is "all", "assigned" or "created_by", value is the user name)
   * @param onlyPullRequest if true then counts only pull request, false then counts both of issue and pull request.
   * @param repos Tuple of the repository owner and the repository name
   * @return the count of the search result
   */
-  def countIssue(condition: IssueSearchCondition, filterUser: Map[String, String], onlyPullRequest: Boolean,
-                 repos: (String, String)*)(implicit s: Session): Int =
-    Query(searchIssueQuery(repos, condition, filterUser, onlyPullRequest).length).first
+  def countIssue(condition: IssueSearchCondition, onlyPullRequest: Boolean, repos: (String, String)*)
+                (implicit s: Session): Int =
+    Query(searchIssueQuery(repos, condition, onlyPullRequest).length).first

  /**
   * Returns the Map which contains issue count for each labels.
@@ -58,13 +57,12 @@ trait IssuesService {
   * @param owner the repository owner
   * @param repository the repository name
   * @param condition the search condition
-   * @param filterUser the filter user name (key is "all", "assigned" or "created_by", value is the user name)
   * @return the Map which contains issue count for each labels (key is label name, value is issue count)
   */
-  def countIssueGroupByLabels(owner: String, repository: String, condition: IssueSearchCondition,
-                              filterUser: Map[String, String])(implicit s: Session): Map[String, Int] = {
+  def countIssueGroupByLabels(owner: String, repository: String,
+                              condition: IssueSearchCondition)(implicit s: Session): Map[String, Int] = {

-    searchIssueQuery(Seq(owner -> repository), condition.copy(labels = Set.empty), filterUser, false)
+    searchIssueQuery(Seq(owner -> repository), condition.copy(labels = Set.empty), false)
      .innerJoin(IssueLabels).on { (t1, t2) =>
        t1.byIssue(t2.userName, t2.repositoryName, t2.issueId)
      }
@@ -84,15 +82,14 @@ trait IssuesService {
   * If the issue does not exist, its repository is not included in the result.
   *
   * @param condition the search condition
-   * @param filterUser the filter user name (key is "all", "assigned" or "created_by", value is the user name)
   * @param onlyPullRequest if true then returns only pull request, false then returns both of issue and pull request.
   * @param repos Tuple of the repository owner and the repository name
   * @return list which contains issue count for each repository
   */
  def countIssueGroupByRepository(
-      condition: IssueSearchCondition, filterUser: Map[String, String], onlyPullRequest: Boolean,
+      condition: IssueSearchCondition, onlyPullRequest: Boolean,
      repos: (String, String)*)(implicit s: Session): List[(String, String, Int)] = {
-    searchIssueQuery(repos, condition.copy(repo = None), filterUser, onlyPullRequest)
+    searchIssueQuery(repos, condition.copy(repo = None), onlyPullRequest)
      .groupBy { t =>
        t.userName -> t.repositoryName
      }
@@ -107,19 +104,18 @@ trait IssuesService {
   * Returns the search result against  issues.
   *
   * @param condition the search condition
-   * @param filterUser the filter user name (key is "all", "assigned", "created_by" or "not_created_by", value is the user name)
-   * @param onlyPullRequest if true then returns only pull request, false then returns both of issue and pull request.
+   * @param pullRequest if true then returns only pull requests, false then returns only issues.
   * @param offset the offset for pagination
   * @param limit the limit for pagination
   * @param repos Tuple of the repository owner and the repository name
   * @return the search result (list of tuples which contain issue, labels and comment count)
   */
-  def searchIssue(condition: IssueSearchCondition, filterUser: Map[String, String], onlyPullRequest: Boolean,
+  def searchIssue(condition: IssueSearchCondition, pullRequest: Boolean,
                  offset: Int, limit: Int, repos: (String, String)*)
-                 (implicit s: Session): List[(Issue, List[Label], Int)] = {
+                 (implicit s: Session): List[IssueInfo] = {

    // get issues and comment count and labels
-    searchIssueQuery(repos, condition, filterUser, onlyPullRequest)
+    searchIssueQuery(repos, condition, pullRequest)
        .innerJoin(IssueOutline).on { (t1, t2) => t1.byIssue(t2.userName, t2.repositoryName, t2.issueId) }
        .sortBy { case (t1, t2) =>
          (condition.sort match {
@@ -136,21 +132,23 @@ trait IssuesService {
        .drop(offset).take(limit)
        .leftJoin (IssueLabels) .on { case ((t1, t2), t3) => t1.byIssue(t3.userName, t3.repositoryName, t3.issueId) }
        .leftJoin (Labels)      .on { case (((t1, t2), t3), t4) => t3.byLabel(t4.userName, t4.repositoryName, t4.labelId) }
-        .map { case (((t1, t2), t3), t4) =>
-          (t1, t2.commentCount, t4.labelId.?, t4.labelName.?, t4.color.?)
+        .leftJoin (Milestones)  .on { case ((((t1, t2), t3), t4), t5) => t1.byMilestone(t5.userName, t5.repositoryName, t5.milestoneId) }
+        .map { case ((((t1, t2), t3), t4), t5) =>
+          (t1, t2.commentCount, t4.labelId.?, t4.labelName.?, t4.color.?, t5.title.?)
        }
        .list
        .splitWith { (c1, c2) =>
-          c1._1.userName == c2._1.userName &&
+          c1._1.userName       == c2._1.userName &&
          c1._1.repositoryName == c2._1.repositoryName &&
-          c1._1.issueId == c2._1.issueId
+          c1._1.issueId        == c2._1.issueId
        }
        .map { issues => issues.head match {
-          case (issue, commentCount, _,_,_) =>
-            (issue,
+          case (issue, commentCount, _, _, _, milestone) =>
+            IssueInfo(issue,
             issues.flatMap { t => t._3.map (
                 Label(issue.userName, issue.repositoryName, _, t._4.get, t._5.get)
             )} toList,
+             milestone,
             commentCount)
        }} toList
  }
@@ -159,7 +157,7 @@ trait IssuesService {
   * Assembles query for conditional issue searching.
   */
  private def searchIssueQuery(repos: Seq[(String, String)], condition: IssueSearchCondition,
-                               filterUser: Map[String, String], onlyPullRequest: Boolean)(implicit s: Session) =
+                               pullRequest: Boolean)(implicit s: Session) =
    Issues filter { t1 =>
      condition.repo
          .map { _.split('/') match { case array => Seq(array(0) -> array(1)) } }
@@ -169,10 +167,9 @@ trait IssuesService {
      (t1.closed           === (condition.state == "closed").bind) &&
      (t1.milestoneId      === condition.milestoneId.get.get.bind, condition.milestoneId.flatten.isDefined) &&
      (t1.milestoneId.?    isEmpty, condition.milestoneId == Some(None)) &&
-      (t1.assignedUserName === filterUser("assigned").bind, filterUser.get("assigned").isDefined) &&
-      (t1.openedUserName   === filterUser("created_by").bind, filterUser.get("created_by").isDefined) &&
-      (t1.openedUserName   =!= filterUser("not_created_by").bind, filterUser.get("not_created_by").isDefined) &&
-      (t1.pullRequest      === true.bind, onlyPullRequest) &&
+      (t1.assignedUserName === condition.assigned.get.bind, condition.assigned.isDefined) &&
+      (t1.openedUserName   === condition.author.get.bind, condition.author.isDefined) &&
+      (t1.pullRequest      === pullRequest.bind) &&
      (IssueLabels filter { t2 =>
        (t2.byIssue(t1.userName, t1.repositoryName, t1.issueId)) &&
        (t2.labelId in
@@ -337,11 +334,20 @@ object IssuesService {
  case class IssueSearchCondition(
      labels: Set[String] = Set.empty,
      milestoneId: Option[Option[Int]] = None,
+      author: Option[String] = None,
+      assigned: Option[String] = None,
      repo: Option[String] = None,
      state: String = "open",
      sort: String = "created",
      direction: String = "desc"){

+    def isEmpty: Boolean = {
+      labels.isEmpty && milestoneId.isEmpty && author.isEmpty && assigned.isEmpty &&
+        state == "open" && sort == "created" && direction == "desc"
+    }
+
+    def nonEmpty: Boolean = !isEmpty
+
    def toURL: String =
      "?" + List(
        if(labels.isEmpty) None else Some("labels=" + urlEncode(labels.mkString(","))),
@@ -349,6 +355,8 @@ object IssuesService {
          case Some(x) => x.toString
          case None    => "none"
        })},
+        author  .map(x => "author="   + urlEncode(x)),
+        assigned.map(x => "assigned=" + urlEncode(x)),
        repo.map("for="   + urlEncode(_)),
        Some("state="     + urlEncode(state)),
        Some("sort="      + urlEncode(sort)),
@@ -370,6 +378,8 @@ object IssuesService {
          case "none" => None
          case x      => x.toIntOpt
        },
+        param(request, "author"),
+        param(request, "assigned"),
        param(request, "for"),
        param(request, "state",     Seq("open", "closed")).getOrElse("open"),
        param(request, "sort",      Seq("created", "comments", "updated")).getOrElse("created"),
@@ -383,4 +393,6 @@ object IssuesService {
    }
  }

+  case class IssueInfo(issue: Issue, labels: List[Label], milestone: Option[String], commentCount: Int)
+
 }
--- a/src/main/scala/service/LabelsService.scala
+++ b/src/main/scala/service/LabelsService.scala
@@ -12,8 +12,8 @@ trait LabelsService {
  def getLabel(owner: String, repository: String, labelId: Int)(implicit s: Session): Option[Label] =
    Labels.filter(_.byPrimaryKey(owner, repository, labelId)).firstOption

-  def createLabel(owner: String, repository: String, labelName: String, color: String)(implicit s: Session): Unit =
-    Labels insert Label(
+  def createLabel(owner: String, repository: String, labelName: String, color: String)(implicit s: Session): Int =
+    Labels returning Labels.map(_.labelId) += Label(
      userName       = owner,
      repositoryName = repository,
      labelName      = labelName,
--- a/src/main/scala/service/PullRequestService.scala
+++ b/src/main/scala/service/PullRequestService.scala
@@ -36,6 +36,24 @@ trait PullRequestService { self: IssuesService =>
      .list
      .map { x => PullRequestCount(x._1, x._2) }

+  def getAllPullRequestCountGroupByUser(closed: Boolean, userName: String)(implicit s: Session): List[PullRequestCount] =
+    PullRequests
+      .innerJoin(Issues).on { (t1, t2) => t1.byPrimaryKey(t2.userName, t2.repositoryName, t2.issueId) }
+      .innerJoin(Repositories).on { case ((t1, t2), t3) => t2.byRepository(t3.userName, t3.repositoryName) }
+      .filter { case ((t1, t2), t3) =>
+        (t2.closed === closed.bind) &&
+          (
+            (t3.isPrivate === false.bind) ||
+            (t3.userName  === userName.bind) ||
+            (Collaborators.filter { t4 => t4.byRepository(t3.userName, t3.repositoryName) && (t4.collaboratorName === userName.bind)} exists)
+          )
+      }
+      .groupBy { case ((t1, t2), t3) => t2.openedUserName }
+      .map { case (userName, t) => userName -> t.length }
+      .sortBy(_._2 desc)
+      .list
+      .map { x => PullRequestCount(x._1, x._2) }
+
  def createPullRequest(originUserName: String, originRepositoryName: String, issueId: Int,
        originBranch: String, requestUserName: String, requestRepositoryName: String, requestBranch: String,
        commitIdFrom: String, commitIdTo: String)(implicit s: Session): Unit =
--- a/src/main/scala/service/RepositoryService.scala
+++ b/src/main/scala/service/RepositoryService.scala
@@ -166,8 +166,19 @@ trait RepositoryService { self: AccountService =>
    }
  }

-  def getAllRepositories()(implicit s: Session): List[(String, String)] = {
-    Repositories.sortBy(_.lastActivityDate desc).map{ t =>
+  /**
+   * Returns the repositories without private repository that user does not have access right.
+   * Include public repository, private own repository and private but collaborator repository.
+   *
+   * @param userName the user name of collaborator
+   * @return the repository infomation list
+   */
+  def getAllRepositories(userName: String)(implicit s: Session): List[(String, String)] = {
+    Repositories.filter { t1 =>
+      (t1.isPrivate === false.bind) ||
+      (t1.userName  === userName.bind) ||
+      (Collaborators.filter { t2 => t2.byRepository(t1.userName, t1.repositoryName) && (t2.collaboratorName === userName.bind)} exists)
+    }.sortBy(_.lastActivityDate desc).map{ t =>
      (t.userName, t.repositoryName)
    }.list
  }
--- a/src/main/scala/service/SystemSettingsService.scala
+++ b/src/main/scala/service/SystemSettingsService.scala
@@ -191,4 +191,7 @@ object SystemSettingsService {
      else value
    }

+  // TODO temporary flag
+  val enablePluginSystem = Option(System.getProperty("enable.plugin")).getOrElse("false").toBoolean
+
 }
--- a/src/main/scala/servlet/AutoUpdateListener.scala
+++ b/src/main/scala/servlet/AutoUpdateListener.scala
@@ -11,6 +11,7 @@ import util.ControlUtil._
 import org.eclipse.jgit.api.Git
 import util.Directory
 import plugin.PluginUpdateJob
+import service.SystemSettingsService

 object AutoUpdate {
  
@@ -52,6 +53,7 @@ object AutoUpdate {
   * The history of versions. A head of this sequence is the current BitBucket version.
   */
  val versions = Seq(
+    new Version(2, 4),
    new Version(2, 3) {
      override def update(conn: Connection): Unit = {
        super.update(conn)
@@ -168,18 +170,15 @@ object AutoUpdate {
 */
 class AutoUpdateListener extends ServletContextListener {
  import org.quartz.impl.StdSchedulerFactory
-  import org.quartz.JobBuilder._
-  import org.quartz.TriggerBuilder._
-  import org.quartz.SimpleScheduleBuilder._
  import AutoUpdate._

  private val logger = LoggerFactory.getLogger(classOf[AutoUpdateListener])
  private val scheduler = StdSchedulerFactory.getDefaultScheduler
  
  override def contextInitialized(event: ServletContextEvent): Unit = {
-    val datadir = event.getServletContext.getInitParameter("gitbucket.home")
-    if(datadir != null){
-      System.setProperty("gitbucket.home", datadir)
+    val dataDir = event.getServletContext.getInitParameter("gitbucket.home")
+    if(dataDir != null){
+      System.setProperty("gitbucket.home", dataDir)
    }
    org.h2.Driver.load()

@@ -210,21 +209,23 @@ class AutoUpdateListener extends ServletContextListener {
      logger.debug("End schema update")
    }

-    getDatabase(context).withSession { implicit session =>
-      logger.debug("Starting plugin system...")
-      try {
-        plugin.PluginSystem.init()
+    if(SystemSettingsService.enablePluginSystem){
+      getDatabase(context).withSession { implicit session =>
+        logger.debug("Starting plugin system...")
+        try {
+          plugin.PluginSystem.init()

-        scheduler.start()
-        PluginUpdateJob.schedule(scheduler)
-        logger.debug("PluginUpdateJob is started.")
+          scheduler.start()
+          PluginUpdateJob.schedule(scheduler)
+          logger.debug("PluginUpdateJob is started.")

-        logger.debug("Plugin system is initialized.")
-      } catch {
-        case ex: Throwable => {
-          logger.error("Failed to initialize plugin system", ex)
-          ex.printStackTrace()
-          throw ex
+          logger.debug("Plugin system is initialized.")
+        } catch {
+          case ex: Throwable => {
+            logger.error("Failed to initialize plugin system", ex)
+            ex.printStackTrace()
+            throw ex
+          }
        }
      }
    }
--- a/src/main/scala/servlet/GitRepositoryServlet.scala
+++ b/src/main/scala/servlet/GitRepositoryServlet.scala
@@ -134,8 +134,8 @@ class CommitLogHook(owner: String, repository: String, pusher: String, baseUrl:

          // Retrieve all issue count in the repository
          val issueCount =
-            countIssue(IssueSearchCondition(state = "open"), Map.empty, false, owner -> repository) +
-            countIssue(IssueSearchCondition(state = "closed"), Map.empty, false, owner -> repository)
+            countIssue(IssueSearchCondition(state = "open"), false, owner -> repository) +
+            countIssue(IssueSearchCondition(state = "closed"), false, owner -> repository)

          // Extract new commit and apply issue comment
          val defaultBranch = getRepository(owner, repository, baseUrl).get.repository.defaultBranch
--- a/src/main/scala/view/Markdown.scala
+++ b/src/main/scala/view/Markdown.scala
@@ -97,9 +97,10 @@ class GitBucketHtmlSerializer(
    Map[String, VerbatimSerializer](VerbatimSerializer.DEFAULT -> new GitBucketVerbatimSerializer).asJava
  ) with LinkConverter with RequestCache {

-  override protected def printImageTag(imageNode: SuperNode, url: String): Unit =
-    printer.print("<a target=\"_blank\" href=\"").print(fixUrl(url)).print("\">")
-           .print("<img src=\"").print(fixUrl(url)).print("\"  alt=\"").printEncoded(printChildrenToString(imageNode)).print("\"/></a>")
+  override protected def printImageTag(imageNode: SuperNode, url: String): Unit = {
+    printer.print("<a target=\"_blank\" href=\"").print(fixUrl(url, true)).print("\">")
+           .print("<img src=\"").print(fixUrl(url, true)).print("\"  alt=\"").printEncoded(printChildrenToString(imageNode)).print("\"/></a>")
+  }

  override protected def printLink(rendering: LinkRenderer.Rendering): Unit = {
    printer.print('<').print('a')
@@ -110,15 +111,20 @@ class GitBucketHtmlSerializer(
    printer.print('>').print(rendering.text).print("</a>")
  }

-  private def fixUrl(url: String): String = {
-    if(!enableWikiLink){
-      if(url.startsWith("http://") || url.startsWith("https://") || url.startsWith("#") || url.startsWith("/") ||
-          context.currentPath.contains("/blob/")){
-        url
+  private def fixUrl(url: String, isImage: Boolean = false): String = {
+    if(url.startsWith("http://") || url.startsWith("https://") || url.startsWith("#") || url.startsWith("/")){
+      url
+    } else if(!enableWikiLink){
+      if(context.currentPath.contains("/blob/")){
+        url + (if(isImage) "?raw=true" else "")
+      } else if(context.currentPath.contains("/tree/")){
+        val paths = context.currentPath.split("/")
+        val branch = if(paths.length > 3) paths.drop(4).mkString("/") else repository.repository.defaultBranch
+        repository.httpUrl.replaceFirst("/git/", "/").stripSuffix(".git") + "/blob/" + branch + "/" + url + (if(isImage) "?raw=true" else "")
      } else {
        val paths = context.currentPath.split("/")
        val branch = if(paths.length > 3) paths.last else repository.repository.defaultBranch
-        repository.httpUrl.replaceFirst("/git/", "/").stripSuffix(".git") + "/blob/" + branch + "/" + url
+        repository.httpUrl.replaceFirst("/git/", "/").stripSuffix(".git") + "/blob/" + branch + "/" + url + (if(isImage) "?raw=true" else "")
      }
    } else {
      repository.httpUrl.replaceFirst("/git/", "/").stripSuffix(".git") + "/wiki/_blob/" + url