Merge branch 'master' into feature-tasklist

Conflicts:
	src/main/twirl/issues/issuedetail.scala.html

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,

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

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()
   })
 
   /**

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

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?