Add watch screen.

Author: shimamoto

src/main/scala/Plugin.scala

@@ -1,4 +1,7 @@
+import gitbucket.core.controller.Context
+import gitbucket.core.model.Issue
 import gitbucket.core.plugin._
+import gitbucket.core.service.RepositoryService.RepositoryInfo
 import io.github.gitbucket.solidbase.migration.LiquibaseMigration
 import io.github.gitbucket.solidbase.model.Version
 
@@ -29,5 +32,22 @@ class Plugin extends gitbucket.core.plugin.Plugin {
   override val pullRequestHooks: Seq[PullRequestHook] = Seq(
   )
 
+  override val repositoryMenus = Seq(
+    (repository: RepositoryInfo, context: Context) =>
+      Some(Link(
+        id    = "watch",
+        label = "Watch",
+        path  = "/watch",
+        icon  = Some("menu-icon octicon octicon-eye")
+      ))
+  )
+
+  override val issueSidebars = Seq(
+    (issue: Issue, repository: RepositoryInfo, context: Context) =>
+      context.loginAccount map { account =>
+        // TODO DB access
+        gitbucket.notifications.html.issue(false, issue, repository)
+      }
+  )
 
 }

src/main/scala/gitbucket/notifications/controller/NotificationsController.scala

@@ -0,0 +1,43 @@
+package gitbucket.notifications.controller
+
+import gitbucket.core.controller.ControllerBase
+import gitbucket.core.service.{AccountService, RepositoryService}
+import gitbucket.core.util.Implicits._
+import gitbucket.core.util.ReadableUsersAuthenticator
+import gitbucket.core.util.SyntaxSugars._
+import gitbucket.notifications.html
+import gitbucket.notifications.model.Watch
+import gitbucket.notifications.service.NotificationsService
+import org.scalatra.Ok
+
+class NotificationsController extends NotificationsControllerBase
+  with NotificationsService with RepositoryService with AccountService with ReadableUsersAuthenticator
+
+trait NotificationsControllerBase extends ControllerBase {
+  self: NotificationsService with RepositoryService with AccountService with ReadableUsersAuthenticator =>
+
+  get("/:owner/:repository/watch")(readableUsersOnly { repository =>
+    defining(repository.owner, repository.name) { case (owner, name) =>
+      html.watch(
+        // TODO default value
+        getWatch(owner, name, context.loginAccount.get.userName),
+        repository
+      )
+    }
+  })
+
+  ajaxPost("/:owner/:repository/watch")(readableUsersOnly { repository =>
+    params.get("notification").flatMap(Watch.Notification.valueOf).map { notification =>
+      updateWatch(repository.owner, repository.name, context.loginAccount.get.userName, notification)
+      Ok()
+    } getOrElse NotFound()
+  })
+
+  ajaxPost("/:owner/:repository/issues/:id/notification")(readableUsersOnly { repository =>
+    params.getAs[Boolean]("subscribed").map { subscribed =>
+      updateIssueNotification(repository.owner, repository.name, params("id").toInt, context.loginAccount.get.userName, subscribed)
+      Ok()
+    } getOrElse NotFound()
+  })
+
+}

src/main/scala/gitbucket/notifications/model/Watch.scala

@@ -3,7 +3,7 @@ package gitbucket.notifications.model
 trait WatchComponent { self: gitbucket.core.model.Profile =>
   import profile.api._
 
-  implicit val watchNotificationType = MappedColumnType.base[Watch.Notification, String](_.code, Watch.Notification.valueOf)
+  implicit val watchNotificationType = MappedColumnType.base[Watch.Notification, String](_.id, Watch.Notification.valueOf(_).get)
 
   lazy val Watches = TableQuery[Watches]
 
@@ -24,13 +24,13 @@ case class Watch(
 )
 
 object Watch {
-  abstract sealed class Notification(val code: String)
-  case object Watching extends Notification("watching")
-  case object NotWatching extends Notification("not_watching")
-  case object Ignoring extends Notification("ignoring")
+  abstract sealed class Notification(val id: String, val name: String)
+  case object Watching extends Notification("watching", "Watching")
+  case object NotWatching extends Notification("not_watching", "Not watching")
+  case object Ignoring extends Notification("ignoring", "Ignoring")
 
-  private[model] object Notification {
-    private val values: Seq[Notification] = Seq(Watching, NotWatching, Ignoring)
-    def valueOf(code: String): Notification = values.find(_.code == code).get
+  object Notification {
+    val values: Seq[Notification] = Seq(Watching, NotWatching, Ignoring)
+    def valueOf(id: String): Option[Notification] = values.find(_.id == id)
   }
 }

src/main/scala/gitbucket/notifications/service/NotificationsAccountHook.scala

@@ -11,4 +11,38 @@ trait NotificationsAccountHook extends AccountHook {
     Watches.filter(_.notificationUserName === userName.bind).delete
   }
 
+}
+
+trait NotificationsRepositoryHook extends RepositoryHook {
+
+  override def deleted(owner: String, repository: String)(implicit session: Session): Unit =  {
+    IssueNotifications.filter(t => t.userName === owner.bind && t.repositoryName === repository.bind).delete
+    Watches.filter(t => t.userName === owner.bind && t.repositoryName === repository.bind).delete
+  }
+
+  override def renamed(owner: String, repository: String, newRepository: String)(implicit session: Session): Unit = {
+    rename(owner, repository, owner, newRepository)
+  }
+
+  override def transferred(owner: String, newOwner: String, repository: String)(implicit session: Session): Unit = {
+    rename(owner, repository, newOwner, repository)
+  }
+
+  // TODO select - insert
+  private def rename(owner: String, repository: String, newOwner: String, newRepository: String)(implicit session: Session) = {
+    val n = IssueNotifications.filter(t => t.userName === owner.bind && t.repositoryName === repository.bind).list
+    val w = Watches.filter(t => t.userName === owner.bind && t.repositoryName === repository.bind).list
+
+    deleted(owner, repository)
+
+    IssueNotifications.insertAll(n.map(_.copy(userName = newOwner, repositoryName = newRepository)) :_*)
+    Watches.insertAll(w.map(_.copy(userName = newOwner, repositoryName = newRepository)) :_*)
+  }
+
+}
+
+trait NotificationsIssueHook extends IssueHook {
+
+
+
 }

src/main/scala/gitbucket/notifications/service/NotificationsService.scala

@@ -0,0 +1,51 @@
+package gitbucket.notifications.service
+
+import gitbucket.notifications.model._, Profile._
+import profile.blockingApi._
+
+trait NotificationsService {
+
+  def getWatch(owner: String, repository: String, userName: String)(implicit s: Session): Option[Watch] = {
+    Watches
+      .filter(t => t.userName === owner.bind && t.repositoryName === repository.bind && t.notificationUserName === userName.bind)
+      .firstOption
+  }
+
+  def updateWatch(owner: String, repository: String, userName: String, notification: Watch.Notification)(implicit s: Session): Unit = {
+    Watches
+      .filter(t => t.userName === owner.bind && t.repositoryName === repository.bind && t.notificationUserName === userName.bind)
+      .delete
+    Watches insert Watch(
+      userName             = owner,
+      repositoryName       = repository,
+      notificationUserName = userName,
+      notification         = notification
+    )
+  }
+
+  def getIssueNotification(owner: String, repository: String, issueId: Int, userName: String)(implicit s: Session): Option[IssueNotification] = {
+    IssueNotifications
+      .filter { t =>
+        t.userName === owner.bind && t.repositoryName === repository.bind &&
+          t.issueId === issueId.bind && t.notificationUserName === userName.bind
+      }
+      .firstOption
+  }
+
+  def updateIssueNotification(owner: String, repository: String, issueId: Int, userName: String, subscribed: Boolean)(implicit s: Session): Unit = {
+    IssueNotifications
+      .filter { t =>
+        t.userName === owner.bind && t.repositoryName === repository.bind &&
+          t.issueId === issueId.bind && t.notificationUserName === userName.bind
+      }
+      .delete
+    IssueNotifications insert IssueNotification(
+      userName             = owner,
+      repositoryName       = repository,
+      issueId              = issueId,
+      notificationUserName = userName,
+      subscribed           = subscribed
+    )
+  }
+
+}

src/main/twirl/gitbucket/notifications/issue.scala.html

@@ -0,0 +1,34 @@
+@(subscribed: Boolean,
+  issue: gitbucket.core.model.Issue,
+  repository: gitbucket.core.service.RepositoryService.RepositoryInfo)
+@import gitbucket.core.view.helpers
+
+<hr/>
+<div style="margin-bottom: 14px;">
+  <span class="muted small strong">Notifications</span>
+  <div class="pull-right">
+    @if(subscribed){
+      <input type="button" class="btn btn-default issue-notification" value="Unsubscribe" data-subscribed="false" />
+    } else {
+      <input type="button" class="btn btn-default issue-notification" value="Subscribe" data-subscribed="true" />
+    }
+  </div>
+</div>
+<script>
+$(function(){
+  $('.issue-notification').click(function(){
+    var $this = $(this);
+    var subscribed = $this.data('subscribed');
+    $.post('@helpers.url(repository)/issues/@issue.issueId/notification,
+      { subscribed : subscribed },
+      function(){
+        if(subscribed == 'false'){
+          $this.val('Subscribe').data('subscribed', 'true');
+        } else {
+          $this.val('Unsubscribe').data('subscribed', 'false');
+        }
+      }
+    );
+  });
+});
+</script>

src/main/twirl/gitbucket/notifications/watch.scala.html

@@ -0,0 +1,33 @@
+@(notification: gitbucket.notifications.model.Watch.Notification,
+  repository: gitbucket.core.service.RepositoryService.RepositoryInfo)(implicit context: gitbucket.core.controller.Context)
+@import gitbucket.core.view.helpers
+@gitbucket.core.html.main("Watch", Some(repository)){
+  @gitbucket.core.html.menu("watch", repository){
+
+    @gitbucket.core.helper.html.dropdown("Notifications"){
+      @gitbucket.notifications.model.Watch.Notification.values.map { n =>
+        <li>
+          <a href="#" class="watch" data-id="@n.id">
+            @gitbucket.core.helper.html.checkicon(notification.id == n.id) @n.name
+          </a>
+        </li>
+      }
+    }
+
+  }
+}
+<script>
+$(function(){
+  $('a.watch').click(function(){
+    var notification = $(this).data('id');
+    $.post('@helpers.url(repository)/watch',
+      { notification : notification },
+      function(){
+        $('a.watch i.octicon-check').removeClass('octicon-check');
+        $('a.watch[data-id=' + notification + '] i').addClass('octicon-check');
+      }
+    );
+    return false;
+  });
+});
+</script>