Remove context.loginAccount.get in services

src/main/scala/gitbucket/core/controller/SystemSettingsController.scala

@@ -164,7 +164,8 @@ trait SystemSettingsControllerBase extends AccountManagementControllerBase {
   post("/admin/system/sendmail", sendMailForm)(adminOnly { form =>
     try {
       new Mailer(form.smtp).send(form.testAddress,
-        "Test message from GitBucket", "This is a test message from GitBucket.")
+        "Test message from GitBucket", "This is a test message from GitBucket.",
+        context.loginAccount.get)
 
       "Test mail has been sent to: " + form.testAddress
 

src/main/scala/gitbucket/core/service/HandleCommentService.scala

@@ -17,76 +17,77 @@ trait HandleCommentService {
    */
   def handleComment(issue: Issue, content: Option[String], repository: RepositoryService.RepositoryInfo, actionOpt: Option[String])
                    (implicit context: Context, s: Session) = {
+    context.loginAccount.flatMap { loginAccount =>
+      defining(repository.owner, repository.name){ case (owner, name) =>
+        val userName = loginAccount.userName
 
-    defining(repository.owner, repository.name){ case (owner, name) =>
+        val (action, recordActivity) = actionOpt
-      val userName = context.loginAccount.get.userName
+          .collect {
-
+            case "close" if(!issue.closed) => true  ->
-      val (action, recordActivity) = actionOpt
+              (Some("close")  -> Some(if(issue.isPullRequest) recordClosePullRequestActivity _ else recordCloseIssueActivity _))
-        .collect {
+            case "reopen" if(issue.closed) => false ->
-          case "close" if(!issue.closed) => true  ->
+              (Some("reopen") -> Some(recordReopenIssueActivity _))
-            (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, issue.issueId, closed)
-          t
-        }
-        .getOrElse(None -> None)
-
-      val commentId = (content, action) match {
-        case (None, None) => None
-        case (None, Some(action)) => Some(createComment(owner, name, userName, issue.issueId, action.capitalize, action))
-        case (Some(content), _) => Some(createComment(owner, name, userName, issue.issueId, content, action.map(_+ "_comment").getOrElse("comment")))
-      }
-
-      // record comment activity if comment is entered
-      content foreach {
-        (if(issue.isPullRequest) recordCommentPullRequestActivity _ else recordCommentIssueActivity _)
-        (owner, name, userName, issue.issueId, _)
-      }
-      recordActivity foreach ( _ (owner, name, userName, issue.issueId, issue.title) )
-
-      // extract references and create refer comment
-      content.map { content =>
-        createReferComment(owner, name, issue, content, context.loginAccount.get)
-      }
-
-      // call web hooks
-      action match {
-        case None => commentId.map { commentIdSome => callIssueCommentWebHook(repository, issue, commentIdSome, context.loginAccount.get) }
-        case Some(act) => {
-          val webHookAction = act match {
-            case "open"   => "opened"
-            case "reopen" => "reopened"
-            case "close"  => "closed"
-            case _ => act
           }
-          if (issue.isPullRequest) {
+          .map { case (closed, t) =>
-            callPullRequestWebHook(webHookAction, repository, issue.issueId, context.baseUrl, context.loginAccount.get)
+            updateClosed(owner, name, issue.issueId, closed)
-          } else {
+            t
-            callIssuesWebHook(webHookAction, repository, issue, context.baseUrl, context.loginAccount.get)
           }
-        }
+          .getOrElse(None -> None)
-      }
 
-      // notifications
+        val commentId = (content, action) match {
-      Notifier() match {
+          case (None, None) => None
-        case f =>
+          case (None, Some(action)) => Some(createComment(owner, name, userName, issue.issueId, action.capitalize, action))
-          content foreach {
+          case (Some(content), _) => Some(createComment(owner, name, userName, issue.issueId, content, action.map(_+ "_comment").getOrElse("comment")))
-            f.toNotify(repository, issue, _){
+        }
-              Notifier.msgComment(s"${context.baseUrl}/${owner}/${name}/${
+
-                if(issue.isPullRequest) "pull" else "issues"}/${issue.issueId}#comment-${commentId.get}")
+        // record comment activity if comment is entered
+        content foreach {
+          (if(issue.isPullRequest) recordCommentPullRequestActivity _ else recordCommentIssueActivity _)
+          (owner, name, userName, issue.issueId, _)
+        }
+        recordActivity foreach ( _ (owner, name, userName, issue.issueId, issue.title) )
+
+        // extract references and create refer comment
+        content.map { content =>
+          createReferComment(owner, name, issue, content, loginAccount)
+        }
+
+        // call web hooks
+        action match {
+          case None => commentId.map { commentIdSome => callIssueCommentWebHook(repository, issue, commentIdSome, loginAccount) }
+          case Some(act) => {
+            val webHookAction = act match {
+              case "open"   => "opened"
+              case "reopen" => "reopened"
+              case "close"  => "closed"
+              case _ => act
+            }
+            if (issue.isPullRequest) {
+              callPullRequestWebHook(webHookAction, repository, issue.issueId, context.baseUrl, loginAccount)
+            } else {
+              callIssuesWebHook(webHookAction, repository, issue, context.baseUrl, loginAccount)
             }
           }
-          action foreach {
+        }
-            f.toNotify(repository, issue, _){
-              Notifier.msgStatus(s"${context.baseUrl}/${owner}/${name}/issues/${issue.issueId}")
-            }
-          }
-      }
 
-      commentId.map( issue -> _ )
+        // notifications
+        Notifier() match {
+          case f =>
+            content foreach {
+              f.toNotify(repository, issue, _){
+                Notifier.msgComment(s"${context.baseUrl}/${owner}/${name}/${
+                  if(issue.isPullRequest) "pull" else "issues"}/${issue.issueId}#comment-${commentId.get}")
+              }
+            }
+            action foreach {
+              f.toNotify(repository, issue, _){
+                Notifier.msgStatus(s"${context.baseUrl}/${owner}/${name}/issues/${issue.issueId}")
+              }
+            }
+        }
+
+        commentId.map( issue -> _ )
+      }
     }
   }
 

src/main/scala/gitbucket/core/util/Notifier.scala

@@ -1,7 +1,7 @@
 package gitbucket.core.util
 
-import gitbucket.core.model.{Session, Issue}
+import gitbucket.core.model.{Account, Issue, Session}
-import gitbucket.core.service.{RepositoryService, AccountService, IssuesService, SystemSettingsService}
+import gitbucket.core.service.{AccountService, IssuesService, RepositoryService, SystemSettingsService}
 import gitbucket.core.servlet.Database
 import gitbucket.core.view.Markdown
 
@@ -9,16 +9,16 @@ import scala.concurrent._
 import ExecutionContext.Implicits.global
 import org.apache.commons.mail.{DefaultAuthenticator, HtmlEmail}
 import org.slf4j.LoggerFactory
-
 import gitbucket.core.controller.Context
 import SystemSettingsService.Smtp
 import ControlUtil.defining
 
 trait Notifier extends RepositoryService with AccountService with IssuesService {
+
   def toNotify(r: RepositoryService.RepositoryInfo, issue: Issue, content: String)
       (msg: String => String)(implicit context: Context): Unit
 
-  protected def recipients(issue: Issue)(notify: String => Unit)(implicit session: Session, context: Context) =
+  protected def recipients(issue: Issue, loginAccount: Account)(notify: String => Unit)(implicit session: Session) =
     (
         // individual repository's owner
         issue.userName ::
@@ -31,9 +31,13 @@ trait Notifier extends RepositoryService with AccountService with IssuesService
         getComments(issue.userName, issue.repositoryName, issue.issueId).map(_.commentedUserName)
     )
     .distinct
-    .withFilter ( _ != context.loginAccount.get.userName )  // the operation in person is excluded
+    .withFilter ( _ != loginAccount.userName )  // the operation in person is excluded
-    .foreach ( getAccountByUserName(_) filterNot (_.isGroupAccount) filterNot (LDAPUtil.isDummyMailAddress(_)) foreach (x => notify(x.mailAddress)) )
+    .foreach (
-
+      getAccountByUserName(_)
+        .filterNot (_.isGroupAccount)
+        .filterNot (LDAPUtil.isDummyMailAddress(_))
+        .foreach (x => notify(x.mailAddress))
+    )
 }
 
 object Notifier {
@@ -70,37 +74,38 @@ class Mailer(private val smtp: Smtp) extends Notifier {
   private val logger = LoggerFactory.getLogger(classOf[Mailer])
 
   def toNotify(r: RepositoryService.RepositoryInfo, issue: Issue, content: String)
-      (msg: String => String)(implicit context: Context) = {
+      (msg: String => String)(implicit context: Context): Unit = {
-    val database = Database()
+    context.loginAccount.foreach { loginAccount =>
+      val database = Database()
 
-    val f = Future {
+      val f = Future {
-      database withSession { implicit session =>
+        database withSession { implicit session =>
-        defining(
+          defining(
-          s"[${r.name}] ${issue.title} (#${issue.issueId})" ->
+            s"[${r.name}] ${issue.title} (#${issue.issueId})" ->
-            msg(Markdown.toHtml(
+              msg(Markdown.toHtml(
-              markdown         = content,
+                markdown         = content,
-              repository       = r,
+                repository       = r,
-              enableWikiLink   = false,
+                enableWikiLink   = false,
-              enableRefsLink   = true,
+                enableRefsLink   = true,
-              enableAnchor     = false,
+                enableAnchor     = false,
-              enableLineBreaks = false
+                enableLineBreaks = false
-            ))) { case (subject, msg) =>
+              ))
-            recipients(issue) { to =>
+          ) { case (subject, msg) =>
-              send(to, subject, msg)
+            recipients(issue, loginAccount) { to => send(to, subject, msg, loginAccount) }
-            }
+          }
         }
+        "Notifications Successful."
+      }
+      f onSuccess {
+        case s => logger.debug(s)
+      }
+      f onFailure {
+        case t => logger.error("Notifications Failed.", t)
       }
-      "Notifications Successful."
-    }
-    f onSuccess {
-      case s => logger.debug(s)
-    }
-    f onFailure {
-      case t => logger.error("Notifications Failed.", t)
     }
   }
 
-  def send(to: String, subject: String, msg: String)(implicit context: Context): Unit = {
+  def send(to: String, subject: String, msg: String, loginAccount: Account): Unit = {
     val email = new HtmlEmail
     email.setHostName(smtp.host)
     email.setSmtpPort(smtp.port.get)
@@ -114,8 +119,8 @@ class Mailer(private val smtp: Smtp) extends Notifier {
       }
     }
     smtp.fromAddress
-      .map (_ -> smtp.fromName.getOrElse(context.loginAccount.get.userName))
+      .map (_ -> smtp.fromName.getOrElse(loginAccount.userName))
-      .orElse (Some("notifications@gitbucket.com" -> context.loginAccount.get.userName))
+      .orElse (Some("notifications@gitbucket.com" -> loginAccount.userName))
       .foreach { case (address, name) =>
         email.setFrom(address, name)
       }