Use Slick2 compatible API

2026-05-07 20:07:30 +02:00 · 2016-08-13 11:46:41 +09:00
parent 7937944c10
commit 161e6dc809
19 changed files with 116 additions and 125 deletions
--- a/src/main/scala/gitbucket/core/model/Profile.scala
+++ b/src/main/scala/gitbucket/core/model/Profile.scala
@@ -1,11 +1,11 @@
 package gitbucket.core.model

 import gitbucket.core.util.DatabaseConfig
-import com.github.takezoe.slick.blocking.SlickBlockingAPI
+import com.github.takezoe.slick.blocking.BlockingJdbcProfile

 trait Profile {
-  val profile: SlickBlockingAPI
-  import profile.api._
+  val profile: BlockingJdbcProfile
+  import profile.blockingApi._

  /**
   * java.util.Date Mapped Column Types
--- a/src/main/scala/gitbucket/core/service/AccessTokenService.scala
+++ b/src/main/scala/gitbucket/core/service/AccessTokenService.scala
@@ -2,7 +2,7 @@ package gitbucket.core.service

 import gitbucket.core.model.Profile._
 import profile._
-import profile.api._
+import profile.blockingApi._

 import gitbucket.core.model.{Account, AccessToken}
 import gitbucket.core.util.StringUtil
@@ -35,7 +35,7 @@ trait AccessTokenService {
        userName = userName,
        note = note,
        tokenHash = hash)
-    val tokenId = (AccessTokens returning AccessTokens.map(_.accessTokenId)) unsafeInsert newToken
+    val tokenId = (AccessTokens returning AccessTokens.map(_.accessTokenId)) insert newToken
    (tokenId, token)
  }

@@ -50,7 +50,7 @@ trait AccessTokenService {
    AccessTokens.filter(_.userName === userName.bind).sortBy(_.accessTokenId.desc).list

  def deleteAccessToken(userName: String, accessTokenId: Int)(implicit s: Session): Unit =
-    AccessTokens filter (t => t.userName === userName.bind && t.accessTokenId === accessTokenId) unsafeDelete
+    AccessTokens filter (t => t.userName === userName.bind && t.accessTokenId === accessTokenId) delete

 }

--- a/src/main/scala/gitbucket/core/service/AccountService.scala
+++ b/src/main/scala/gitbucket/core/service/AccountService.scala
@@ -7,7 +7,7 @@ import gitbucket.core.util.{StringUtil, LDAPUtil}
 import StringUtil._
 import gitbucket.core.service.SystemSettingsService.SystemSettings
 import profile._
-import profile.api._
+import profile.blockingApi._
 import gitbucket.core.model.Profile.dateColumnType

 trait AccountService {
@@ -105,7 +105,7 @@ trait AccountService {

  def createAccount(userName: String, password: String, fullName: String, mailAddress: String, isAdmin: Boolean, url: Option[String])
                   (implicit s: Session): Unit =
-    Accounts unsafeInsert Account(
+    Accounts insert Account(
      userName       = userName,
      password       = password,
      fullName       = fullName,
@@ -123,7 +123,7 @@ trait AccountService {
    Accounts
      .filter { a =>  a.userName === account.userName.bind }
      .map    { a => (a.password, a.fullName, a.mailAddress, a.isAdmin, a.url.?, a.registeredDate, a.updatedDate, a.lastLoginDate.?, a.removed) }
-      .unsafeUpdate (
+      .update (
        account.password,
        account.fullName,
        account.mailAddress,
@@ -135,13 +135,13 @@ trait AccountService {
        account.isRemoved)

  def updateAvatarImage(userName: String, image: Option[String])(implicit s: Session): Unit =
-    Accounts.filter(_.userName === userName.bind).map(_.image.?).unsafeUpdate(image)
+    Accounts.filter(_.userName === userName.bind).map(_.image.?).update(image)

  def updateLastLoginDate(userName: String)(implicit s: Session): Unit =
-    Accounts.filter(_.userName === userName.bind).map(_.lastLoginDate).unsafeUpdate(currentDate)
+    Accounts.filter(_.userName === userName.bind).map(_.lastLoginDate).update(currentDate)

  def createGroup(groupName: String, url: Option[String])(implicit s: Session): Unit =
-    Accounts unsafeInsert Account(
+    Accounts insert Account(
      userName       = groupName,
      password       = "",
      fullName       = groupName,
@@ -156,12 +156,12 @@ trait AccountService {
      isRemoved      = false)

  def updateGroup(groupName: String, url: Option[String], removed: Boolean)(implicit s: Session): Unit =
-    Accounts.filter(_.userName === groupName.bind).map(t => t.url.? -> t.removed).unsafeUpdate(url, removed)
+    Accounts.filter(_.userName === groupName.bind).map(t => t.url.? -> t.removed).update(url, removed)

  def updateGroupMembers(groupName: String, members: List[(String, Boolean)])(implicit s: Session): Unit = {
    GroupMembers.filter(_.groupName === groupName.bind).delete
    members.foreach { case (userName, isManager) =>
-      GroupMembers unsafeInsert GroupMember (groupName, userName, isManager)
+      GroupMembers insert GroupMember (groupName, userName, isManager)
    }
  }

@@ -179,9 +179,9 @@ trait AccountService {
      .list

  def removeUserRelatedData(userName: String)(implicit s: Session): Unit = {
-    GroupMembers.filter(_.userName === userName.bind).unsafeDelete
-    Collaborators.filter(_.collaboratorName === userName.bind).unsafeDelete
-    Repositories.filter(_.userName === userName.bind).unsafeDelete
+    GroupMembers.filter(_.userName === userName.bind).delete
+    Collaborators.filter(_.collaboratorName === userName.bind).delete
+    Repositories.filter(_.userName === userName.bind).delete
  }

  def getGroupNames(userName: String)(implicit s: Session): List[String] = {
--- a/src/main/scala/gitbucket/core/service/ActivityService.scala
+++ b/src/main/scala/gitbucket/core/service/ActivityService.scala
@@ -4,13 +4,13 @@ import gitbucket.core.model.Activity
 import gitbucket.core.model.Profile._
 import gitbucket.core.util.JGitUtil
 import profile._
-import profile.api._
+import profile.blockingApi._

 trait ActivityService {

  def deleteOldActivities(limit: Int)(implicit s: Session): Int = {
    Activities.map(_.activityId).sortBy(_ desc).drop(limit).firstOption.map { id =>
-      Activities.filter(_.activityId <= id.bind).unsafeDelete
+      Activities.filter(_.activityId <= id.bind).delete
    } getOrElse 0
  }

@@ -49,7 +49,7 @@ trait ActivityService {

  def recordCreateRepositoryActivity(userName: String, repositoryName: String, activityUserName: String)
                                    (implicit s: Session): Unit =
-    Activities unsafeInsert Activity(userName, repositoryName, activityUserName,
+    Activities insert Activity(userName, repositoryName, activityUserName,
      "create_repository",
      s"[user:${activityUserName}] created [repo:${userName}/${repositoryName}]",
      None,
@@ -57,7 +57,7 @@ trait ActivityService {

  def recordCreateIssueActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, title: String)
                               (implicit s: Session): Unit =
-    Activities unsafeInsert Activity(userName, repositoryName, activityUserName,
+    Activities insert Activity(userName, repositoryName, activityUserName,
      "open_issue",
      s"[user:${activityUserName}] opened issue [issue:${userName}/${repositoryName}#${issueId}]",
      Some(title), 
@@ -65,7 +65,7 @@ trait ActivityService {

  def recordCloseIssueActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, title: String)
                              (implicit s: Session): Unit =
-    Activities unsafeInsert Activity(userName, repositoryName, activityUserName,
+    Activities insert Activity(userName, repositoryName, activityUserName,
      "close_issue",
      s"[user:${activityUserName}] closed issue [issue:${userName}/${repositoryName}#${issueId}]",
      Some(title),
@@ -73,7 +73,7 @@ trait ActivityService {

  def recordClosePullRequestActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, title: String)
                                    (implicit s: Session): Unit =
-    Activities unsafeInsert Activity(userName, repositoryName, activityUserName,
+    Activities insert Activity(userName, repositoryName, activityUserName,
      "close_issue",
      s"[user:${activityUserName}] closed pull request [pullreq:${userName}/${repositoryName}#${issueId}]",
      Some(title),
@@ -81,7 +81,7 @@ trait ActivityService {

  def recordReopenIssueActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, title: String)
                               (implicit s: Session): Unit =
-    Activities unsafeInsert Activity(userName, repositoryName, activityUserName,
+    Activities insert Activity(userName, repositoryName, activityUserName,
      "reopen_issue",
      s"[user:${activityUserName}] reopened issue [issue:${userName}/${repositoryName}#${issueId}]",
      Some(title),
@@ -89,7 +89,7 @@ trait ActivityService {

  def recordCommentIssueActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, comment: String)
                                (implicit s: Session): Unit =
-    Activities unsafeInsert Activity(userName, repositoryName, activityUserName,
+    Activities insert Activity(userName, repositoryName, activityUserName,
      "comment_issue",
      s"[user:${activityUserName}] commented on issue [issue:${userName}/${repositoryName}#${issueId}]",
      Some(cut(comment, 200)),
@@ -97,7 +97,7 @@ trait ActivityService {

  def recordCommentPullRequestActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, comment: String)
                                      (implicit s: Session): Unit =
-    Activities unsafeInsert Activity(userName, repositoryName, activityUserName,
+    Activities insert Activity(userName, repositoryName, activityUserName,
      "comment_issue",
      s"[user:${activityUserName}] commented on pull request [pullreq:${userName}/${repositoryName}#${issueId}]",
      Some(cut(comment, 200)),
@@ -105,7 +105,7 @@ trait ActivityService {

  def recordCommentCommitActivity(userName: String, repositoryName: String, activityUserName: String, commitId: String, comment: String)
                                 (implicit s: Session): Unit =
-    Activities unsafeInsert Activity(userName, repositoryName, activityUserName,
+    Activities insert Activity(userName, repositoryName, activityUserName,
      "comment_commit",
      s"[user:${activityUserName}] commented on commit [commit:${userName}/${repositoryName}@${commitId}]",
      Some(cut(comment, 200)),
@@ -114,7 +114,7 @@ trait ActivityService {

  def recordCreateWikiPageActivity(userName: String, repositoryName: String, activityUserName: String, pageName: String)
                                  (implicit s: Session): Unit =
-    Activities unsafeInsert Activity(userName, repositoryName, activityUserName,
+    Activities insert Activity(userName, repositoryName, activityUserName,
      "create_wiki",
      s"[user:${activityUserName}] created the [repo:${userName}/${repositoryName}] wiki",
      Some(pageName),
@@ -122,7 +122,7 @@ trait ActivityService {

  def recordEditWikiPageActivity(userName: String, repositoryName: String, activityUserName: String, pageName: String, commitId: String)
                                (implicit s: Session): Unit =
-    Activities unsafeInsert Activity(userName, repositoryName, activityUserName,
+    Activities insert Activity(userName, repositoryName, activityUserName,
      "edit_wiki",
      s"[user:${activityUserName}] edited the [repo:${userName}/${repositoryName}] wiki",
      Some(pageName + ":" + commitId),
@@ -130,7 +130,7 @@ trait ActivityService {

  def recordPushActivity(userName: String, repositoryName: String, activityUserName: String,
      branchName: String, commits: List[JGitUtil.CommitInfo])(implicit s: Session): Unit =
-    Activities unsafeInsert Activity(userName, repositoryName, activityUserName,
+    Activities insert Activity(userName, repositoryName, activityUserName,
      "push",
      s"[user:${activityUserName}] pushed to [branch:${userName}/${repositoryName}#${branchName}] at [repo:${userName}/${repositoryName}]",
      Some(commits.map { commit => commit.id + ":" + commit.shortMessage }.mkString("\n")),
@@ -138,7 +138,7 @@ trait ActivityService {

  def recordCreateTagActivity(userName: String, repositoryName: String, activityUserName: String, 
      tagName: String, commits: List[JGitUtil.CommitInfo])(implicit s: Session): Unit =
-    Activities unsafeInsert Activity(userName, repositoryName, activityUserName,
+    Activities insert Activity(userName, repositoryName, activityUserName,
      "create_tag",
      s"[user:${activityUserName}] created tag [tag:${userName}/${repositoryName}#${tagName}] at [repo:${userName}/${repositoryName}]",
      None,
@@ -146,7 +146,7 @@ trait ActivityService {

  def recordDeleteTagActivity(userName: String, repositoryName: String, activityUserName: String,
                              tagName: String, commits: List[JGitUtil.CommitInfo])(implicit s: Session): Unit =
-    Activities unsafeInsert Activity(userName, repositoryName, activityUserName,
+    Activities insert Activity(userName, repositoryName, activityUserName,
      "delete_tag",
      s"[user:${activityUserName}] deleted tag ${tagName} at [repo:${userName}/${repositoryName}]",
      None,
@@ -154,7 +154,7 @@ trait ActivityService {

  def recordCreateBranchActivity(userName: String, repositoryName: String, activityUserName: String, branchName: String)
                                (implicit s: Session): Unit =
-    Activities unsafeInsert Activity(userName, repositoryName, activityUserName,
+    Activities insert Activity(userName, repositoryName, activityUserName,
      "create_branch",
      s"[user:${activityUserName}] created branch [branch:${userName}/${repositoryName}#${branchName}] at [repo:${userName}/${repositoryName}]",
      None,
@@ -162,14 +162,14 @@ trait ActivityService {

  def recordDeleteBranchActivity(userName: String, repositoryName: String, activityUserName: String, branchName: String)
                                (implicit s: Session): Unit =
-    Activities unsafeInsert Activity(userName, repositoryName, activityUserName,
+    Activities insert Activity(userName, repositoryName, activityUserName,
      "delete_branch",
      s"[user:${activityUserName}] deleted branch ${branchName} at [repo:${userName}/${repositoryName}]",
      None,
      currentDate)

  def recordForkActivity(userName: String, repositoryName: String, activityUserName: String, forkedUserName: String)(implicit s: Session): Unit = 
-    Activities unsafeInsert Activity(userName, repositoryName, activityUserName,
+    Activities insert Activity(userName, repositoryName, activityUserName,
      "fork",
      s"[user:${activityUserName}] forked [repo:${userName}/${repositoryName}] to [repo:${forkedUserName}/${repositoryName}]",
      None,
@@ -177,7 +177,7 @@ trait ActivityService {

  def recordPullRequestActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, title: String)
                               (implicit s: Session): Unit =
-    Activities unsafeInsert Activity(userName, repositoryName, activityUserName,
+    Activities insert Activity(userName, repositoryName, activityUserName,
      "open_pullreq",
      s"[user:${activityUserName}] opened pull request [pullreq:${userName}/${repositoryName}#${issueId}]",
      Some(title),
@@ -185,7 +185,7 @@ trait ActivityService {

  def recordMergeActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, message: String)
                         (implicit s: Session): Unit =
-    Activities unsafeInsert Activity(userName, repositoryName, activityUserName,
+    Activities insert Activity(userName, repositoryName, activityUserName,
      "merge_pullreq",
      s"[user:${activityUserName}] merged pull request [pullreq:${userName}/${repositoryName}#${issueId}]",
      Some(message),
--- a/src/main/scala/gitbucket/core/service/CommitStatusService.scala
+++ b/src/main/scala/gitbucket/core/service/CommitStatusService.scala
@@ -2,7 +2,7 @@ package gitbucket.core.service

 import gitbucket.core.model.Profile._
 import profile._
-import profile.api._
+import profile.blockingApi._
 import gitbucket.core.model.Profile.dateColumnType
 import gitbucket.core.model.{CommitState, CommitStatus, Account}

@@ -19,7 +19,7 @@ trait CommitStatusService {
          }.update((state, targetUrl, now, creator.userName, description))
          id
        }
-        case None => (CommitStatuses returning CommitStatuses.map(_.commitStatusId)) unsafeInsert CommitStatus(
+        case None => (CommitStatuses returning CommitStatuses.map(_.commitStatusId)) insert CommitStatus(
            userName       = userName,
            repositoryName = repositoryName,
            commitId       = sha,
--- a/src/main/scala/gitbucket/core/service/CommitsService.scala
+++ b/src/main/scala/gitbucket/core/service/CommitsService.scala
@@ -3,7 +3,7 @@ package gitbucket.core.service
 import gitbucket.core.model.CommitComment
 import gitbucket.core.model.Profile._
 import profile._
-import profile.api._
+import profile.blockingApi._
 import gitbucket.core.model.Profile.dateColumnType

 trait CommitsService {
@@ -24,7 +24,7 @@ trait CommitsService {
  def createCommitComment(owner: String, repository: String, commitId: String, loginUser: String,
                          content: String, fileName: Option[String], oldLine: Option[Int], newLine: Option[Int],
                          issueId: Option[Int])(implicit s: Session): Int =
-    CommitComments returning CommitComments.map(_.commentId) unsafeInsert CommitComment(
+    CommitComments returning CommitComments.map(_.commentId) insert CommitComment(
      userName          = owner,
      repositoryName    = repository,
      commitId          = commitId,
@@ -41,9 +41,9 @@ trait CommitsService {
    CommitComments
      .filter (_.byPrimaryKey(commentId))
      .map { t => (t.content, t.updatedDate) }
-      .unsafeUpdate (content, currentDate)
+      .update (content, currentDate)
  }

  def deleteCommitComment(commentId: Int)(implicit s: Session) =
-    CommitComments filter (_.byPrimaryKey(commentId)) unsafeDelete
+    CommitComments filter (_.byPrimaryKey(commentId)) delete
 }
--- a/src/main/scala/gitbucket/core/service/HandleCommentService.scala
+++ b/src/main/scala/gitbucket/core/service/HandleCommentService.scala
@@ -6,7 +6,7 @@ import gitbucket.core.model.Profile._
 import gitbucket.core.util.ControlUtil._
 import gitbucket.core.util.Implicits._
 import gitbucket.core.util.Notifier
-import profile.api._
+import profile.blockingApi._

 trait HandleCommentService {
  self: RepositoryService with IssuesService with ActivityService
--- a/src/main/scala/gitbucket/core/service/IssuesService.scala
+++ b/src/main/scala/gitbucket/core/service/IssuesService.scala
@@ -6,7 +6,7 @@ import gitbucket.core.util.Implicits._
 import gitbucket.core.model.{Account, CommitState, Issue, IssueComment, IssueLabel, Label, PullRequest, Repository}
 import gitbucket.core.model.Profile._
 import profile._
-import profile.api._
+import profile.blockingApi._
 import gitbucket.core.model.Profile.dateColumnType


@@ -235,7 +235,7 @@ trait IssuesService {
    // next id number
    sql"SELECT ISSUE_ID + 1 FROM ISSUE_ID WHERE USER_NAME = $owner AND REPOSITORY_NAME = $repository FOR UPDATE".as[Int]
        .firstOption.filter { id =>
-      Issues unsafeInsert Issue(
+      Issues insert Issue(
          owner,
          repository,
          id,
@@ -253,18 +253,18 @@ trait IssuesService {
      IssueId
        .filter (_.byPrimaryKey(owner, repository))
        .map (_.issueId)
-        .unsafeUpdate (id) > 0
+        .update (id) > 0
    } get

  def registerIssueLabel(owner: String, repository: String, issueId: Int, labelId: Int)(implicit s: Session) =
-    IssueLabels unsafeInsert IssueLabel(owner, repository, issueId, labelId)
+    IssueLabels insert IssueLabel(owner, repository, issueId, labelId)

  def deleteIssueLabel(owner: String, repository: String, issueId: Int, labelId: Int)(implicit s: Session) =
-    IssueLabels filter(_.byPrimaryKey(owner, repository, issueId, labelId)) unsafeDelete
+    IssueLabels filter(_.byPrimaryKey(owner, repository, issueId, labelId)) delete

  def createComment(owner: String, repository: String, loginUser: String,
      issueId: Int, content: String, action: String)(implicit s: Session): Int = {
-    IssueComments returning IssueComments.map(_.commentId) unsafeInsert IssueComment(
+    IssueComments returning IssueComments.map(_.commentId) insert IssueComment(
      userName          = owner,
      repositoryName    = repository,
      issueId           = issueId,
@@ -279,26 +279,26 @@ trait IssuesService {
    Issues
      .filter (_.byPrimaryKey(owner, repository, issueId))
      .map { t => (t.title, t.content.?, t.updatedDate) }
-      .unsafeUpdate (title, content, currentDate)
+      .update (title, content, currentDate)
  }

  def updateAssignedUserName(owner: String, repository: String, issueId: Int,
                             assignedUserName: Option[String])(implicit s: Session) =
-    Issues.filter (_.byPrimaryKey(owner, repository, issueId)).map(_.assignedUserName?).unsafeUpdate (assignedUserName)
+    Issues.filter (_.byPrimaryKey(owner, repository, issueId)).map(_.assignedUserName?).update (assignedUserName)

  def updateMilestoneId(owner: String, repository: String, issueId: Int,
                        milestoneId: Option[Int])(implicit s: Session) =
-    Issues.filter (_.byPrimaryKey(owner, repository, issueId)).map(_.milestoneId?).unsafeUpdate (milestoneId)
+    Issues.filter (_.byPrimaryKey(owner, repository, issueId)).map(_.milestoneId?).update (milestoneId)

  def updateComment(commentId: Int, content: String)(implicit s: Session) = {
-    IssueComments.filter (_.byPrimaryKey(commentId)).map(t => (t.content, t.updatedDate)).unsafeUpdate(content, currentDate)
+    IssueComments.filter (_.byPrimaryKey(commentId)).map(t => (t.content, t.updatedDate)).update(content, currentDate)
  }

  def deleteComment(commentId: Int)(implicit s: Session) =
-    IssueComments filter (_.byPrimaryKey(commentId)) unsafeDelete
+    IssueComments filter (_.byPrimaryKey(commentId)) delete

  def updateClosed(owner: String, repository: String, issueId: Int, closed: Boolean)(implicit s: Session) = {
-    (Issues filter (_.byPrimaryKey(owner, repository, issueId)) map(t => (t.closed, t.updatedDate))).unsafeUpdate((closed, currentDate))
+    (Issues filter (_.byPrimaryKey(owner, repository, issueId)) map(t => (t.closed, t.updatedDate))).update((closed, currentDate))
  }

  /**
--- a/src/main/scala/gitbucket/core/service/LabelsService.scala
+++ b/src/main/scala/gitbucket/core/service/LabelsService.scala
@@ -3,10 +3,7 @@ package gitbucket.core.service
 import gitbucket.core.model.Label
 import gitbucket.core.model.Profile._
 import profile._
-import profile.api._
-
-import scala.concurrent.Await
-import scala.concurrent.duration.Duration
+import profile.blockingApi._

 trait LabelsService {

@@ -20,16 +17,12 @@ trait LabelsService {
    Labels.filter(_.byLabel(owner, repository, labelName)).firstOption

  def createLabel(owner: String, repository: String, labelName: String, color: String)(implicit s: Session): Int = {
-    // TODO [Slick3]Provide blocking method for returning
-    val f = s.database.run(
-      Labels returning Labels.map(_.labelId) += Label(
-        userName       = owner,
-        repositoryName = repository,
-        labelName      = labelName,
-        color          = color
-      )
+    Labels returning Labels.map(_.labelId) insert Label(
+      userName       = owner,
+      repositoryName = repository,
+      labelName      = labelName,
+      color          = color
    )
-    Await.result(f, Duration.Inf)
  }

  def updateLabel(owner: String, repository: String, labelId: Int, labelName: String, color: String)
@@ -39,8 +32,8 @@ trait LabelsService {
          .update(labelName, color)

  def deleteLabel(owner: String, repository: String, labelId: Int)(implicit s: Session): Unit = {
-    IssueLabels.filter(_.byLabel(owner, repository, labelId)).unsafeDelete
-    Labels.filter(_.byPrimaryKey(owner, repository, labelId)).unsafeDelete
+    IssueLabels.filter(_.byLabel(owner, repository, labelId)).delete
+    Labels.filter(_.byPrimaryKey(owner, repository, labelId)).delete
  }

 }
--- a/src/main/scala/gitbucket/core/service/MergeService.scala
+++ b/src/main/scala/gitbucket/core/service/MergeService.scala
@@ -1,9 +1,7 @@
 package gitbucket.core.service

 import gitbucket.core.model.Account
-import gitbucket.core.util.LockUtil
 import gitbucket.core.util.Directory._
-import gitbucket.core.util.Implicits._
 import gitbucket.core.util.ControlUtil._

 import org.eclipse.jgit.merge.MergeStrategy
--- a/src/main/scala/gitbucket/core/service/MilestonesService.scala
+++ b/src/main/scala/gitbucket/core/service/MilestonesService.scala
@@ -3,14 +3,14 @@ package gitbucket.core.service
 import gitbucket.core.model.Milestone
 import gitbucket.core.model.Profile._
 import profile._
-import profile.api._
+import profile.blockingApi._
 import gitbucket.core.model.Profile.dateColumnType

 trait MilestonesService {

  def createMilestone(owner: String, repository: String, title: String, description: Option[String],
                      dueDate: Option[java.util.Date])(implicit s: Session): Unit =
-    Milestones unsafeInsert Milestone(
+    Milestones insert Milestone(
      userName       = owner,
      repositoryName = repository,
      title          = title,
--- a/src/main/scala/gitbucket/core/service/ProtectedBranchService.scala
+++ b/src/main/scala/gitbucket/core/service/ProtectedBranchService.scala
@@ -4,7 +4,7 @@ import gitbucket.core.model.{ProtectedBranch, ProtectedBranchContext, CommitStat
 import gitbucket.core.model.Profile._
 import gitbucket.core.plugin.ReceiveHook
 import profile._
-import profile.api._
+import profile.blockingApi._

 import org.eclipse.jgit.transport.{ReceivePack, ReceiveCommand}

@@ -33,9 +33,9 @@ trait ProtectedBranchService {
  def enableBranchProtection(owner: String, repository: String, branch:String, includeAdministrators: Boolean, contexts: Seq[String])
                            (implicit session: Session): Unit = {
    disableBranchProtection(owner, repository, branch)
-    ProtectedBranches.unsafeInsert(new ProtectedBranch(owner, repository, branch, includeAdministrators && contexts.nonEmpty))
+    ProtectedBranches.insert(new ProtectedBranch(owner, repository, branch, includeAdministrators && contexts.nonEmpty))
    contexts.map{ context =>
-      ProtectedBranchContexts.unsafeInsert(new ProtectedBranchContext(owner, repository, branch, context))
+      ProtectedBranchContexts.insert(new ProtectedBranchContext(owner, repository, branch, context))
    }
  }

--- a/src/main/scala/gitbucket/core/service/PullRequestService.scala
+++ b/src/main/scala/gitbucket/core/service/PullRequestService.scala
@@ -4,7 +4,7 @@ import gitbucket.core.model.{Account, Issue, PullRequest, WebHook, CommitStatus,
 import gitbucket.core.model.Profile._
 import gitbucket.core.util.JGitUtil
 import profile._
-import profile.api._
+import profile.blockingApi._


 trait PullRequestService { self: IssuesService =>
@@ -60,7 +60,7 @@ trait PullRequestService { self: IssuesService =>
  def createPullRequest(originUserName: String, originRepositoryName: String, issueId: Int,
        originBranch: String, requestUserName: String, requestRepositoryName: String, requestBranch: String,
        commitIdFrom: String, commitIdTo: String)(implicit s: Session): Unit =
-    PullRequests unsafeInsert PullRequest(
+    PullRequests insert PullRequest(
      originUserName,
      originRepositoryName,
      issueId,
--- a/src/main/scala/gitbucket/core/service/RepositoryCreationService.scala
+++ b/src/main/scala/gitbucket/core/service/RepositoryCreationService.scala
@@ -8,7 +8,7 @@ import gitbucket.core.model.Account
 import org.eclipse.jgit.api.Git
 import org.eclipse.jgit.dircache.DirCache
 import org.eclipse.jgit.lib.{FileMode, Constants}
-import profile.api._
+import profile.blockingApi._

 trait RepositoryCreationService {
  self: AccountService with RepositoryService with LabelsService with WikiService with ActivityService =>
--- a/src/main/scala/gitbucket/core/service/RepositorySearchService.scala
+++ b/src/main/scala/gitbucket/core/service/RepositorySearchService.scala
@@ -10,7 +10,7 @@ import org.eclipse.jgit.treewalk.TreeWalk
 import org.eclipse.jgit.lib.FileMode
 import org.eclipse.jgit.api.Git
 import gitbucket.core.model.Profile._
-import profile.api._
+import profile.blockingApi._

 trait RepositorySearchService { self: IssuesService =>
  import RepositorySearchService._
--- a/src/main/scala/gitbucket/core/service/RepositoryService.scala
+++ b/src/main/scala/gitbucket/core/service/RepositoryService.scala
@@ -5,7 +5,7 @@ import gitbucket.core.util.JGitUtil
 import gitbucket.core.model.{Collaborator, Repository, Account}
 import gitbucket.core.model.Profile._
 import profile._
-import profile.api._
+import profile.blockingApi._
 import gitbucket.core.model.Profile.dateColumnType

 trait RepositoryService { self: AccountService =>
@@ -25,7 +25,7 @@ trait RepositoryService { self: AccountService =>
                       originRepositoryName: Option[String] = None, originUserName: Option[String] = None,
                       parentRepositoryName: Option[String] = None, parentUserName: Option[String] = None)
                      (implicit s: Session): Unit = {
-    Repositories unsafeInsert
+    Repositories insert
      Repository(
        userName             = userName,
        repositoryName       = repositoryName,
@@ -46,14 +46,14 @@ trait RepositoryService { self: AccountService =>
        externalWikiUrl      = None
      )

-    IssueId unsafeInsert (userName, repositoryName, 0)
+    IssueId insert (userName, repositoryName, 0)
  }

  def renameRepository(oldUserName: String, oldRepositoryName: String, newUserName: String, newRepositoryName: String)
                      (implicit s: Session): Unit = {
    getAccountByUserName(newUserName).foreach { account =>
      (Repositories filter { t => t.byRepository(oldUserName, oldRepositoryName) } firstOption).map { repository =>
-        Repositories unsafeInsert repository.copy(userName = newUserName, repositoryName = newRepositoryName)
+        Repositories insert repository.copy(userName = newUserName, repositoryName = newRepositoryName)

        val webHooks                = WebHooks               .filter(_.byRepository(oldUserName, oldRepositoryName)).list
        val webHookEvents           = WebHookEvents          .filter(_.byRepository(oldUserName, oldRepositoryName)).list
@@ -72,17 +72,17 @@ trait RepositoryService { self: AccountService =>

        Repositories.filter { t =>
          (t.originUserName === oldUserName.bind) && (t.originRepositoryName === oldRepositoryName.bind)
-        }.map { t => t.originUserName -> t.originRepositoryName }.unsafeUpdate(newUserName, newRepositoryName)
+        }.map { t => t.originUserName -> t.originRepositoryName }.update(newUserName, newRepositoryName)

        Repositories.filter { t =>
          (t.parentUserName === oldUserName.bind) && (t.parentRepositoryName === oldRepositoryName.bind)
-        }.map { t => t.originUserName -> t.originRepositoryName }.unsafeUpdate(newUserName, newRepositoryName)
+        }.map { t => t.originUserName -> t.originRepositoryName }.update(newUserName, newRepositoryName)

        // Updates activity fk before deleting repository because activity is sorted by activityId
        // and it can't be changed by deleting-and-inserting record.
        Activities.filter(_.byRepository(oldUserName, oldRepositoryName)).list.foreach { activity =>
          Activities.filter(_.activityId === activity.activityId.bind)
-            .map(x => (x.userName, x.repositoryName)).unsafeUpdate(newUserName, newRepositoryName)
+            .map(x => (x.userName, x.repositoryName)).update(newUserName, newRepositoryName)
        }

        deleteRepository(oldUserName, oldRepositoryName)
@@ -112,7 +112,7 @@ trait RepositoryService { self: AccountService =>
        // Update source repository of pull requests
        PullRequests.filter { t =>
          (t.requestUserName === oldUserName.bind) && (t.requestRepositoryName === oldRepositoryName.bind)
-        }.map { t => t.requestUserName -> t.requestRepositoryName }.unsafeUpdate(newUserName, newRepositoryName)
+        }.map { t => t.requestUserName -> t.requestRepositoryName }.update(newUserName, newRepositoryName)

        // Convert labelId
        val oldLabelMap = labels.map(x => (x.labelId, x.labelName)).toMap
@@ -140,7 +140,7 @@ trait RepositoryService { self: AccountService =>
          (t.message like s"%:${oldUserName}/${oldRepositoryName}#%") ||
          (t.message like s"%:${oldUserName}/${oldRepositoryName}@%")
        }.map { t => t.activityId -> t.message }.list.foreach { case (activityId, message) =>
-          Activities.filter(_.activityId === activityId.bind).map(_.message).unsafeUpdate(
+          Activities.filter(_.activityId === activityId.bind).map(_.message).update(
            message
              .replace(s"[repo:${oldUserName}/${oldRepositoryName}]"   ,s"[repo:${newUserName}/${newRepositoryName}]")
              .replace(s"[branch:${oldUserName}/${oldRepositoryName}#" ,s"[branch:${newUserName}/${newRepositoryName}#")
@@ -155,19 +155,19 @@ trait RepositoryService { self: AccountService =>
  }

  def deleteRepository(userName: String, repositoryName: String)(implicit s: Session): Unit = {
-    Activities    .filter(_.byRepository(userName, repositoryName)).unsafeDelete
-    Collaborators .filter(_.byRepository(userName, repositoryName)).unsafeDelete
-    CommitComments.filter(_.byRepository(userName, repositoryName)).unsafeDelete
-    IssueLabels   .filter(_.byRepository(userName, repositoryName)).unsafeDelete
-    Labels        .filter(_.byRepository(userName, repositoryName)).unsafeDelete
-    IssueComments .filter(_.byRepository(userName, repositoryName)).unsafeDelete
-    PullRequests  .filter(_.byRepository(userName, repositoryName)).unsafeDelete
-    Issues        .filter(_.byRepository(userName, repositoryName)).unsafeDelete
-    IssueId       .filter(_.byRepository(userName, repositoryName)).unsafeDelete
-    Milestones    .filter(_.byRepository(userName, repositoryName)).unsafeDelete
-    WebHooks      .filter(_.byRepository(userName, repositoryName)).unsafeDelete
-    WebHookEvents .filter(_.byRepository(userName, repositoryName)).unsafeDelete
-    Repositories  .filter(_.byRepository(userName, repositoryName)).unsafeDelete
+    Activities    .filter(_.byRepository(userName, repositoryName)).delete
+    Collaborators .filter(_.byRepository(userName, repositoryName)).delete
+    CommitComments.filter(_.byRepository(userName, repositoryName)).delete
+    IssueLabels   .filter(_.byRepository(userName, repositoryName)).delete
+    Labels        .filter(_.byRepository(userName, repositoryName)).delete
+    IssueComments .filter(_.byRepository(userName, repositoryName)).delete
+    PullRequests  .filter(_.byRepository(userName, repositoryName)).delete
+    Issues        .filter(_.byRepository(userName, repositoryName)).delete
+    IssueId       .filter(_.byRepository(userName, repositoryName)).delete
+    Milestones    .filter(_.byRepository(userName, repositoryName)).delete
+    WebHooks      .filter(_.byRepository(userName, repositoryName)).delete
+    WebHookEvents .filter(_.byRepository(userName, repositoryName)).delete
+    Repositories  .filter(_.byRepository(userName, repositoryName)).delete

    // Update ORIGIN_USER_NAME and ORIGIN_REPOSITORY_NAME
    Repositories
@@ -178,7 +178,7 @@ trait RepositoryService { self: AccountService =>
        Repositories
          .filter(_.byRepository(userName, repositoryName))
          .map(x => (x.originUserName?, x.originRepositoryName?))
-          .unsafeUpdate(None, None)
+          .update(None, None)
      }

    // Update PARENT_USER_NAME and PARENT_REPOSITORY_NAME
@@ -190,7 +190,7 @@ trait RepositoryService { self: AccountService =>
        Repositories
          .filter(_.byRepository(userName, repositoryName))
          .map(x => (x.parentUserName?, x.parentRepositoryName?))
-          .unsafeUpdate(None, None)
+          .update(None, None)
      }
  }

@@ -319,7 +319,7 @@ trait RepositoryService { self: AccountService =>
   * Updates the last activity date of the repository.
   */
  def updateLastActivityDate(userName: String, repositoryName: String)(implicit s: Session): Unit = {
-    Repositories.filter(_.byRepository(userName, repositoryName)).map(_.lastActivityDate).unsafeUpdate(currentDate)
+    Repositories.filter(_.byRepository(userName, repositoryName)).map(_.lastActivityDate).update(currentDate)
  }

  /**
@@ -331,14 +331,14 @@ trait RepositoryService { self: AccountService =>
      enableWiki: Boolean, allowWikiEditing: Boolean, externalWikiUrl: Option[String])(implicit s: Session): Unit = {
    Repositories.filter(_.byRepository(userName, repositoryName))
      .map { r => (r.description.?, r.isPrivate, r.enableIssues, r.externalIssuesUrl.?, r.enableWiki, r.allowWikiEditing, r.externalWikiUrl.?, r.updatedDate) }
-      .unsafeUpdate (description, isPrivate, enableIssues, externalIssuesUrl, enableWiki, allowWikiEditing, externalWikiUrl, currentDate)
+      .update (description, isPrivate, enableIssues, externalIssuesUrl, enableWiki, allowWikiEditing, externalWikiUrl, currentDate)
  }

  def saveRepositoryDefaultBranch(userName: String, repositoryName: String,
      defaultBranch: String)(implicit s: Session): Unit =
    Repositories.filter(_.byRepository(userName, repositoryName))
      .map { r => r.defaultBranch }
-      .unsafeUpdate (defaultBranch)
+      .update (defaultBranch)

  /**
   * Add collaborator to the repository.
@@ -348,7 +348,7 @@ trait RepositoryService { self: AccountService =>
   * @param collaboratorName the collaborator name
   */
  def addCollaborator(userName: String, repositoryName: String, collaboratorName: String)(implicit s: Session): Unit =
-    Collaborators unsafeInsert Collaborator(userName, repositoryName, collaboratorName)
+    Collaborators insert Collaborator(userName, repositoryName, collaboratorName)

  /**
   * Remove collaborator from the repository.
@@ -358,7 +358,7 @@ trait RepositoryService { self: AccountService =>
   * @param collaboratorName the collaborator name
   */
  def removeCollaborator(userName: String, repositoryName: String, collaboratorName: String)(implicit s: Session): Unit =
-    Collaborators.filter(_.byPrimaryKey(userName, repositoryName, collaboratorName)).unsafeDelete
+    Collaborators.filter(_.byPrimaryKey(userName, repositoryName, collaboratorName)).delete

  /**
   * Remove all collaborators from the repository.
@@ -367,7 +367,7 @@ trait RepositoryService { self: AccountService =>
   * @param repositoryName the repository name
   */
  def removeCollaborators(userName: String, repositoryName: String)(implicit s: Session): Unit =
-    Collaborators.filter(_.byRepository(userName, repositoryName)).unsafeDelete
+    Collaborators.filter(_.byRepository(userName, repositoryName)).delete

  /**
   * Returns the list of collaborators name which is sorted with ascending order.
--- a/src/main/scala/gitbucket/core/service/SshKeyService.scala
+++ b/src/main/scala/gitbucket/core/service/SshKeyService.scala
@@ -3,12 +3,12 @@ package gitbucket.core.service
 import gitbucket.core.model.SshKey
 import gitbucket.core.model.Profile._
 import profile._
-import profile.api._
+import profile.blockingApi._

 trait SshKeyService {

  def addPublicKey(userName: String, title: String, publicKey: String)(implicit s: Session): Unit =
-    SshKeys unsafeInsert SshKey(userName = userName, title = title, publicKey = publicKey)
+    SshKeys insert SshKey(userName = userName, title = title, publicKey = publicKey)

  def getPublicKeys(userName: String)(implicit s: Session): List[SshKey] =
    SshKeys.filter(_.userName === userName.bind).sortBy(_.sshKeyId).list
--- a/src/main/scala/gitbucket/core/service/WebHookService.scala
+++ b/src/main/scala/gitbucket/core/service/WebHookService.scala
@@ -7,7 +7,7 @@ import gitbucket.core.model.{WebHook, Account, Issue, PullRequest, IssueComment,
 import gitbucket.core.model.Profile._
 import org.apache.http.client.utils.URLEncodedUtils
 import profile._
-import profile.api._
+import profile.blockingApi._
 import gitbucket.core.util.JGitUtil.CommitInfo
 import gitbucket.core.util.RepositoryName
 import gitbucket.core.service.RepositoryService.RepositoryInfo
@@ -54,22 +54,22 @@ trait WebHookService {
      .list.groupBy(_._1).mapValues(_.map(_._2).toSet).headOption

  def addWebHook(owner: String, repository: String, url :String, events: Set[WebHook.Event], ctype: WebHookContentType,  token: Option[String])(implicit s: Session): Unit = {
-    WebHooks unsafeInsert WebHook(owner, repository, url, ctype, token)
+    WebHooks insert WebHook(owner, repository, url, ctype, token)
    events.toSet.map { event: WebHook.Event =>
-      WebHookEvents unsafeInsert WebHookEvent(owner, repository, url, event)
+      WebHookEvents insert WebHookEvent(owner, repository, url, event)
    }
  }

  def updateWebHook(owner: String, repository: String, url :String, events: Set[WebHook.Event], ctype: WebHookContentType, token: Option[String])(implicit s: Session): Unit = {
-    WebHooks.filter(_.byPrimaryKey(owner, repository, url)).map(w => (w.ctype, w.token)).unsafeUpdate((ctype, token))
-    WebHookEvents.filter(_.byWebHook(owner, repository, url)).unsafeDelete
+    WebHooks.filter(_.byPrimaryKey(owner, repository, url)).map(w => (w.ctype, w.token)).update((ctype, token))
+    WebHookEvents.filter(_.byWebHook(owner, repository, url)).delete
    events.toSet.map { event: WebHook.Event =>
-      WebHookEvents unsafeInsert WebHookEvent(owner, repository, url, event)
+      WebHookEvents insert WebHookEvent(owner, repository, url, event)
    }
  }

  def deleteWebHook(owner: String, repository: String, url :String)(implicit s: Session): Unit =
-    WebHooks.filter(_.byPrimaryKey(owner, repository, url)).unsafeDelete
+    WebHooks.filter(_.byPrimaryKey(owner, repository, url)).delete

  def callWebHookOf(owner: String, repository: String, event: WebHook.Event)(makePayload: => Option[WebHookPayload])
                   (implicit s: Session, c: JsonFormat.Context): Unit = {
--- a/src/main/scala/gitbucket/core/util/DatabaseConfig.scala
+++ b/src/main/scala/gitbucket/core/util/DatabaseConfig.scala
@@ -4,7 +4,7 @@ import com.typesafe.config.ConfigFactory
 import java.io.File

 import Directory._
-import com.github.takezoe.slick.blocking.{BlockingH2Driver, BlockingMySQLDriver, SlickBlockingAPI}
+import com.github.takezoe.slick.blocking.{BlockingH2Driver, BlockingMySQLDriver, BlockingJdbcProfile}
 import liquibase.database.AbstractJdbcDatabase
 import liquibase.database.core.{H2Database, MySQLDatabase, PostgresDatabase}
 import org.apache.commons.io.FileUtils
@@ -34,14 +34,14 @@ object DatabaseConfig {
  lazy val user: String = config.getString("db.user")
  lazy val password: String = config.getString("db.password")
  lazy val jdbcDriver: String = DatabaseType(url).jdbcDriver
-  lazy val slickDriver: SlickBlockingAPI = DatabaseType(url).slickDriver
+  lazy val slickDriver: BlockingJdbcProfile = DatabaseType(url).slickDriver
  lazy val liquiDriver: AbstractJdbcDatabase = DatabaseType(url).liquiDriver

 }

 sealed trait DatabaseType {
  val jdbcDriver: String
-  val slickDriver: SlickBlockingAPI
+  val slickDriver: BlockingJdbcProfile
  val liquiDriver: AbstractJdbcDatabase
 }

@@ -77,7 +77,7 @@ object DatabaseType {
    val liquiDriver = new PostgresDatabase()
  }

-  object BlockingPostgresDriver extends slick.driver.PostgresDriver with SlickBlockingAPI {
+  object BlockingPostgresDriver extends slick.driver.PostgresDriver with BlockingJdbcProfile {
    override def quoteIdentifier(id: String): String = {
      val s = new StringBuilder(id.length + 4) append '"'
      for(c <- id) if(c == '"') s append "\"\"" else s append c.toLower