gitbucket.core.util.Notifier.scala Maven / Gradle / Ivy

Go to download
package gitbucket.core.util

import gitbucket.core.model.{Session, Issue, Account}
import gitbucket.core.model.Profile.profile.blockingApi._
import gitbucket.core.service.{RepositoryService, AccountService, IssuesService, SystemSettingsService}
import gitbucket.core.servlet.Database
import gitbucket.core.view.Markdown

import scala.concurrent._
import scala.util.{Success, Failure}
import ExecutionContext.Implicits.global
import org.apache.commons.mail.{DefaultAuthenticator, HtmlEmail}
import org.slf4j.LoggerFactory
import gitbucket.core.controller.Context
import SystemSettingsService.Smtp
import SyntaxSugars.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, loginAccount: Account)(notify: String => Unit)(implicit session: Session) =
    (
        // individual repository's owner
        issue.userName ::
        // group members of group repository
        getGroupMembers(issue.userName).map(_.userName) :::
        // collaborators
        getCollaboratorUserNames(issue.userName, issue.repositoryName) :::
        // participants
        issue.openedUserName ::
        getComments(issue.userName, issue.repositoryName, issue.issueId).map(_.commentedUserName)
    )
    .distinct
    .withFilter ( _ != loginAccount.userName )  // the operation in person is excluded
    .foreach (
      getAccountByUserName(_)
        .filterNot (_.isGroupAccount)
        .filterNot (LDAPUtil.isDummyMailAddress(_))
        .foreach (x => notify(x.mailAddress))
    )
}

object Notifier {
  // TODO We want to be able to switch to mock.
  def apply(): Notifier = new SystemSettingsService {}.loadSystemSettings match {
    case settings if (settings.notification && settings.useSMTP) => new Mailer(settings.smtp.get)
    case _ => new MockMailer
  }

  def msgIssue(url: String) = (content: String) => s"""
    |${content}

    |--

    |View it on GitBucket
    """.stripMargin

  def msgPullRequest(url: String) = (content: String) => s"""
    |${content}
    |View, comment on, or merge it at:

    |${url}
    """.stripMargin

  def msgComment(url: String) = (content: String) => s"""
    |${content}

    |--

    |View it on GitBucket
    """.stripMargin

  def msgStatus(url: String) = (content: String) => s"""
    |${content} #${url split('/') last}
    """.stripMargin
}

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): Unit = {
    context.loginAccount.foreach { loginAccount =>
      val database = Database()

      val f = Future {
        database withSession { implicit session =>
          defining(
            s"[${r.owner}/${r.name}] ${issue.title} (#${issue.issueId})" ->
              msg(Markdown.toHtml(
                markdown         = content,
                repository       = r,
                enableWikiLink   = false,
                enableRefsLink   = true,
                enableAnchor     = false,
                enableLineBreaks = false
              ))
          ) { case (subject, msg) =>
            recipients(issue, loginAccount) { to => send(to, subject, msg, loginAccount) }
          }
        }
        "Notifications Successful."
      }
      f.onComplete {
        case Success(s) => logger.debug(s)
        case Failure(t) => logger.error("Notifications Failed.", t)
      }
    }
  }

  def send(to: String, subject: String, msg: String, loginAccount: Account): Unit = {
    val email = new HtmlEmail
    email.setHostName(smtp.host)
    email.setSmtpPort(smtp.port.get)
    smtp.user.foreach { user =>
      email.setAuthenticator(new DefaultAuthenticator(user, smtp.password.getOrElse("")))
    }
    smtp.ssl.foreach { ssl =>
      email.setSSLOnConnect(ssl)
      if(ssl == true) {
        email.setSslSmtpPort(smtp.port.get.toString)
      }
    }
    smtp.starttls.foreach { starttls =>
      email.setStartTLSEnabled(starttls)
      email.setStartTLSRequired(starttls)
    }
    smtp.fromAddress
      .map (_ -> smtp.fromName.getOrElse(loginAccount.userName))
      .orElse (Some("[email protected]" -> loginAccount.userName))
      .foreach { case (address, name) =>
        email.setFrom(address, name)
      }
    email.setCharset("UTF-8")
    email.setSubject(subject)
    email.setHtmlMsg(msg)

    email.addTo(to).send
  }

}
class MockMailer extends Notifier {
  def toNotify(r: RepositoryService.RepositoryInfo, issue: Issue, content: String)
      (msg: String => String)(implicit context: Context): Unit = {}
}