(refs #522)Recover user filter in dashboard

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(
         dashboard.html.issueslist(
-            searchIssue(condition, false, (page - 1) * IssueLimit, IssueLimit, userRepos: _*),
+            searchIssue(condition, filterUser, false, (page - 1) * IssueLimit, IssueLimit, userRepos: _*),
             page,
-            countIssue(condition.copy(state = "open"  ), false, userRepos: _*),
+            countIssue(condition.copy(state = "open"  ), filterUser, false, userRepos: _*),
-            countIssue(condition.copy(state = "closed"), false, userRepos: _*),
+            countIssue(condition.copy(state = "closed"), filterUser, false, userRepos: _*),
             condition),
-        countIssue(condition.copy(assigned = None, author = None), false, userRepos: _*),
+        countIssue(condition.copy(assigned = None, author = None), filterUser, false, userRepos: _*),
-        countIssue(condition.copy(assigned = Some(userName), author = None), false, userRepos: _*),
+        countIssue(condition.copy(assigned = Some(userName), author = None), filterUser, false, userRepos: _*),
-        countIssue(condition.copy(assigned = None, author = Some(userName)), false, userRepos: _*),
+        countIssue(condition.copy(assigned = None, author = Some(userName)), filterUser, false, userRepos: _*),
-        countIssueGroupByRepository(condition, false, userRepos: _*),
+        countIssueGroupByRepository(condition, filterUser, false, userRepos: _*),
         condition,
         filter)    
     
@@ -86,14 +86,14 @@ trait DashboardControllerBase extends ControllerBase {
     val page = IssueSearchCondition.page(request)
 
     val counts = countIssueGroupByRepository(
-      IssueSearchCondition().copy(state = condition.state), true, userRepos: _*)
+      IssueSearchCondition().copy(state = condition.state), filterUser, true, userRepos: _*)
 
     dashboard.html.pulls(
       dashboard.html.pullslist(
-        searchIssue(condition, true, (page - 1) * PullRequestLimit, PullRequestLimit, allRepos: _*),
+        searchIssue(condition, filterUser, true, (page - 1) * PullRequestLimit, PullRequestLimit, allRepos: _*),
         page,
-        countIssue(condition.copy(state = "open"  ), true, allRepos: _*),
+        countIssue(condition.copy(state = "open"  ), filterUser, true, allRepos: _*),
-        countIssue(condition.copy(state = "closed"), true, allRepos: _*),
+        countIssue(condition.copy(state = "closed"), filterUser, true, allRepos: _*),
         condition,
         None,
         false),

src/main/scala/app/IssuesController.scala

@@ -396,13 +396,13 @@ trait IssuesControllerBase extends ControllerBase {
 
       issues.html.list(
           "issues",
-          searchIssue(condition, false, (page - 1) * IssueLimit, IssueLimit, owner -> repoName),
+          searchIssue(condition, Map.empty, false, (page - 1) * IssueLimit, IssueLimit, owner -> repoName),
           page,
           (getCollaborators(owner, repoName) :+ owner).sorted,
           getMilestones(owner, repoName),
           getLabels(owner, repoName),
-          countIssue(condition.copy(state = "open"  ), false, owner -> repoName),
+          countIssue(condition.copy(state = "open"  ), Map.empty, false, owner -> repoName),
-          countIssue(condition.copy(state = "closed"), false, owner -> repoName),
+          countIssue(condition.copy(state = "closed"), Map.empty, false, owner -> repoName),
           condition,
           repository,
           hasWritePermission(owner, repoName, context.loginAccount))

src/main/scala/app/LabelsController.scala

@@ -25,7 +25,7 @@ trait LabelsControllerBase extends ControllerBase {
   get("/:owner/:repository/issues/labels")(referrersOnly { repository =>
     issues.labels.html.list(
       getLabels(repository.owner, repository.name),
-      countIssueGroupByLabels(repository.owner, repository.name, IssuesService.IssueSearchCondition()),
+      countIssueGroupByLabels(repository.owner, repository.name, IssuesService.IssueSearchCondition(), Map.empty),
       repository,
       hasWritePermission(repository.owner, repository.name, context.loginAccount))
   })
@@ -39,7 +39,7 @@ trait LabelsControllerBase extends ControllerBase {
     issues.labels.html.label(
       getLabel(repository.owner, repository.name, labelId).get,
       // TODO futility
-      countIssueGroupByLabels(repository.owner, repository.name, IssuesService.IssueSearchCondition()),
+      countIssueGroupByLabels(repository.owner, repository.name, IssuesService.IssueSearchCondition(), Map.empty),
       repository,
       hasWritePermission(repository.owner, repository.name, context.loginAccount))
   })
@@ -55,7 +55,7 @@ trait LabelsControllerBase extends ControllerBase {
     issues.labels.html.label(
       getLabel(repository.owner, repository.name, params("labelId").toInt).get,
       // TODO futility
-      countIssueGroupByLabels(repository.owner, repository.name, IssuesService.IssueSearchCondition()),
+      countIssueGroupByLabels(repository.owner, repository.name, IssuesService.IssueSearchCondition(), Map.empty),
       repository,
       hasWritePermission(repository.owner, repository.name, context.loginAccount))
   })

src/main/scala/app/PullRequestsController.scala

@@ -460,13 +460,13 @@ trait PullRequestsControllerBase extends ControllerBase {
 
       issues.html.list(
         "pulls",
-        searchIssue(condition, true, (page - 1) * PullRequestLimit, PullRequestLimit, owner -> repoName),
+        searchIssue(condition, Map.empty, true, (page - 1) * PullRequestLimit, PullRequestLimit, owner -> repoName),
         page,
         (getCollaborators(owner, repoName) :+ owner).sorted,
         getMilestones(owner, repoName),
         getLabels(owner, repoName),
-        countIssue(condition.copy(state = "open"  ), true, owner -> repoName),
+        countIssue(condition.copy(state = "open"  ), Map.empty, true, owner -> repoName),
-        countIssue(condition.copy(state = "closed"), true, owner -> repoName),
+        countIssue(condition.copy(state = "closed"), Map.empty, true, owner -> repoName),
         condition,
         repository,
         hasWritePermission(owner, repoName, context.loginAccount))

src/main/scala/service/IssuesService.scala

@@ -47,9 +47,9 @@ trait IssuesService {
    * @param repos Tuple of the repository owner and the repository name
    * @return the count of the search result
    */
-  def countIssue(condition: IssueSearchCondition, onlyPullRequest: Boolean, repos: (String, String)*)
+  def countIssue(condition: IssueSearchCondition, filterUser: Map[String, String], onlyPullRequest: Boolean,
-                (implicit s: Session): Int =
+                 repos: (String, String)*)(implicit s: Session): Int =
-    Query(searchIssueQuery(repos, condition, onlyPullRequest).length).first
+    Query(searchIssueQuery(repos, condition, filterUser, onlyPullRequest).length).first
 
   /**
    * Returns the Map which contains issue count for each labels.
@@ -59,10 +59,10 @@ trait IssuesService {
    * @param condition the search condition
    * @return the Map which contains issue count for each labels (key is label name, value is issue count)
    */
-  def countIssueGroupByLabels(owner: String, repository: String,
+  def countIssueGroupByLabels(owner: String, repository: String, condition: IssueSearchCondition,
-                              condition: IssueSearchCondition)(implicit s: Session): Map[String, Int] = {
+                              filterUser: Map[String, String])(implicit s: Session): Map[String, Int] = {
 
-    searchIssueQuery(Seq(owner -> repository), condition.copy(labels = Set.empty), false)
+    searchIssueQuery(Seq(owner -> repository), condition.copy(labels = Set.empty), filterUser, false)
       .innerJoin(IssueLabels).on { (t1, t2) =>
         t1.byIssue(t2.userName, t2.repositoryName, t2.issueId)
       }
@@ -87,9 +87,9 @@ trait IssuesService {
    * @return list which contains issue count for each repository
    */
   def countIssueGroupByRepository(
-      condition: IssueSearchCondition, onlyPullRequest: Boolean,
+      condition: IssueSearchCondition, filterUser: Map[String, String], onlyPullRequest: Boolean,
       repos: (String, String)*)(implicit s: Session): List[(String, String, Int)] = {
-    searchIssueQuery(repos, condition.copy(repo = None), onlyPullRequest)
+    searchIssueQuery(repos, condition.copy(repo = None), filterUser, onlyPullRequest)
       .groupBy { t =>
         t.userName -> t.repositoryName
       }
@@ -104,18 +104,19 @@ 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 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, pullRequest: Boolean,
+  def searchIssue(condition: IssueSearchCondition, filterUser: Map[String, String], pullRequest: Boolean,
                   offset: Int, limit: Int, repos: (String, String)*)
                  (implicit s: Session): List[IssueInfo] = {
 
     // get issues and comment count and labels
-    searchIssueQuery(repos, condition, pullRequest)
+    searchIssueQuery(repos, condition, filterUser, pullRequest)
         .innerJoin(IssueOutline).on { (t1, t2) => t1.byIssue(t2.userName, t2.repositoryName, t2.issueId) }
         .sortBy { case (t1, t2) =>
           (condition.sort match {
@@ -157,7 +158,7 @@ trait IssuesService {
    * Assembles query for conditional issue searching.
    */
   private def searchIssueQuery(repos: Seq[(String, String)], condition: IssueSearchCondition,
-                               pullRequest: Boolean)(implicit s: Session) =
+                               filterUser: Map[String, String], pullRequest: Boolean)(implicit s: Session) =
     Issues filter { t1 =>
       condition.repo
           .map { _.split('/') match { case array => Seq(array(0) -> array(1)) } }
@@ -167,6 +168,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.assignedUserName === condition.assigned.get.bind, condition.assigned.isDefined) &&
       (t1.openedUserName   === condition.author.get.bind, condition.author.isDefined) &&
       (t1.pullRequest      === pullRequest.bind) &&

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"), false, owner -> repository) +
+            countIssue(IssueSearchCondition(state = "open"), Map.empty, false, owner -> repository) +
-            countIssue(IssueSearchCondition(state = "closed"), false, owner -> repository)
+            countIssue(IssueSearchCondition(state = "closed"), Map.empty, false, owner -> repository)
 
           // Extract new commit and apply issue comment
           val defaultBranch = getRepository(owner, repository, baseUrl).get.repository.defaultBranch