Moving to Quill

# Conflicts:
#	build.sbt
#	src/main/scala/gitbucket/core/controller/AccountController.scala
#	src/main/scala/gitbucket/core/controller/UserManagementController.scala

.travis.yml

@@ -1,11 +1,6 @@
 language: scala
-sudo: true
+sudo: false
 script:
   - sbt test
 jdk:
   - oraclejdk8
-before_script:
-  - sudo apt-get install libaio1
-  - sudo /etc/init.d/mysql stop
-  - sudo /etc/init.d/postgresql stop
-

README.md

@@ -1,10 +1,7 @@
 GitBucket [![Gitter chat](https://badges.gitter.im/gitbucket/gitbucket.png)](https://gitter.im/gitbucket/gitbucket) [![Build Status](https://travis-ci.org/gitbucket/gitbucket.svg?branch=master)](https://travis-ci.org/gitbucket/gitbucket)
 =========
 
-GitBucket is a Git platform powered by Scala offering:
-- easy installation
-- high extensibility by plugins
-- API compatibility with Github
+GitBucket is a GitHub clone powered by Scala which has easy installation and high extensibility.
 
 Features
 --------
@@ -59,36 +56,10 @@ Support
 - Make sure check whether there is a same question or request in the past.
 - When raise a new issue, write subject in **English** at least.
 - We can also support in Japaneses other than English at [gitter room for Japanese](https://gitter.im/gitbucket/gitbucket_ja).
-- First priority of GitBucket is easy installation and API compatibility with GitHub, so we might reject if your request is against it.
+- First priority of GitBucket is easy installation and reproduce GitHub behavior, so we might reject if your request is against it.
 
 Release Notes
--------------
-### 4.1 - 4 Jun 2016
-
-- Generic ssh user
-- Improve branch protection UI
-- Default value of pull request title
-
-### 4.0 - 30 Apr 2016
-
-- MySQL and PostgreSQL support
-- Data export and import
-- Migration system has been switched to [solidbase](https://github.com/gitbucket/solidbase)
-
-**Note:** You can upgrade to GitBucket 4.0 from 3.14. If your GitBucket is 3.13 or before, you have to upgrade 3.14 at first.
-
-### 3.14 - 30 Apr 2016
-
-- File attachment and search for wiki pages
-- New extension points to add menus
-- Content-Type of webhooks has been choosable
-
-### 3.13 - 1 Apr 2016
-- Refresh user interface for wide screen
-- Add `pull_request` key in list issues API for pull requests
-- Add `X-Hub-Signature` security to webhooks
-- Provide SHA-256 checksum for `gitbucket.war`
-
+--------
 ### 3.12 - 27 Feb 2016
 - New GitHub UI
 - Improve mobile view

build.sbt

@@ -1,6 +1,6 @@
 val Organization = "gitbucket"
 val Name = "gitbucket"
-val GitBucketVersion = "4.1.0"
+val GitBucketVersion = "3.12.0"
 val ScalatraVersion = "2.4.0"
 val JettyVersion = "9.3.6.v20151106"
 
@@ -10,17 +10,14 @@ sourcesInBase := false
 organization := Organization
 name := Name
 version := GitBucketVersion
-scalaVersion := "2.11.8"
+scalaVersion := "2.11.7"
 
 // dependency settings
 resolvers ++= Seq(
   Classpaths.typesafeReleases,
-  "amateras" at "http://amateras.sourceforge.jp/mvn/",
-  "sonatype-snapshot" at "https://oss.sonatype.org/content/repositories/snapshots/",
-  "amateras-snapshot" at "http://amateras.sourceforge.jp/mvn-snapshot/"
+  "sonatype-snapshot" at "https://oss.sonatype.org/content/repositories/snapshots/"
 )
 libraryDependencies ++= Seq(
-  "org.scala-lang.modules"   %% "scala-java8-compat"           % "0.7.0",
   "org.eclipse.jgit"          % "org.eclipse.jgit.http.server" % "4.1.1.201511131810-r",
   "org.eclipse.jgit"          % "org.eclipse.jgit.archive"     % "4.1.1.201511131810-r",
   "org.scalatra"             %% "scalatra"                     % ScalatraVersion,
@@ -28,8 +25,7 @@ libraryDependencies ++= Seq(
   "org.json4s"               %% "json4s-jackson"               % "3.3.0",
   "io.github.gitbucket"      %% "scalatra-forms"               % "1.0.0",
   "commons-io"                % "commons-io"                   % "2.4",
-  "io.github.gitbucket"       % "solidbase"                    % "1.0.0",
-  "io.github.gitbucket"       % "markedj"                      % "1.0.9-SNAPSHOT",
+  "io.github.gitbucket"       % "markedj"                      % "1.0.7",
   "org.apache.commons"        % "commons-compress"             % "1.10",
   "org.apache.commons"        % "commons-email"                % "1.4",
   "org.apache.httpcomponents" % "httpclient"                   % "4.5.1",
@@ -38,38 +34,31 @@ libraryDependencies ++= Seq(
   "com.typesafe.slick"       %% "slick"                        % "2.1.0",
   "com.novell.ldap"           % "jldap"                        % "2009-10-07",
   "com.h2database"            % "h2"                           % "1.4.190",
-  "mysql"                     % "mysql-connector-java"         % "5.1.38",
-  "org.postgresql"            % "postgresql"                   % "9.4.1208",
   "ch.qos.logback"            % "logback-classic"              % "1.1.1",
-  "com.zaxxer"                % "HikariCP"                     % "2.4.5",
+  "com.mchange"               % "c3p0"                         % "0.9.5.2",
   "com.typesafe"              % "config"                       % "1.3.0",
   "com.typesafe.akka"        %% "akka-actor"                   % "2.3.14",
+  "io.getquill"              %% "quill-jdbc"                   % "0.4.1",
   "fr.brouillard.oss.security.xhub" % "xhub4j-core"            % "1.0.0",
   "com.enragedginger"        %% "akka-quartz-scheduler"        % "1.4.0-akka-2.3.x" exclude("c3p0","c3p0"),
   "org.eclipse.jetty"         % "jetty-webapp"                 % JettyVersion     % "provided",
   "javax.servlet"             % "javax.servlet-api"            % "3.1.0"          % "provided",
   "junit"                     % "junit"                        % "4.12"           % "test",
   "org.scalatra"             %% "scalatra-scalatest"           % ScalatraVersion  % "test",
-  "org.scalaz"               %% "scalaz-core"                  % "7.2.0"          % "test",
-  "com.wix"                   % "wix-embedded-mysql"           % "1.0.3"          % "test",
-  "ru.yandex.qatools.embed"   % "postgresql-embedded"          % "1.14"           % "test"
+  "org.scalaz"               %% "scalaz-core"                  % "7.2.0"          % "test"
 )
 
 // Twirl settings
 play.twirl.sbt.Import.TwirlKeys.templateImports += "gitbucket.core._"
 
 // Compiler settings
-scalacOptions := Seq("-deprecation", "-language:postfixOps", "-Ybackend:GenBCode", "-Ydelambdafy:method", "-target:jvm-1.8")
+scalacOptions := Seq("-deprecation", "-language:postfixOps")
 javacOptions in compile ++= Seq("-target", "8", "-source", "8")
 javaOptions in Jetty += "-Dlogback.configurationFile=/logback-dev.xml"
-
-// Test settings
-//testOptions in Test += Tests.Argument("-l", "ExternalDBTest")
+testOptions in Test += Tests.Argument(TestFrameworks.Specs2, "junitxml", "console")
 javaOptions in Test += "-Dgitbucket.home=target/gitbucket_home_for_test"
 testOptions in Test += Tests.Setup( () => new java.io.File("target/gitbucket_home_for_test").mkdir() )
 fork in Test := true
-
-// Packaging options
 packageOptions += Package.MainClass("JettyLauncher")
 
 // Assembly settings
@@ -84,13 +73,12 @@ assemblyMergeStrategy in assembly := {
 }
 
 // JRebel
-Seq(jrebelSettings: _*)
-
 jrebel.webLinks += (target in webappPrepare).value
 jrebel.enabled := System.getenv().get("JREBEL") != null
 javaOptions in Jetty ++= Option(System.getenv().get("JREBEL")).toSeq.flatMap { path =>
   Seq("-noverify", "-XX:+UseConcMarkSweepGC", "-XX:+CMSClassUnloadingEnabled", s"-javaagent:${path}")
 }
+jrebelSettings
 
 // Create executable war file
 val executableConfig = config("executable").hide

doc/release.md

@@ -11,24 +11,22 @@ Note to update version number in files below:
 ```scala
 val Organization = "gitbucket"
 val Name = "gitbucket"
-val GitBucketVersion = "4.0.0" // <---- update version!!
+val GitBucketVersion = "3.12.0" // <---- update version!!
 val ScalatraVersion = "2.4.0"
 val JettyVersion = "9.3.6.v20151106"
 ```
 
-### src/main/scala/gitbucket/core/GitBucketCoreModule.scala
+### src/main/scala/gitbucket/core/servlet/AutoUpdate.scala
 
 ```scala
-object GitBucketCoreModule extends Module("gitbucket-core",
-  // add new version definition
-  new Version("4.1.0",
-    new LiquibaseMigration("update/gitbucket-core_4.1.xml")
-  ),
-  new Version("4.0.0",
-    new LiquibaseMigration("update/gitbucket-core_4.0.xml"),
-    new SqlMigration("update/gitbucket-core_4.0.sql")
-  )
-)
+object AutoUpdate {
+
+  /**
+   * The history of versions. A head of this sequence is the current GitBucket version.
+   */
+  val versions = Seq(
+    new Version(3, 12), // <---- add this line!!
+    new Version(3, 11),
 ```
 
 Generate release files

release/pom.xml

@@ -10,7 +10,7 @@
             <extension>
                 <groupId>org.apache.maven.wagon</groupId>
                 <artifactId>wagon-ssh</artifactId>
-                <version>2.10</version>
+                <version>1.0-beta-6</version>
             </extension>
         </extensions>
     </build>

sbt.bat

@@ -1,2 +1,2 @@
 set SCRIPT_DIR=%~dp0
-java %JAVA_OPTS% -Dsbt.log.noformat=true -XX:+CMSClassUnloadingEnabled -Xmx512M -Xss2M -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005 -jar "%SCRIPT_DIR%\sbt-launch-0.13.9.jar" %*
+java %JAVA_OPTS% -Dsbt.log.noformat=true -XX:+CMSClassUnloadingEnabled -XX:MaxPermSize=256m -Xmx512M -Xss2M -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005 -jar "%SCRIPT_DIR%\sbt-launch-0.13.9.jar" %*

sbt.sh

@@ -1,2 +1,2 @@
 #!/bin/sh
-java $JAVA_OPTS -Dsbt.log.noformat=true -XX:+CMSClassUnloadingEnabled -Xmx512M -Xss2M -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005 -jar `dirname $0`/sbt-launch-0.13.9.jar "$@"
+java $JAVA_OPTS -Dsbt.log.noformat=true -XX:+CMSClassUnloadingEnabled -XX:MaxPermSize=256m -Xmx512M -Xss2M -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005 -jar `dirname $0`/sbt-launch-0.13.9.jar "$@"

src/main/java/JettyLauncher.java

@@ -43,9 +43,10 @@ public class JettyLauncher {
         WebAppContext context = new WebAppContext();
 
         File tmpDir = new File(getGitBucketHome(), "tmp");
-        if(!tmpDir.exists()){
-            tmpDir.mkdirs();
+        if(tmpDir.exists()){
+            deleteDirectory(tmpDir);
         }
+        tmpDir.mkdirs();
         context.setTempDirectory(tmpDir);
 
         ProtectionDomain domain = JettyLauncher.class.getProtectionDomain();

src/main/java/org/postgresql/Driver2.java

@@ -1,52 +0,0 @@
-package org.postgresql;
-
-import java.lang.reflect.InvocationHandler;
-import java.lang.reflect.Method;
-import java.lang.reflect.Proxy;
-import java.sql.Connection;
-import java.sql.SQLException;
-import java.util.Properties;
-
-/**
- * Wraps the PostgreSQL JDBC driver to convert the returning column names to lower case.
- */
-public class Driver2 extends Driver {
-
-    @Override
-    public java.sql.Connection connect(String url, Properties info) throws SQLException {
-        Connection conn =  super.connect(url, info);
-
-        Object proxy = Proxy.newProxyInstance(
-                conn.getClass().getClassLoader(),
-                new Class[]{ Connection.class },
-                new ConnectionProxyHandler(conn)
-        );
-
-        return Connection.class.cast(proxy);
-    }
-
-
-    private static class ConnectionProxyHandler implements InvocationHandler {
-
-        private Connection conn;
-
-        public ConnectionProxyHandler(Connection conn){
-            this.conn = conn;
-        }
-
-        @Override
-        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
-            if(method.getName().equals("prepareStatement")){
-                if(args != null && args.length == 2 && args[1].getClass().isArray()){
-                    String[] keys = (String[]) args[1];
-                    for(int i = 0; i < keys.length; i++){
-                        keys[i] = keys[i].toLowerCase();
-                    }
-                }
-            }
-            return method.invoke(conn, args);
-        }
-    }
-
-}
-

src/main/resources/application.conf

@@ -0,0 +1,8 @@
+db.dataSourceClassName="org.h2.jdbcx.JdbcDataSource"
+db.dataSource.url="jdbc:h2:~/.gitbucket/data;MVCC=true"
+db.dataSource.user="sa"
+db.dataSource.password="sa"
+#db.dataSource.cachePrepStmts=true
+#db.dataSource.prepStmtCacheSize=250
+#db.dataSource.prepStmtCacheSqlLimit=2048
+#db.connectionTimeout=30000

src/main/resources/database.conf

@@ -0,0 +1,6 @@
+db {
+  driver = "org.h2.Driver"
+  url = "jdbc:h2:${DatabaseHome};MVCC=true"
+  user = "sa"
+  password = "sa"
+}

src/main/resources/logback-dev.xml

@@ -20,7 +20,7 @@
   <!--
   <logger name="service.WebHookService" level="DEBUG" />
   <logger name="servlet" level="DEBUG" />
-  <logger name="scala.slick.jdbc.JdbcBackend.statement" level="DEBUG" />
   -->
+  <logger name="scala.slick.jdbc.JdbcBackend.statement" level="DEBUG" />
 
 </configuration>

src/main/resources/reference.conf

@@ -0,0 +1,5 @@
+c3p0 {
+  privilegeSpawnedThreads=true
+  contextClassLoaderSource=library
+}
+

src/main/resources/update/1_0.sql

@@ -0,0 +1,135 @@
+CREATE TABLE ACCOUNT(
+		USER_NAME VARCHAR(100) NOT NULL,
+		MAIL_ADDRESS VARCHAR(100) NOT NULL,
+		PASSWORD VARCHAR(40) NOT NULL,
+		ADMINISTRATOR BOOLEAN NOT NULL,
+		URL VARCHAR(200),
+		REGISTERED_DATE TIMESTAMP NOT NULL,
+		UPDATED_DATE TIMESTAMP NOT NULL,
+		LAST_LOGIN_DATE TIMESTAMP
+);
+
+CREATE TABLE REPOSITORY(
+		USER_NAME VARCHAR(100) NOT NULL,
+		REPOSITORY_NAME VARCHAR(100) NOT NULL,
+		PRIVATE BOOLEAN NOT NULL,
+		DESCRIPTION TEXT,
+		DEFAULT_BRANCH VARCHAR(100),
+		REGISTERED_DATE TIMESTAMP NOT NULL,
+		UPDATED_DATE TIMESTAMP NOT NULL,
+		LAST_ACTIVITY_DATE TIMESTAMP NOT NULL
+);
+
+CREATE TABLE COLLABORATOR(
+		USER_NAME VARCHAR(100) NOT NULL,
+		REPOSITORY_NAME VARCHAR(100) NOT NULL,
+		COLLABORATOR_NAME VARCHAR(100) NOT NULL
+);
+
+CREATE TABLE ISSUE(
+		USER_NAME VARCHAR(100) NOT NULL,
+		REPOSITORY_NAME VARCHAR(100) NOT NULL,
+		ISSUE_ID INT NOT NULL,
+		OPENED_USER_NAME VARCHAR(100) NOT NULL,
+		MILESTONE_ID INT,
+		ASSIGNED_USER_NAME VARCHAR(100),
+		TITLE TEXT NOT NULL,
+		CONTENT TEXT,
+		CLOSED BOOLEAN NOT NULL,
+		REGISTERED_DATE TIMESTAMP NOT NULL,
+		UPDATED_DATE TIMESTAMP NOT NULL
+);
+
+CREATE TABLE ISSUE_ID(
+		USER_NAME VARCHAR(100) NOT NULL,
+		REPOSITORY_NAME VARCHAR(100) NOT NULL,
+		ISSUE_ID INT NOT NULL
+);
+
+CREATE TABLE ISSUE_COMMENT(
+		USER_NAME VARCHAR(100) NOT NULL,
+		REPOSITORY_NAME VARCHAR(100) NOT NULL,
+		ISSUE_ID INT NOT NULL,
+		COMMENT_ID INT AUTO_INCREMENT,
+		ACTION VARCHAR(10),
+		COMMENTED_USER_NAME VARCHAR(100) NOT NULL,
+		CONTENT TEXT NOT NULL,
+		REGISTERED_DATE TIMESTAMP NOT NULL,
+		UPDATED_DATE TIMESTAMP NOT NULL
+);
+
+CREATE TABLE LABEL(
+		USER_NAME VARCHAR(100) NOT NULL,
+		REPOSITORY_NAME VARCHAR(100) NOT NULL,
+		LABEL_ID INT AUTO_INCREMENT,
+		LABEL_NAME VARCHAR(100) NOT NULL,
+		COLOR CHAR(6) NOT NULL
+);
+
+CREATE TABLE ISSUE_LABEL(
+		USER_NAME VARCHAR(100) NOT NULL,
+		REPOSITORY_NAME VARCHAR(100) NOT NULL,
+		ISSUE_ID INT NOT NULL,
+		LABEL_ID INT NOT NULL
+);
+
+CREATE TABLE MILESTONE(
+		USER_NAME VARCHAR(100) NOT NULL,
+		REPOSITORY_NAME VARCHAR(100) NOT NULL,
+		MILESTONE_ID INT AUTO_INCREMENT,
+		TITLE VARCHAR(100) NOT NULL,
+		DESCRIPTION TEXT,
+		DUE_DATE TIMESTAMP,
+		CLOSED_DATE TIMESTAMP
+);
+
+ALTER TABLE ACCOUNT ADD CONSTRAINT IDX_ACCOUNT_PK PRIMARY KEY (USER_NAME);
+ALTER TABLE ACCOUNT ADD CONSTRAINT IDX_ACCOUNT_1 UNIQUE (MAIL_ADDRESS);
+
+ALTER TABLE REPOSITORY ADD CONSTRAINT IDX_REPOSITORY_PK PRIMARY KEY (USER_NAME, REPOSITORY_NAME);
+ALTER TABLE REPOSITORY ADD CONSTRAINT IDX_REPOSITORY_FK0 FOREIGN KEY (USER_NAME) REFERENCES ACCOUNT (USER_NAME);
+
+ALTER TABLE COLLABORATOR ADD CONSTRAINT IDX_COLLABORATOR_PK PRIMARY KEY (USER_NAME, REPOSITORY_NAME);
+ALTER TABLE COLLABORATOR ADD CONSTRAINT IDX_COLLABORATOR_FK0 FOREIGN KEY (USER_NAME, REPOSITORY_NAME) REFERENCES REPOSITORY (USER_NAME, REPOSITORY_NAME);
+ALTER TABLE COLLABORATOR ADD CONSTRAINT IDX_COLLABORATOR_FK1 FOREIGN KEY (COLLABORATOR_NAME) REFERENCES ACCOUNT (USER_NAME);
+
+ALTER TABLE ISSUE ADD CONSTRAINT IDX_ISSUE_PK PRIMARY KEY (ISSUE_ID, USER_NAME, REPOSITORY_NAME);
+ALTER TABLE ISSUE ADD CONSTRAINT IDX_ISSUE_FK0 FOREIGN KEY (USER_NAME, REPOSITORY_NAME) REFERENCES REPOSITORY (USER_NAME, REPOSITORY_NAME);
+ALTER TABLE ISSUE ADD CONSTRAINT IDX_ISSUE_FK1 FOREIGN KEY (OPENED_USER_NAME) REFERENCES ACCOUNT (USER_NAME);
+ALTER TABLE ISSUE ADD CONSTRAINT IDX_ISSUE_FK2 FOREIGN KEY (MILESTONE_ID) REFERENCES MILESTONE (MILESTONE_ID);
+
+ALTER TABLE ISSUE_ID ADD CONSTRAINT IDX_ISSUE_ID_PK PRIMARY KEY (USER_NAME, REPOSITORY_NAME);
+ALTER TABLE ISSUE_ID ADD CONSTRAINT IDX_ISSUE_ID_FK1 FOREIGN KEY (USER_NAME, REPOSITORY_NAME) REFERENCES REPOSITORY (USER_NAME, REPOSITORY_NAME);
+
+ALTER TABLE ISSUE_COMMENT ADD CONSTRAINT IDX_ISSUE_COMMENT_PK PRIMARY KEY (COMMENT_ID);
+ALTER TABLE ISSUE_COMMENT ADD CONSTRAINT IDX_ISSUE_COMMENT_1 UNIQUE (USER_NAME, REPOSITORY_NAME, ISSUE_ID, COMMENT_ID);
+ALTER TABLE ISSUE_COMMENT ADD CONSTRAINT IDX_ISSUE_COMMENT_FK0 FOREIGN KEY (USER_NAME, REPOSITORY_NAME, ISSUE_ID) REFERENCES ISSUE (USER_NAME, REPOSITORY_NAME, ISSUE_ID);
+
+ALTER TABLE LABEL ADD CONSTRAINT IDX_LABEL_PK PRIMARY KEY (USER_NAME, REPOSITORY_NAME, LABEL_ID);
+ALTER TABLE LABEL ADD CONSTRAINT IDX_LABEL_FK0 FOREIGN KEY (USER_NAME, REPOSITORY_NAME) REFERENCES REPOSITORY (USER_NAME, REPOSITORY_NAME);
+
+ALTER TABLE ISSUE_LABEL ADD CONSTRAINT IDX_ISSUE_LABEL_PK PRIMARY KEY (USER_NAME, REPOSITORY_NAME, ISSUE_ID, LABEL_ID);
+ALTER TABLE ISSUE_LABEL ADD CONSTRAINT IDX_ISSUE_LABEL_FK0 FOREIGN KEY (USER_NAME, REPOSITORY_NAME, ISSUE_ID) REFERENCES ISSUE (USER_NAME, REPOSITORY_NAME, ISSUE_ID);
+
+ALTER TABLE MILESTONE ADD CONSTRAINT IDX_MILESTONE_PK PRIMARY KEY (USER_NAME, REPOSITORY_NAME, MILESTONE_ID);
+ALTER TABLE MILESTONE ADD CONSTRAINT IDX_MILESTONE_FK0 FOREIGN KEY (USER_NAME, REPOSITORY_NAME) REFERENCES REPOSITORY (USER_NAME, REPOSITORY_NAME);
+
+INSERT INTO ACCOUNT (
+  USER_NAME,
+  MAIL_ADDRESS,
+  PASSWORD,
+  ADMINISTRATOR,
+  URL,
+  REGISTERED_DATE,
+  UPDATED_DATE,
+  LAST_LOGIN_DATE
+) VALUES (
+  'root',
+  'root@localhost',
+  'dc76e9f0c0006e8f919e0c515c66dbba3982f785',
+  true,
+  'https://github.com/gitbucket/gitbucket',
+  SYSDATE,
+  SYSDATE,
+  NULL
+);

src/main/resources/update/1_1.sql

@@ -0,0 +1,8 @@
+-- Fix COLLABORATOR constraints
+ALTER TABLE COLLABORATOR DROP CONSTRAINT IDX_COLLABORATOR_FK1 IF EXISTS;
+ALTER TABLE COLLABORATOR DROP CONSTRAINT IDX_COLLABORATOR_FK0 IF EXISTS;
+ALTER TABLE COLLABORATOR DROP CONSTRAINT IDX_COLLABORATOR_PK IF EXISTS;
+
+ALTER TABLE COLLABORATOR ADD CONSTRAINT IDX_COLLABORATOR_PK PRIMARY KEY (USER_NAME, REPOSITORY_NAME, COLLABORATOR_NAME);
+ALTER TABLE COLLABORATOR ADD CONSTRAINT IDX_COLLABORATOR_FK0 FOREIGN KEY (USER_NAME, REPOSITORY_NAME) REFERENCES REPOSITORY (USER_NAME, REPOSITORY_NAME);
+ALTER TABLE COLLABORATOR ADD CONSTRAINT IDX_COLLABORATOR_FK1 FOREIGN KEY (COLLABORATOR_NAME) REFERENCES ACCOUNT (USER_NAME);

src/main/resources/update/1_12.sql

@@ -0,0 +1,11 @@
+ALTER TABLE GROUP_MEMBER ADD COLUMN MANAGER BOOLEAN DEFAULT FALSE;
+
+CREATE TABLE SSH_KEY (
+  USER_NAME VARCHAR(100) NOT NULL,
+  SSH_KEY_ID INT AUTO_INCREMENT,
+  TITLE VARCHAR(100) NOT NULL,
+  PUBLIC_KEY TEXT NOT NULL
+);
+
+ALTER TABLE SSH_KEY ADD CONSTRAINT IDX_SSH_KEY_PK PRIMARY KEY (USER_NAME, SSH_KEY_ID);
+ALTER TABLE SSH_KEY ADD CONSTRAINT IDX_SSH_KEY_FK0 FOREIGN KEY (USER_NAME) REFERENCES ACCOUNT (USER_NAME);

src/main/resources/update/1_13.sql

@@ -0,0 +1 @@
+DROP TABLE COMMIT_LOG;

src/main/resources/update/1_2.sql

@@ -0,0 +1,24 @@
+CREATE TABLE ACTIVITY(
+		ACTIVITY_ID INT AUTO_INCREMENT,
+		USER_NAME VARCHAR(100) NOT NULL,
+		REPOSITORY_NAME VARCHAR(100) NOT NULL,
+		ACTIVITY_USER_NAME VARCHAR(100) NOT NULL,
+		ACTIVITY_TYPE VARCHAR(100) NOT NULL,
+		MESSAGE TEXT NOT NULL,
+		ADDITIONAL_INFO TEXT,
+		ACTIVITY_DATE TIMESTAMP NOT NULL
+);
+
+CREATE TABLE COMMIT_LOG (
+		USER_NAME VARCHAR(100) NOT NULL,
+		REPOSITORY_NAME VARCHAR(100) NOT NULL,
+		COMMIT_ID VARCHAR(40) NOT NULL
+);
+
+ALTER TABLE ACTIVITY ADD CONSTRAINT IDX_ACTIVITY_PK PRIMARY KEY (ACTIVITY_ID);
+ALTER TABLE ACTIVITY ADD CONSTRAINT IDX_ACTIVITY_FK0 FOREIGN KEY (USER_NAME, REPOSITORY_NAME) REFERENCES REPOSITORY (USER_NAME, REPOSITORY_NAME);
+ALTER TABLE ACTIVITY ADD CONSTRAINT IDX_ACTIVITY_FK1 FOREIGN KEY (ACTIVITY_USER_NAME) REFERENCES ACCOUNT (USER_NAME);
+
+ALTER TABLE COMMIT_LOG ADD CONSTRAINT IDX_COMMIT_LOG_PK PRIMARY KEY (USER_NAME, REPOSITORY_NAME, COMMIT_ID);
+ALTER TABLE COMMIT_LOG ADD CONSTRAINT IDX_COMMIT_LOG_FK0 FOREIGN KEY (USER_NAME, REPOSITORY_NAME) REFERENCES REPOSITORY (USER_NAME, REPOSITORY_NAME);
+

src/main/resources/update/1_3.sql

@@ -0,0 +1,8 @@
+ALTER TABLE ACCOUNT ADD COLUMN IMAGE VARCHAR(100);
+
+UPDATE ISSUE_COMMENT SET ACTION = 'comment' WHERE ACTION IS NULL;
+
+ALTER TABLE ISSUE_COMMENT ALTER COLUMN ACTION VARCHAR(20) NOT NULL;
+
+UPDATE ISSUE_COMMENT SET ACTION = 'close_comment'  WHERE ACTION = 'close';
+UPDATE ISSUE_COMMENT SET ACTION = 'reopen_comment' WHERE ACTION = 'reopen';

src/main/resources/update/1_4.sql

@@ -0,0 +1,24 @@
+CREATE TABLE GROUP_MEMBER(
+  GROUP_NAME VARCHAR(100) NOT NULL,
+  USER_NAME  VARCHAR(100) NOT NULL
+);
+
+ALTER TABLE GROUP_MEMBER ADD CONSTRAINT IDX_GROUP_MEMBER_PK PRIMARY KEY (GROUP_NAME, USER_NAME);
+ALTER TABLE GROUP_MEMBER ADD CONSTRAINT IDX_GROUP_MEMBER_FK0 FOREIGN KEY (GROUP_NAME) REFERENCES ACCOUNT (USER_NAME);
+ALTER TABLE GROUP_MEMBER ADD CONSTRAINT IDX_GROUP_MEMBER_FK1 FOREIGN KEY (USER_NAME) REFERENCES ACCOUNT (USER_NAME);
+
+ALTER TABLE ACCOUNT ADD COLUMN GROUP_ACCOUNT BOOLEAN NOT NULL DEFAULT FALSE;
+
+CREATE OR REPLACE VIEW ISSUE_OUTLINE_VIEW AS
+ SELECT
+   A.USER_NAME,
+   A.REPOSITORY_NAME,
+   A.ISSUE_ID,
+   NVL(B.COMMENT_COUNT, 0) AS COMMENT_COUNT
+ FROM ISSUE A
+ LEFT OUTER JOIN (
+   SELECT USER_NAME, REPOSITORY_NAME, ISSUE_ID, COUNT(COMMENT_ID) AS COMMENT_COUNT FROM ISSUE_COMMENT
+   WHERE ACTION IN ('comment', 'close_comment', 'reopen_comment')
+   GROUP BY USER_NAME, REPOSITORY_NAME, ISSUE_ID
+ ) B
+ ON (A.USER_NAME = B.USER_NAME AND A.REPOSITORY_NAME = B.REPOSITORY_NAME AND A.ISSUE_ID = B.ISSUE_ID);

src/main/resources/update/1_5.sql

@@ -0,0 +1,21 @@
+ALTER TABLE REPOSITORY ADD COLUMN ORIGIN_USER_NAME VARCHAR(100);
+ALTER TABLE REPOSITORY ADD COLUMN ORIGIN_REPOSITORY_NAME VARCHAR(100);
+ALTER TABLE REPOSITORY ADD COLUMN PARENT_USER_NAME VARCHAR(100);
+ALTER TABLE REPOSITORY ADD COLUMN PARENT_REPOSITORY_NAME VARCHAR(100);
+
+CREATE TABLE PULL_REQUEST(
+		USER_NAME VARCHAR(100) NOT NULL,
+		REPOSITORY_NAME VARCHAR(100) NOT NULL,
+		ISSUE_ID INT NOT NULL,
+		BRANCH VARCHAR(100) NOT NULL,
+		REQUEST_USER_NAME VARCHAR(100) NOT NULL,
+		REQUEST_REPOSITORY_NAME VARCHAR(100) NOT NULL,
+		REQUEST_BRANCH VARCHAR(100) NOT NULL,
+		COMMIT_ID_FROM VARCHAR(40) NOT NULL,
+		COMMIT_ID_TO VARCHAR(40) NOT NULL
+);
+
+ALTER TABLE PULL_REQUEST ADD CONSTRAINT IDX_PULL_REQUEST_PK PRIMARY KEY (USER_NAME, REPOSITORY_NAME, ISSUE_ID);
+ALTER TABLE PULL_REQUEST ADD CONSTRAINT IDX_PULL_REQUEST_FK0 FOREIGN KEY (USER_NAME, REPOSITORY_NAME, ISSUE_ID) REFERENCES ISSUE (USER_NAME, REPOSITORY_NAME, ISSUE_ID);
+
+ALTER TABLE ISSUE ADD COLUMN PULL_REQUEST BOOLEAN NOT NULL DEFAULT FALSE;

src/main/resources/update/1_6.sql

@@ -0,0 +1,8 @@
+CREATE TABLE WEB_HOOK (
+		USER_NAME VARCHAR(100) NOT NULL,
+		REPOSITORY_NAME VARCHAR(100) NOT NULL,
+		URL VARCHAR(200) NOT NULL
+);
+
+ALTER TABLE WEB_HOOK ADD CONSTRAINT IDX_WEB_HOOK_PK PRIMARY KEY (USER_NAME, REPOSITORY_NAME, URL);
+ALTER TABLE WEB_HOOK ADD CONSTRAINT IDX_WEB_HOOK_FK0 FOREIGN KEY (USER_NAME, REPOSITORY_NAME) REFERENCES REPOSITORY (USER_NAME, REPOSITORY_NAME);

src/main/resources/update/1_7.sql

@@ -0,0 +1,5 @@
+ALTER TABLE ACCOUNT ADD COLUMN FULL_NAME VARCHAR(100);
+
+UPDATE ACCOUNT SET FULL_NAME = USER_NAME WHERE FULL_NAME IS NULL;
+
+ALTER TABLE ACCOUNT ALTER COLUMN FULL_NAME SET NOT NULL;

src/main/resources/update/1_8.sql

@@ -0,0 +1 @@
+ALTER TABLE ACCOUNT ADD COLUMN REMOVED BOOLEAN DEFAULT FALSE;

src/main/resources/update/2_3.sql

@@ -0,0 +1,6 @@
+CREATE TABLE PLUGIN (
+  PLUGIN_ID VARCHAR(100) NOT NULL,
+  VERSION   VARCHAR(100) NOT NULL
+);
+
+ALTER TABLE PLUGIN ADD CONSTRAINT IDX_PLUGIN_PK PRIMARY KEY (PLUGIN_ID);

src/main/resources/update/2_7.sql

@@ -0,0 +1,18 @@
+CREATE TABLE COMMIT_COMMENT (
+    USER_NAME VARCHAR(100) NOT NULL,
+    REPOSITORY_NAME VARCHAR(100) NOT NULL,
+    COMMIT_ID VARCHAR(100) NOT NULL,
+    COMMENT_ID INT AUTO_INCREMENT,
+    COMMENTED_USER_NAME VARCHAR(100) NOT NULL,
+    CONTENT TEXT NOT NULL,
+    FILE_NAME NVARCHAR(100),
+    OLD_LINE_NUMBER INT,
+    NEW_LINE_NUMBER INT,
+    REGISTERED_DATE TIMESTAMP NOT NULL,
+    UPDATED_DATE TIMESTAMP NOT NULL,
+    PULL_REQUEST BOOLEAN NOT NULL
+);
+
+ALTER TABLE COMMIT_COMMENT ADD CONSTRAINT IDX_COMMIT_COMMENT_PK PRIMARY KEY (COMMENT_ID);
+ALTER TABLE COMMIT_COMMENT ADD CONSTRAINT IDX_COMMIT_COMMENT_FK0 FOREIGN KEY (USER_NAME, REPOSITORY_NAME) REFERENCES REPOSITORY (USER_NAME, REPOSITORY_NAME);
+ALTER TABLE COMMIT_COMMENT ADD CONSTRAINT IDX_COMMIT_COMMENT_1 UNIQUE (USER_NAME, REPOSITORY_NAME, COMMIT_ID, COMMENT_ID);

src/main/resources/update/2_8.sql

@@ -0,0 +1 @@
+ALTER TABLE COMMIT_COMMENT ALTER COLUMN FILE_NAME NVARCHAR(260);

src/main/resources/update/3_1.sql

@@ -0,0 +1,42 @@
+DROP TABLE IF EXISTS ACCESS_TOKEN;
+
+CREATE TABLE ACCESS_TOKEN (
+   ACCESS_TOKEN_ID INT NOT NULL AUTO_INCREMENT,
+   TOKEN_HASH VARCHAR(40) NOT NULL,
+   USER_NAME VARCHAR(100) NOT NULL,
+   NOTE TEXT NOT NULL
+);
+
+ALTER TABLE ACCESS_TOKEN ADD CONSTRAINT IDX_ACCESS_TOKEN_PK PRIMARY KEY (ACCESS_TOKEN_ID);
+ALTER TABLE ACCESS_TOKEN ADD CONSTRAINT IDX_ACCESS_TOKEN_FK0 FOREIGN KEY (USER_NAME) REFERENCES ACCOUNT (USER_NAME)
+  ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE ACCESS_TOKEN ADD CONSTRAINT IDX_ACCESS_TOKEN_TOKEN_HASH UNIQUE(TOKEN_HASH);
+
+
+DROP TABLE IF EXISTS COMMIT_STATUS;
+CREATE TABLE COMMIT_STATUS(
+  COMMIT_STATUS_ID INT AUTO_INCREMENT,
+  USER_NAME VARCHAR(100) NOT NULL,
+  REPOSITORY_NAME VARCHAR(100) NOT NULL,
+  COMMIT_ID VARCHAR(40) NOT NULL,
+  CONTEXT VARCHAR(255) NOT NULL, -- context is too long (maximum is 255 characters)
+  STATE VARCHAR(10) NOT NULL, -- pending, success, error, or failure
+  TARGET_URL VARCHAR(200),
+  DESCRIPTION TEXT,
+  CREATOR VARCHAR(100) NOT NULL,
+  REGISTERED_DATE TIMESTAMP NOT NULL, -- CREATED_AT
+  UPDATED_DATE TIMESTAMP NOT NULL -- UPDATED_AT
+);
+ALTER TABLE COMMIT_STATUS ADD CONSTRAINT IDX_COMMIT_STATUS_PK PRIMARY KEY (COMMIT_STATUS_ID);
+ALTER TABLE COMMIT_STATUS ADD CONSTRAINT IDX_COMMIT_STATUS_1
+  UNIQUE (USER_NAME, REPOSITORY_NAME, COMMIT_ID, CONTEXT);
+ALTER TABLE COMMIT_STATUS ADD CONSTRAINT IDX_COMMIT_STATUS_FK1
+  FOREIGN KEY (USER_NAME, REPOSITORY_NAME)
+  REFERENCES REPOSITORY (USER_NAME, REPOSITORY_NAME)
+  ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE COMMIT_STATUS ADD CONSTRAINT IDX_COMMIT_STATUS_FK2
+  FOREIGN KEY (USER_NAME) REFERENCES ACCOUNT (USER_NAME)
+  ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE COMMIT_STATUS ADD CONSTRAINT IDX_COMMIT_STATUS_FK3
+  FOREIGN KEY (CREATOR) REFERENCES ACCOUNT (USER_NAME)
+  ON DELETE CASCADE ON UPDATE CASCADE;

src/main/resources/update/3_11.sql

@@ -0,0 +1,25 @@
+DROP TABLE IF EXISTS PROTECTED_BRANCH;
+
+CREATE TABLE PROTECTED_BRANCH(
+    USER_NAME VARCHAR(100) NOT NULL,
+    REPOSITORY_NAME VARCHAR(100) NOT NULL,
+    BRANCH VARCHAR(100) NOT NULL,
+    STATUS_CHECK_ADMIN BOOLEAN NOT NULL DEFAULT false
+);
+
+ALTER TABLE PROTECTED_BRANCH ADD CONSTRAINT IDX_PROTECTED_BRANCH_PK PRIMARY KEY (USER_NAME, REPOSITORY_NAME, BRANCH);
+ALTER TABLE PROTECTED_BRANCH ADD CONSTRAINT IDX_PROTECTED_BRANCH_FK0 FOREIGN KEY (USER_NAME, REPOSITORY_NAME) REFERENCES REPOSITORY (USER_NAME, REPOSITORY_NAME)
+  ON DELETE CASCADE ON UPDATE CASCADE;
+
+
+DROP TABLE IF EXISTS PROTECTED_BRANCH_REQUIRE_CONTEXT;
+CREATE TABLE PROTECTED_BRANCH_REQUIRE_CONTEXT(
+    USER_NAME VARCHAR(100) NOT NULL,
+    REPOSITORY_NAME VARCHAR(100) NOT NULL,
+    BRANCH VARCHAR(100) NOT NULL,
+    CONTEXT VARCHAR(255) NOT NULL
+);
+
+ALTER TABLE PROTECTED_BRANCH_REQUIRE_CONTEXT ADD CONSTRAINT IDX_PROTECTED_BRANCH_REQUIRE_CONTEXT_PK PRIMARY KEY (USER_NAME, REPOSITORY_NAME, BRANCH, CONTEXT);
+ALTER TABLE PROTECTED_BRANCH_REQUIRE_CONTEXT ADD CONSTRAINT IDX_PROTECTED_BRANCH_REQUIRE_CONTEXT_FK0 FOREIGN KEY (USER_NAME, REPOSITORY_NAME, BRANCH) REFERENCES PROTECTED_BRANCH (USER_NAME, REPOSITORY_NAME, BRANCH)
+  ON DELETE CASCADE ON UPDATE CASCADE;

src/main/resources/update/3_13.sql

@@ -0,0 +1 @@
+ALTER TABLE WEB_HOOK ADD COLUMN TOKEN VARCHAR(100);

src/main/resources/update/3_9.sql

@@ -0,0 +1,55 @@
+DROP TABLE IF EXISTS WEB_HOOK_EVENT;
+
+CREATE TABLE WEB_HOOK_EVENT(
+    USER_NAME VARCHAR(100) NOT NULL,
+    REPOSITORY_NAME VARCHAR(100) NOT NULL,
+    URL VARCHAR(200) NOT NULL,
+    EVENT VARCHAR(30) NOT NULL
+);
+
+ALTER TABLE WEB_HOOK_EVENT ADD CONSTRAINT IDX_WEB_HOOK_EVENT_PK PRIMARY KEY (USER_NAME, REPOSITORY_NAME, URL, EVENT);
+ALTER TABLE WEB_HOOK_EVENT ADD CONSTRAINT IDX_WEB_HOOK_EVENT_FK0 FOREIGN KEY (USER_NAME, REPOSITORY_NAME, URL) REFERENCES WEB_HOOK (USER_NAME, REPOSITORY_NAME, URL)
+  ON DELETE CASCADE ON UPDATE CASCADE;
+
+CREATE TEMPORARY TABLE TMP_EVENTS (EVENT VARCHAR(30));
+
+INSERT INTO TMP_EVENTS VALUES ('push'),('issue_comment'),('issues'),('pull_request');
+
+INSERT INTO WEB_HOOK_EVENT (USER_NAME, REPOSITORY_NAME, URL, EVENT)
+  SELECT USER_NAME, REPOSITORY_NAME, URL, EVENT
+    FROM WEB_HOOK, TMP_EVENTS;
+
+DROP TABLE TMP_EVENTS;
+
+ALTER TABLE COMMIT_COMMENT ADD COLUMN ISSUE_ID INT;
+
+CREATE OR REPLACE VIEW ISSUE_OUTLINE_VIEW AS
+ SELECT
+   A.USER_NAME,
+   A.REPOSITORY_NAME,
+   A.ISSUE_ID,
+   NVL(B.COMMENT_COUNT, 0) + NVL(C.COMMENT_COUNT, 0) AS COMMENT_COUNT
+ FROM ISSUE A
+ LEFT OUTER JOIN (
+   SELECT USER_NAME, REPOSITORY_NAME, ISSUE_ID, COUNT(COMMENT_ID) AS COMMENT_COUNT FROM ISSUE_COMMENT
+   WHERE ACTION IN ('comment', 'close_comment', 'reopen_comment')
+   GROUP BY USER_NAME, REPOSITORY_NAME, ISSUE_ID
+ ) B
+ ON (A.USER_NAME = B.USER_NAME AND A.REPOSITORY_NAME = B.REPOSITORY_NAME AND A.ISSUE_ID = B.ISSUE_ID)
+ LEFT OUTER JOIN (
+   SELECT USER_NAME, REPOSITORY_NAME, ISSUE_ID, COUNT(COMMENT_ID) AS COMMENT_COUNT FROM COMMIT_COMMENT
+   GROUP BY USER_NAME, REPOSITORY_NAME, ISSUE_ID
+ ) C
+ ON (A.USER_NAME = C.USER_NAME AND A.REPOSITORY_NAME = C.REPOSITORY_NAME AND A.ISSUE_ID = C.ISSUE_ID);
+
+
+UPDATE COMMIT_COMMENT C SET (ISSUE_ID) = (
+  SELECT MAX(P.ISSUE_ID)
+  FROM PULL_REQUEST P
+  WHERE
+    C.USER_NAME       = P.USER_NAME AND
+    C.REPOSITORY_NAME = P.REPOSITORY_NAME AND
+    C.COMMIT_ID       = P.COMMIT_ID_TO
+);
+
+ALTER TABLE COMMIT_COMMENT DROP COLUMN PULL_REQUEST;

src/main/resources/update/gitbucket-core_4.0.sql

@@ -1,18 +0,0 @@
-CREATE OR REPLACE VIEW ISSUE_OUTLINE_VIEW AS
- SELECT
-   A.USER_NAME,
-   A.REPOSITORY_NAME,
-   A.ISSUE_ID,
-   COALESCE(B.COMMENT_COUNT, 0) + COALESCE(C.COMMENT_COUNT, 0) AS COMMENT_COUNT
- FROM ISSUE A
- LEFT OUTER JOIN (
-   SELECT USER_NAME, REPOSITORY_NAME, ISSUE_ID, COUNT(COMMENT_ID) AS COMMENT_COUNT FROM ISSUE_COMMENT
-   WHERE ACTION IN ('comment', 'close_comment', 'reopen_comment')
-   GROUP BY USER_NAME, REPOSITORY_NAME, ISSUE_ID
- ) B
- ON (A.USER_NAME = B.USER_NAME AND A.REPOSITORY_NAME = B.REPOSITORY_NAME AND A.ISSUE_ID = B.ISSUE_ID)
- LEFT OUTER JOIN (
-   SELECT USER_NAME, REPOSITORY_NAME, ISSUE_ID, COUNT(COMMENT_ID) AS COMMENT_COUNT FROM COMMIT_COMMENT
-   GROUP BY USER_NAME, REPOSITORY_NAME, ISSUE_ID
- ) C
- ON (A.USER_NAME = C.USER_NAME AND A.REPOSITORY_NAME = C.REPOSITORY_NAME AND A.ISSUE_ID = C.ISSUE_ID);

src/main/resources/update/gitbucket-core_4.0.xml

@@ -1,351 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<changeSet>
-
-  <!--================================================================================================-->
-  <!-- ACCOUNT -->
-  <!--================================================================================================-->
-  <createTable tableName="ACCOUNT">
-    <column name="USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="MAIL_ADDRESS" type="varchar(100)" nullable="false"/>
-    <column name="PASSWORD" type="varchar(40)" nullable="false"/>
-    <column name="ADMINISTRATOR" type="boolean" nullable="false"/>
-    <column name="URL" type="varchar(200)" nullable="true"/>
-    <column name="REGISTERED_DATE" type="datetime" nullable="false"/>
-    <column name="UPDATED_DATE" type="datetime" nullable="false"/>
-    <column name="LAST_LOGIN_DATE" type="datetime" nullable="true"/>
-    <column name="IMAGE" type="varchar(100)" nullable="true"/>
-    <column name="GROUP_ACCOUNT" type="boolean" nullable="false"/>
-    <column name="FULL_NAME" type="varchar(100)" nullable="false"/>
-    <column name="REMOVED" type="boolean" nullable="true"/>
-  </createTable>
-
-  <addPrimaryKey constraintName="IDX_ACCOUNT_PK" tableName="ACCOUNT" columnNames="USER_NAME"/>
-  <addUniqueConstraint constraintName="IDX_ACCOUNT_1" tableName="ACCOUNT" columnNames="MAIL_ADDRESS"/>
-
-  <insert tableName="ACCOUNT">
-    <column name="USER_NAME" value="root"/>
-    <column name="FULL_NAME" value="root"/>
-    <column name="MAIL_ADDRESS" value="root@localhost"/>
-    <column name="PASSWORD" value="dc76e9f0c0006e8f919e0c515c66dbba3982f785"/>
-    <column name="ADMINISTRATOR" valueBoolean="true"/>
-    <column name="URL" value="https://github.com/gitbucket/gitbucket"/>
-    <column name="GROUP_ACCOUNT" valueBoolean="false"/>
-    <column name="REMOVED" valueBoolean="false"/>
-    <column name="REGISTERED_DATE" valueDate="${currentDateTime}"/>
-    <column name="UPDATED_DATE" valueDate="${currentDateTime}"/>
-  </insert>
-
-  <!--================================================================================================-->
-  <!-- REPOSITORY -->
-  <!--================================================================================================-->
-  <createTable tableName="REPOSITORY">
-    <column name="USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="REPOSITORY_NAME" type="varchar(100)" nullable="false"/>
-    <column name="PRIVATE" type="boolean" nullable="false"/>
-    <column name="DESCRIPTION" type="text" nullable="true"/>
-    <column name="DEFAULT_BRANCH" type="varchar(100)" nullable="true"/>
-    <column name="REGISTERED_DATE" type="datetime" nullable="false"/>
-    <column name="UPDATED_DATE" type="datetime" nullable="false"/>
-    <column name="LAST_ACTIVITY_DATE" type="datetime" nullable="false"/>
-    <column name="ORIGIN_USER_NAME" type="varchar(100)" nullable="true"/>
-    <column name="ORIGIN_REPOSITORY_NAME" type="varchar(100)" nullable="true"/>
-    <column name="PARENT_USER_NAME" type="varchar(100)" nullable="true"/>
-    <column name="PARENT_REPOSITORY_NAME" type="varchar(100)" nullable="true"/>
-  </createTable>
-
-  <addPrimaryKey constraintName="IDX_REPOSITORY_PK" tableName="REPOSITORY" columnNames="USER_NAME, REPOSITORY_NAME"/>
-  <addForeignKeyConstraint constraintName="IDX_REPOSITORY_FK0" baseTableName="REPOSITORY" baseColumnNames="USER_NAME" referencedTableName="ACCOUNT" referencedColumnNames="USER_NAME"/>
-
-  <!--================================================================================================-->
-  <!-- ACCESS_TOKEN -->
-  <!--================================================================================================-->
-  <createTable tableName="ACCESS_TOKEN">
-    <column name="ACCESS_TOKEN_ID" type="int" nullable="false" autoIncrement="true" unique="true"/>
-    <column name="TOKEN_HASH" type="varchar(40)" nullable="false"/>
-    <column name="USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="NOTE" type="text" nullable="false"/>
-  </createTable>
-
-  <addPrimaryKey constraintName="IDX_ACCESS_TOKEN_PK" tableName="ACCESS_TOKEN" columnNames="ACCESS_TOKEN_ID"/>
-  <addUniqueConstraint constraintName="IDX_ACCESS_TOKEN_TOKEN_HASH" tableName="ACCESS_TOKEN" columnNames="TOKEN_HASH"/>
-  <addForeignKeyConstraint constraintName="IDX_ACCESS_TOKEN_FK0" baseTableName="ACCESS_TOKEN" baseColumnNames="USER_NAME" referencedTableName="ACCOUNT" referencedColumnNames="USER_NAME" onDelete="CASCADE" onUpdate="CASCADE"/>
-
-  <!--================================================================================================-->
-  <!-- ACTIVITY -->
-  <!--================================================================================================-->
-  <createTable tableName="ACTIVITY">
-    <column name="ACTIVITY_ID" type="int" nullable="false" autoIncrement="true" unique="true"/>
-    <column name="USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="REPOSITORY_NAME" type="varchar(100)" nullable="false"/>
-    <column name="ACTIVITY_USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="ACTIVITY_TYPE" type="varchar(100)" nullable="false"/>
-    <column name="MESSAGE" type="text" nullable="false"/>
-    <column name="ADDITIONAL_INFO" type="text" nullable="true"/>
-    <column name="ACTIVITY_DATE" type="datetime" nullable="false"/>
-  </createTable>
-
-  <addPrimaryKey constraintName="IDX_ACTIVITY_PK" tableName="ACTIVITY" columnNames="ACTIVITY_ID"/>
-  <addForeignKeyConstraint constraintName="IDX_ACTIVITY_FK1" baseTableName="ACTIVITY" baseColumnNames="ACTIVITY_USER_NAME" referencedTableName="ACCOUNT" referencedColumnNames="USER_NAME"/>
-  <addForeignKeyConstraint constraintName="IDX_ACTIVITY_FK0" baseTableName="ACTIVITY" baseColumnNames="USER_NAME, REPOSITORY_NAME" referencedTableName="REPOSITORY" referencedColumnNames="USER_NAME, REPOSITORY_NAME"/>
-
-  <!--================================================================================================-->
-  <!-- COLLABORATOR -->
-  <!--================================================================================================-->
-  <createTable tableName="COLLABORATOR">
-    <column name="USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="REPOSITORY_NAME" type="varchar(100)" nullable="false"/>
-    <column name="COLLABORATOR_NAME" type="varchar(100)" nullable="false"/>
-  </createTable>
-
-  <addPrimaryKey constraintName="IDX_COLLABORATOR_PK" tableName="COLLABORATOR" columnNames="USER_NAME, REPOSITORY_NAME, COLLABORATOR_NAME"/>
-  <addForeignKeyConstraint constraintName="IDX_COLLABORATOR_FK1" baseTableName="COLLABORATOR" baseColumnNames="COLLABORATOR_NAME" referencedTableName="ACCOUNT" referencedColumnNames="USER_NAME"/>
-  <addForeignKeyConstraint constraintName="IDX_COLLABORATOR_FK0" baseTableName="COLLABORATOR" baseColumnNames="USER_NAME, REPOSITORY_NAME" referencedTableName="REPOSITORY" referencedColumnNames="USER_NAME, REPOSITORY_NAME"/>
-
-  <!--================================================================================================-->
-  <!-- COMMIT_COMMENT -->
-  <!--================================================================================================-->
-  <createTable tableName="COMMIT_COMMENT">
-    <column name="USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="REPOSITORY_NAME" type="varchar(100)" nullable="false"/>
-    <column name="COMMIT_ID" type="varchar(100)" nullable="false"/>
-    <column name="COMMENT_ID" type="int" nullable="false" autoIncrement="true" unique="true"/>
-    <column name="COMMENTED_USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="CONTENT" type="text" nullable="false"/>
-    <column name="FILE_NAME" type="varchar(260)" nullable="true"/>
-    <column name="OLD_LINE_NUMBER" type="int" nullable="true"/>
-    <column name="NEW_LINE_NUMBER" type="int" nullable="true"/>
-    <column name="REGISTERED_DATE" type="datetime" nullable="false"/>
-    <column name="UPDATED_DATE" type="datetime" nullable="false"/>
-    <column name="ISSUE_ID" type="int" nullable="true"/>
-  </createTable>
-
-  <addPrimaryKey constraintName="IDX_COMMIT_COMMENT_PK" tableName="COMMIT_COMMENT" columnNames="COMMENT_ID"/>
-  <addForeignKeyConstraint constraintName="IDX_COMMIT_COMMENT_FK0" baseTableName="COMMIT_COMMENT" baseColumnNames="USER_NAME, REPOSITORY_NAME" referencedTableName="REPOSITORY" referencedColumnNames="USER_NAME, REPOSITORY_NAME"/>
-
-  <!--================================================================================================-->
-  <!-- COMMIT_STATUS -->
-  <!--================================================================================================-->
-  <createTable tableName="COMMIT_STATUS">
-    <column name="COMMIT_STATUS_ID" type="int" nullable="false" autoIncrement="true" unique="true"/>
-    <column name="USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="REPOSITORY_NAME" type="varchar(100)" nullable="false"/>
-    <column name="COMMIT_ID" type="varchar(40)" nullable="false"/>
-    <column name="CONTEXT" type="varchar(255)" nullable="false"/>
-    <column name="STATE" type="varchar(10)" nullable="false"/>
-    <column name="TARGET_URL" type="varchar(200)" nullable="true"/>
-    <column name="DESCRIPTION" type="text" nullable="true"/>
-    <column name="CREATOR" type="varchar(100)" nullable="false"/>
-    <column name="REGISTERED_DATE" type="datetime" nullable="false"/>
-    <column name="UPDATED_DATE" type="datetime" nullable="false"/>
-  </createTable>
-
-  <addPrimaryKey constraintName="IDX_COMMIT_STATUS_PK" tableName="COMMIT_STATUS" columnNames="COMMIT_STATUS_ID"/>
-  <addUniqueConstraint constraintName="IDX_COMMIT_STATUS_1" tableName="COMMIT_STATUS" columnNames="USER_NAME, REPOSITORY_NAME, COMMIT_ID, CONTEXT"/>
-  <addForeignKeyConstraint constraintName="IDX_COMMIT_STATUS_FK3" baseTableName="COMMIT_STATUS" baseColumnNames="CREATOR" referencedTableName="ACCOUNT" referencedColumnNames="USER_NAME" onDelete="CASCADE" onUpdate="CASCADE"/>
-  <addForeignKeyConstraint constraintName="IDX_COMMIT_STATUS_FK2" baseTableName="COMMIT_STATUS" baseColumnNames="USER_NAME" referencedTableName="ACCOUNT" referencedColumnNames="USER_NAME" onDelete="CASCADE" onUpdate="CASCADE"/>
-  <addForeignKeyConstraint constraintName="IDX_COMMIT_STATUS_FK1" baseTableName="COMMIT_STATUS" baseColumnNames="USER_NAME, REPOSITORY_NAME" referencedTableName="REPOSITORY" referencedColumnNames="USER_NAME, REPOSITORY_NAME" onDelete="CASCADE" onUpdate="CASCADE"/>
-
-  <!--================================================================================================-->
-  <!-- GROUP_MEMBER -->
-  <!--================================================================================================-->
-  <createTable tableName="GROUP_MEMBER">
-    <column name="GROUP_NAME" type="varchar(100)" nullable="false"/>
-    <column name="USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="MANAGER" type="boolean" nullable="true"/>
-  </createTable>
-
-  <addPrimaryKey constraintName="IDX_GROUP_MEMBER_PK" tableName="GROUP_MEMBER" columnNames="GROUP_NAME, USER_NAME"/>
-  <addForeignKeyConstraint constraintName="IDX_GROUP_MEMBER_FK1" baseTableName="GROUP_MEMBER" baseColumnNames="USER_NAME" referencedTableName="ACCOUNT" referencedColumnNames="USER_NAME"/>
-  <addForeignKeyConstraint constraintName="IDX_GROUP_MEMBER_FK0" baseTableName="GROUP_MEMBER" baseColumnNames="GROUP_NAME" referencedTableName="ACCOUNT" referencedColumnNames="USER_NAME"/>
-
-  <!--================================================================================================-->
-  <!-- LABEL -->
-  <!--================================================================================================-->
-  <createTable tableName="LABEL">
-    <column name="USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="REPOSITORY_NAME" type="varchar(100)" nullable="false"/>
-    <column name="LABEL_ID" type="int" nullable="false" autoIncrement="true" unique="true"/>
-    <column name="LABEL_NAME" type="varchar(100)" nullable="false"/>
-    <column name="COLOR" type="char(6)" nullable="false"/>
-  </createTable>
-
-  <addPrimaryKey constraintName="IDX_LABEL_PK" tableName="LABEL" columnNames="USER_NAME, REPOSITORY_NAME, LABEL_ID"/>
-  <addForeignKeyConstraint constraintName="IDX_LABEL_FK0" baseTableName="LABEL" baseColumnNames="USER_NAME, REPOSITORY_NAME" referencedTableName="REPOSITORY" referencedColumnNames="USER_NAME, REPOSITORY_NAME"/>
-
-  <!--================================================================================================-->
-  <!-- MILESTONE -->
-  <!--================================================================================================-->
-  <createTable tableName="MILESTONE">
-    <column name="USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="REPOSITORY_NAME" type="varchar(100)" nullable="false"/>
-    <column name="MILESTONE_ID" type="int" nullable="false" autoIncrement="true" unique="true"/>
-    <column name="TITLE" type="varchar(100)" nullable="false"/>
-    <column name="DESCRIPTION" type="text" nullable="true"/>
-    <column name="DUE_DATE" type="datetime" nullable="true"/>
-    <column name="CLOSED_DATE" type="datetime" nullable="true"/>
-  </createTable>
-
-  <addPrimaryKey constraintName="IDX_MILESTONE_PK" tableName="MILESTONE" columnNames="USER_NAME, REPOSITORY_NAME, MILESTONE_ID"/>
-  <addForeignKeyConstraint constraintName="IDX_MILESTONE_FK0" baseTableName="MILESTONE" baseColumnNames="USER_NAME, REPOSITORY_NAME" referencedTableName="REPOSITORY" referencedColumnNames="USER_NAME, REPOSITORY_NAME"/>
-
-  <!--================================================================================================-->
-  <!-- ISSUE -->
-  <!--================================================================================================-->
-  <createTable tableName="ISSUE">
-    <column name="USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="REPOSITORY_NAME" type="varchar(100)" nullable="false"/>
-    <column name="ISSUE_ID" type="int" nullable="false"/>
-    <column name="OPENED_USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="MILESTONE_ID" type="int" nullable="true"/>
-    <column name="ASSIGNED_USER_NAME" type="varchar(100)" nullable="true"/>
-    <column name="TITLE" type="text" nullable="false"/>
-    <column name="CONTENT" type="text" nullable="true"/>
-    <column name="CLOSED" type="boolean" nullable="false"/>
-    <column name="REGISTERED_DATE" type="datetime" nullable="false"/>
-    <column name="UPDATED_DATE" type="datetime" nullable="false"/>
-    <column name="PULL_REQUEST" type="boolean" nullable="false"/>
-  </createTable>
-
-  <addPrimaryKey constraintName="IDX_ISSUE_PK" tableName="ISSUE" columnNames="ISSUE_ID, USER_NAME, REPOSITORY_NAME"/>
-  <addForeignKeyConstraint constraintName="IDX_ISSUE_FK0" baseTableName="ISSUE" baseColumnNames="USER_NAME, REPOSITORY_NAME" referencedTableName="REPOSITORY" referencedColumnNames="USER_NAME, REPOSITORY_NAME"/>
-  <addForeignKeyConstraint constraintName="IDX_ISSUE_FK2" baseTableName="ISSUE" baseColumnNames="MILESTONE_ID" referencedTableName="MILESTONE" referencedColumnNames="MILESTONE_ID"/>
-  <addForeignKeyConstraint constraintName="IDX_ISSUE_FK1" baseTableName="ISSUE" baseColumnNames="OPENED_USER_NAME" referencedTableName="ACCOUNT" referencedColumnNames="USER_NAME"/>
-
-  <!--================================================================================================-->
-  <!-- ISSUE_COMMENT -->
-  <!--================================================================================================-->
-  <createTable tableName="ISSUE_COMMENT">
-    <column name="USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="REPOSITORY_NAME" type="varchar(100)" nullable="false"/>
-    <column name="ISSUE_ID" type="int" nullable="false"/>
-    <column name="COMMENT_ID" type="int" nullable="false" autoIncrement="true" unique="true"/>
-    <column name="ACTION" type="varchar(20)" nullable="false"/>
-    <column name="COMMENTED_USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="CONTENT" type="text" nullable="false"/>
-    <column name="REGISTERED_DATE" type="datetime" nullable="false"/>
-    <column name="UPDATED_DATE" type="datetime" nullable="false"/>
-  </createTable>
-
-  <addPrimaryKey constraintName="IDX_ISSUE_COMMENT_PK" tableName="ISSUE_COMMENT" columnNames="COMMENT_ID"/>
-  <addForeignKeyConstraint constraintName="IDX_ISSUE_COMMENT_FK0" baseTableName="ISSUE_COMMENT" baseColumnNames="USER_NAME, REPOSITORY_NAME, ISSUE_ID" referencedTableName="ISSUE" referencedColumnNames="USER_NAME, REPOSITORY_NAME, ISSUE_ID"/>
-
-  <!--================================================================================================-->
-  <!-- ISSUE_ID -->
-  <!--================================================================================================-->
-  <createTable tableName="ISSUE_ID">
-    <column name="USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="REPOSITORY_NAME" type="varchar(100)" nullable="false"/>
-    <column name="ISSUE_ID" type="int" nullable="false"/>
-  </createTable>
-
-  <addPrimaryKey constraintName="IDX_ISSUE_ID_PK" tableName="ISSUE_ID" columnNames="USER_NAME, REPOSITORY_NAME"/>
-  <addForeignKeyConstraint constraintName="IDX_ISSUE_ID_FK1" baseTableName="ISSUE_ID" baseColumnNames="USER_NAME, REPOSITORY_NAME" referencedTableName="REPOSITORY" referencedColumnNames="USER_NAME, REPOSITORY_NAME"/>
-
-  <!--================================================================================================-->
-  <!-- ISSUE_ID -->
-  <!--================================================================================================-->
-  <createTable tableName="ISSUE_LABEL">
-    <column name="USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="REPOSITORY_NAME" type="varchar(100)" nullable="false"/>
-    <column name="ISSUE_ID" type="int" nullable="false"/>
-    <column name="LABEL_ID" type="int" nullable="false"/>
-  </createTable>
-
-  <addPrimaryKey constraintName="IDX_ISSUE_LABEL_PK" tableName="ISSUE_LABEL" columnNames="USER_NAME, REPOSITORY_NAME, ISSUE_ID, LABEL_ID"/>
-  <addForeignKeyConstraint constraintName="IDX_ISSUE_LABEL_FK0" baseTableName="ISSUE_LABEL" baseColumnNames="USER_NAME, REPOSITORY_NAME, ISSUE_ID" referencedTableName="ISSUE" referencedColumnNames="USER_NAME, REPOSITORY_NAME, ISSUE_ID"/>
-
-  <!--================================================================================================-->
-  <!-- PLUGIN -->
-  <!--================================================================================================-->
-  <createTable tableName="PLUGIN">
-    <column name="PLUGIN_ID" type="varchar(100)" nullable="false"/>
-    <column name="VERSION" type="varchar(100)" nullable="false"/>
-  </createTable>
-
-  <addPrimaryKey constraintName="IDX_PLUGIN_PK" tableName="PLUGIN" columnNames="PLUGIN_ID"/>
-
-  <!--================================================================================================-->
-  <!-- PULL_REQUEST -->
-  <!--================================================================================================-->
-  <createTable tableName="PULL_REQUEST">
-    <column name="USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="REPOSITORY_NAME" type="varchar(100)" nullable="false"/>
-    <column name="ISSUE_ID" type="int" nullable="false"/>
-    <column name="BRANCH" type="varchar(100)" nullable="false"/>
-    <column name="REQUEST_USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="REQUEST_REPOSITORY_NAME" type="varchar(100)" nullable="false"/>
-    <column name="REQUEST_BRANCH" type="varchar(100)" nullable="false"/>
-    <column name="COMMIT_ID_FROM" type="varchar(40)" nullable="false"/>
-    <column name="COMMIT_ID_TO" type="varchar(40)" nullable="false"/>
-  </createTable>
-
-  <addPrimaryKey constraintName="IDX_PULL_REQUEST_PK" tableName="PULL_REQUEST" columnNames="USER_NAME, REPOSITORY_NAME, ISSUE_ID"/>
-  <addForeignKeyConstraint constraintName="IDX_PULL_REQUEST_FK0" baseTableName="PULL_REQUEST" baseColumnNames="USER_NAME, REPOSITORY_NAME, ISSUE_ID" referencedTableName="ISSUE" referencedColumnNames="USER_NAME, REPOSITORY_NAME, ISSUE_ID"/>
-
-  <!--================================================================================================-->
-  <!-- SSH_KEY -->
-  <!--================================================================================================-->
-  <createTable tableName="SSH_KEY">
-    <column name="USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="SSH_KEY_ID" type="int" nullable="false" autoIncrement="true" unique="true"/>
-    <column name="TITLE" type="varchar(100)" nullable="false"/>
-    <column name="PUBLIC_KEY" type="text" nullable="false"/>
-  </createTable>
-
-  <addPrimaryKey constraintName="IDX_SSH_KEY_PK" tableName="SSH_KEY" columnNames="USER_NAME, SSH_KEY_ID"/>
-  <addForeignKeyConstraint constraintName="IDX_SSH_KEY_FK0" baseTableName="SSH_KEY" baseColumnNames="USER_NAME" referencedTableName="ACCOUNT" referencedColumnNames="USER_NAME"/>
-
-  <!--================================================================================================-->
-  <!-- WEB_HOOK -->
-  <!--================================================================================================-->
-  <createTable tableName="WEB_HOOK">
-    <column name="USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="REPOSITORY_NAME" type="varchar(100)" nullable="false"/>
-    <column name="URL" type="varchar(200)" nullable="false"/>
-    <column name="TOKEN" type="varchar(100)" nullable="true"/>
-    <column name="CTYPE" type="varchar(10)" nullable="true"/>
-  </createTable>
-
-  <addPrimaryKey constraintName="IDX_WEB_HOOK_PK" tableName="WEB_HOOK" columnNames="USER_NAME, REPOSITORY_NAME, URL"/>
-  <addForeignKeyConstraint constraintName="IDX_WEB_HOOK_FK0" baseTableName="WEB_HOOK" baseColumnNames="USER_NAME, REPOSITORY_NAME" referencedTableName="REPOSITORY" referencedColumnNames="USER_NAME, REPOSITORY_NAME"/>
-
-  <!--================================================================================================-->
-  <!-- WEB_HOOK_EVENT -->
-  <!--================================================================================================-->
-  <createTable tableName="WEB_HOOK_EVENT">
-    <column name="USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="REPOSITORY_NAME" type="varchar(100)" nullable="false"/>
-    <column name="URL" type="varchar(200)" nullable="false"/>
-    <column name="EVENT" type="varchar(30)" nullable="false"/>
-  </createTable>
-
-  <addPrimaryKey constraintName="IDX_WEB_HOOK_EVENT_PK" tableName="WEB_HOOK_EVENT" columnNames="USER_NAME, REPOSITORY_NAME, URL, EVENT"/>
-  <addForeignKeyConstraint constraintName="IDX_WEB_HOOK_EVENT_FK0" baseTableName="WEB_HOOK_EVENT" baseColumnNames="USER_NAME, REPOSITORY_NAME, URL" referencedTableName="WEB_HOOK" referencedColumnNames="USER_NAME, REPOSITORY_NAME, URL" onDelete="CASCADE" onUpdate="CASCADE"/>
-
-  <!--================================================================================================-->
-  <!-- PROTECTED_BRANCH -->
-  <!--================================================================================================-->
-  <createTable tableName="PROTECTED_BRANCH">
-    <column name="USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="REPOSITORY_NAME" type="varchar(100)" nullable="false"/>
-    <column name="BRANCH" type="varchar(100)" nullable="false"/>
-    <column name="STATUS_CHECK_ADMIN" type="boolean" nullable="false" defaultValueBoolean="false"/>
-  </createTable>
-
-  <addPrimaryKey constraintName="IDX_PROTECTED_BRANCH_PK" tableName="PROTECTED_BRANCH" columnNames="USER_NAME, REPOSITORY_NAME, BRANCH"/>
-  <addForeignKeyConstraint constraintName="IDX_PROTECTED_BRANCH_FK0" baseTableName="PROTECTED_BRANCH" baseColumnNames="USER_NAME, REPOSITORY_NAME" referencedTableName="REPOSITORY" referencedColumnNames="USER_NAME, REPOSITORY_NAME" onDelete="CASCADE" onUpdate="CASCADE"/>
-
-  <!--================================================================================================-->
-  <!-- PROTECTED_BRANCH_REQUIRE_CONTEXT -->
-  <!--================================================================================================-->
-  <createTable tableName="PROTECTED_BRANCH_REQUIRE_CONTEXT">
-    <column name="USER_NAME" type="varchar(100)" nullable="false"/>
-    <column name="REPOSITORY_NAME" type="varchar(100)" nullable="false"/>
-    <column name="BRANCH" type="varchar(100)" nullable="false"/>
-    <column name="CONTEXT" type="varchar(255)" nullable="false"/>
-  </createTable>
-
-  <addPrimaryKey constraintName="IDX_PROTECTED_BRANCH_REQUIRE_CONTEXT_PK" tableName="PROTECTED_BRANCH_REQUIRE_CONTEXT" columnNames="USER_NAME, REPOSITORY_NAME, BRANCH, CONTEXT"/>
-  <addForeignKeyConstraint constraintName="IDX_PROTECTED_BRANCH_REQUIRE_CONTEXT_FK0" baseTableName="PROTECTED_BRANCH_REQUIRE_CONTEXT" baseColumnNames="USER_NAME, REPOSITORY_NAME, BRANCH" referencedTableName="PROTECTED_BRANCH" referencedColumnNames="USER_NAME, REPOSITORY_NAME, BRANCH" onDelete="CASCADE" onUpdate="CASCADE"/>
-
-</changeSet>

src/main/scala/gitbucket/core/GitBucketCoreModule.scala

@@ -1,12 +0,0 @@
-package gitbucket.core
-
-import io.github.gitbucket.solidbase.migration.{SqlMigration, LiquibaseMigration}
-import io.github.gitbucket.solidbase.model.{Version, Module}
-
-object GitBucketCoreModule extends Module("gitbucket-core",
-  new Version("4.1.0"),
-  new Version("4.0.0",
-    new LiquibaseMigration("update/gitbucket-core_4.0.xml"),
-    new SqlMigration("update/gitbucket-core_4.0.sql")
-  )
-)

src/main/scala/gitbucket/core/api/ApiBranchProtection.scala

@@ -14,7 +14,7 @@ object ApiBranchProtection{
 
   def apply(info: ProtectedBranchService.ProtectedBranchInfo): ApiBranchProtection = ApiBranchProtection(
     enabled = info.enabled,
-    required_status_checks = Some(Status(EnforcementLevel(info.enabled && info.contexts.nonEmpty, info.includeAdministrators), info.contexts)))
+    required_status_checks = Some(Status(EnforcementLevel(info.enabled, info.includeAdministrators), info.contexts)))
   val statusNone = Status(Off, Seq.empty)
   case class Status(enforcement_level: EnforcementLevel, contexts: Seq[String])
   sealed class EnforcementLevel(val name: String)
@@ -44,3 +44,4 @@ object ApiBranchProtection{
    }
  ))
 }
+

src/main/scala/gitbucket/core/api/ApiIssue.scala

@@ -20,16 +20,6 @@ case class ApiIssue(
   body: String)(repositoryName: RepositoryName, isPullRequest: Boolean){
   val comments_url = ApiPath(s"/api/v3/repos/${repositoryName.fullName}/issues/${number}/comments")
   val html_url = ApiPath(s"/${repositoryName.fullName}/${if(isPullRequest){ "pull" }else{ "issues" }}/${number}")
-  val pull_request = if (isPullRequest) {
-    Some(Map(
-      "url" -> ApiPath(s"/api/v3/repos/${repositoryName.fullName}/pulls/${number}"),
-      "html_url" -> ApiPath(s"/${repositoryName.fullName}/pull/${number}")
-      // "diff_url" -> ApiPath(s"/${repositoryName.fullName}/pull/${number}.diff"),
-      // "patch_url" -> ApiPath(s"/${repositoryName.fullName}/pull/${number}.patch")
-    ))
-  } else {
-    None
-  }
 }
 
 object ApiIssue{

src/main/scala/gitbucket/core/api/ApiPullRequest.scala

@@ -31,8 +31,7 @@ case class ApiPullRequest(
 }
 
 object ApiPullRequest{
-  def apply(issue: Issue, pullRequest: PullRequest, headRepo: ApiRepository, baseRepo: ApiRepository, user: ApiUser): ApiPullRequest =
-    ApiPullRequest(
+  def apply(issue: Issue, pullRequest: PullRequest, headRepo: ApiRepository, baseRepo: ApiRepository, user: ApiUser): ApiPullRequest = ApiPullRequest(
       number     = issue.issueId,
       updated_at = issue.updatedDate,
       created_at = issue.registeredDate,

src/main/scala/gitbucket/core/api/ApiRepository.scala

@@ -14,11 +14,11 @@ case class ApiRepository(
   `private`: Boolean,
   default_branch: String,
   owner: ApiUser)(urlIsHtmlUrl: Boolean) {
-  val forks_count = forks
+  val forks_count   = forks
   val watchers_count = watchers
-  val url = if(urlIsHtmlUrl){
+  val url       = if(urlIsHtmlUrl){
     ApiPath(s"/${full_name}")
-  } else {
+  }else{
     ApiPath(s"/api/v3/repos/${full_name}")
   }
   val http_url  = ApiPath(s"/git/${full_name}.git")
@@ -34,14 +34,14 @@ object ApiRepository{
       watchers: Int = 0,
       urlIsHtmlUrl: Boolean = false): ApiRepository =
     ApiRepository(
-      name           = repository.repositoryName,
-      full_name      = s"${repository.userName}/${repository.repositoryName}",
-      description    = repository.description.getOrElse(""),
-      watchers       = 0,
-      forks          = forkedCount,
-      `private`      = repository.isPrivate,
+      name        = repository.repositoryName,
+      full_name   = s"${repository.userName}/${repository.repositoryName}",
+      description = repository.description.getOrElse(""),
+      watchers    = 0,
+      forks       = forkedCount,
+      `private`   = repository.`private`,
       default_branch = repository.defaultBranch,
-      owner          = owner
+      owner       = owner
     )(urlIsHtmlUrl)
 
   def apply(repositoryInfo: RepositoryInfo, owner: ApiUser): ApiRepository =

src/main/scala/gitbucket/core/api/ApiUser.scala

@@ -29,8 +29,8 @@ object ApiUser{
   def apply(user: Account): ApiUser = ApiUser(
     login      = user.userName,
     email      = user.mailAddress,
-    `type`     = if(user.isGroupAccount){ "Organization" }else{ "User" },
-    site_admin = user.isAdmin,
+    `type`     = if(user.groupAccount){ "Organization" }else{ "User" },
+    site_admin = user.administrator,
     created_at = user.registeredDate
   )
 }

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

@@ -114,23 +114,23 @@ trait AccountControllerBase extends AccountManagementControllerBase {
         // Public Activity
         case "activity" =>
           gitbucket.core.account.html.activity(account,
-            if(account.isGroupAccount) Nil else getGroupsByUserName(userName),
+            if(account.groupAccount) Nil else getGroupsByUserName(userName),
             getActivitiesByUser(userName, true))
 
         // Members
-        case "members" if(account.isGroupAccount) => {
+        case "members" if(account.groupAccount) => {
           val members = getGroupMembers(account.userName)
           gitbucket.core.account.html.members(account, members.map(_.userName),
-            context.loginAccount.exists(x => members.exists { member => member.userName == x.userName && member.isManager }))
+            context.loginAccount.exists(x => members.exists { member => member.userName == x.userName && member.manager }))
         }
 
         // Repositories
         case _ => {
           val members = getGroupMembers(account.userName)
           gitbucket.core.account.html.repositories(account,
-            if(account.isGroupAccount) Nil else getGroupsByUserName(userName),
+            if(account.groupAccount) Nil else getGroupsByUserName(userName),
             getVisibleRepositories(context.loginAccount, Some(userName)),
-            context.loginAccount.exists(x => members.exists { member => member.userName == x.userName && member.isManager }))
+            context.loginAccount.exists(x => members.exists { member => member.userName == x.userName && member.manager }))
         }
       }
     } getOrElse NotFound
@@ -155,7 +155,7 @@ trait AccountControllerBase extends AccountManagementControllerBase {
   get("/:userName/_edit")(oneselfOnly {
     val userName = params("userName")
     getAccountByUserName(userName).map { x =>
-      html.edit(x, flash.get("info"), flash.get("error"))
+      html.edit(x, flash.get("info"))
     } getOrElse NotFound
   })
 
@@ -178,11 +178,7 @@ trait AccountControllerBase extends AccountManagementControllerBase {
   get("/:userName/_delete")(oneselfOnly {
     val userName = params("userName")
 
-    getAccountByUserName(userName, true).map { account =>
-      if(isLastAdministrator(account)){
-        flash += "error" -> "Account can't be removed because this is last one administrator."
-        redirect(s"/${userName}/_edit")
-      } else {
+    getAccountByUserName(userName, true).foreach { account =>
 //      // Remove repositories
 //      getRepositoryNamesOfUser(userName).foreach { repositoryName =>
 //        deleteRepository(userName, repositoryName)
@@ -191,12 +187,14 @@ trait AccountControllerBase extends AccountManagementControllerBase {
 //        FileUtils.deleteDirectory(getTemporaryDir(userName, repositoryName))
 //      }
 //      // Remove from GROUP_MEMBER, COLLABORATOR and REPOSITORY
-        removeUserRelatedData(userName)
-        updateAccount(account.copy(isRemoved = true))
-        session.invalidate
-        redirect("/")
-      }
-    } getOrElse NotFound
+//      removeUserRelatedData(userName)
+
+      removeUserRelatedData(userName)
+      updateAccount(account.copy(removed = true))
+    }
+
+    session.invalidate
+    redirect("/")
   })
 
   get("/:userName/_ssh")(oneselfOnly {
@@ -362,7 +360,7 @@ trait AccountControllerBase extends AccountManagementControllerBase {
       case _: List[String] =>
         val managerPermissions = groups.map { group =>
           val members = getGroupMembers(group)
-          context.loginAccount.exists(x => members.exists { member => member.userName == x.userName && member.isManager })
+          context.loginAccount.exists(x => members.exists { member => member.userName == x.userName && member.manager })
         }
         helper.html.forkrepository(
           repository,
@@ -391,7 +389,7 @@ trait AccountControllerBase extends AccountManagementControllerBase {
           repositoryName       = repository.name,
           userName             = accountName,
           description          = repository.repository.description,
-          isPrivate            = repository.repository.isPrivate,
+          isPrivate            = repository.repository.`private`,
           originRepositoryName = Some(originRepositoryName),
           originUserName       = Some(originUserName),
           parentRepositoryName = Some(repository.name),
@@ -400,7 +398,7 @@ trait AccountControllerBase extends AccountManagementControllerBase {
 
         // Add collaborators for group repository
         val ownerAccount = getAccountByUserName(accountName).get
-        if(ownerAccount.isGroupAccount){
+        if(ownerAccount.groupAccount){
           getGroupMembers(accountName).foreach { member =>
             addCollaborator(accountName, repository.name, member.userName)
           }
@@ -449,8 +447,8 @@ trait AccountControllerBase extends AccountManagementControllerBase {
 
   private def validPublicKey: Constraint = new Constraint(){
     override def validate(name: String, value: String, messages: Messages): Option[String] = SshUtil.str2PublicKey(value) match {
-     case Some(_) if !getAllKeys().exists(_.publicKey == value) => None
-     case _ => Some("Key is invalid.")
+     case Some(_) => None
+     case None => Some("Key is invalid.")
     }
   }
 

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

@@ -119,9 +119,7 @@ trait ApiControllerBase extends ControllerBase {
     }) getOrElse NotFound
   })
 
-  /**
-   * https://developer.github.com/v3/repos/#enabling-and-disabling-branch-protection
-   */
+  /** https://developer.github.com/v3/repos/#enabling-and-disabling-branch-protection */
   patch("/api/v3/repos/:owner/:repo/branches/:branch")(ownerOnly { repository =>
     import gitbucket.core.api._
     (for{
@@ -263,28 +261,18 @@ trait ApiControllerBase extends ControllerBase {
    * https://developer.github.com/v3/pulls/#list-pull-requests
    */
   get("/api/v3/repos/:owner/:repository/pulls")(referrersOnly { repository =>
-    val page = IssueSearchCondition.page(request)
+    val page       = IssueSearchCondition.page(request)
     // TODO: more api spec condition
     val condition = IssueSearchCondition(request)
     val baseOwner = getAccountByUserName(repository.owner).get
-
-    val issues: List[(Issue, Account, Int, PullRequest, Repository, Account)] =
-      searchPullRequestByApi(
-        condition = condition,
-        offset    = (page - 1) * PullRequestLimit,
-        limit     = PullRequestLimit,
-        repos     = repository.owner -> repository.name
-      )
-
-    JsonFormat(issues.map { case (issue, issueUser, commentCount, pullRequest, headRepo, headOwner) =>
+    val issues:List[(Issue, Account, Int, PullRequest, Repository, Account)] = searchPullRequestByApi(condition, (page - 1) * PullRequestLimit, PullRequestLimit, repository.owner -> repository.name)
+    JsonFormat(issues.map{case (issue, issueUser, commentCount, pullRequest, headRepo, headOwner) =>
       ApiPullRequest(
         issue,
         pullRequest,
         ApiRepository(headRepo, ApiUser(headOwner)),
         ApiRepository(repository, ApiUser(baseOwner)),
-        ApiUser(issueUser)
-      )
-    })
+        ApiUser(issueUser)) })
   })
 
   /**

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

@@ -50,7 +50,7 @@ abstract class ControllerBase extends ScalatraFilter
       if(account == null){
         // Redirect to login form
         httpResponse.sendRedirect(baseUrl + "/signin?redirect=" + StringUtil.urlEncode(path))
-      } else if(account.isAdmin){
+      } else if(account.administrator){
         // H2 Console (administrators only)
         chain.doFilter(request, response)
       } else {

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

@@ -83,9 +83,9 @@ trait DashboardControllerBase extends ControllerBase {
     } else session.getAs[IssueSearchCondition](key).getOrElse(IssueSearchCondition()))
 
     filter match {
-      case "assigned"  => condition.copy(assigned = Some(Some(userName)), author = None, mentioned = None)
-      case "mentioned" => condition.copy(assigned = None, author = None, mentioned = Some(userName))
-      case _           => condition.copy(assigned = None, author = Some(userName), mentioned = None)
+      case "assigned"  => condition.copy(assigned = Some(userName), author = None          , mentioned = None)
+      case "mentioned" => condition.copy(assigned = None          , author = None          , mentioned = Some(userName))
+      case _           => condition.copy(assigned = None          , author = Some(userName), mentioned = None)
     }
   }
 
@@ -103,14 +103,12 @@ trait DashboardControllerBase extends ControllerBase {
       countIssue(condition.copy(state = "open"  ), false, userRepos: _*),
       countIssue(condition.copy(state = "closed"), false, userRepos: _*),
       filter match {
-        case "assigned"  => condition.copy(assigned  = Some(Some(userName)))
+        case "assigned"  => condition.copy(assigned  = Some(userName))
         case "mentioned" => condition.copy(mentioned = Some(userName))
         case _           => condition.copy(author    = Some(userName))
       },
       filter,
-      getGroupNames(userName),
-      getVisibleRepositories(context.loginAccount, withoutPhysicalInfo = true),
-      getUserRepositories(userName, withoutPhysicalInfo = true))
+      getGroupNames(userName))
   }
 
   private def searchPullRequests(filter: String) = {
@@ -128,14 +126,12 @@ trait DashboardControllerBase extends ControllerBase {
       countIssue(condition.copy(state = "open"  ), true, allRepos: _*),
       countIssue(condition.copy(state = "closed"), true, allRepos: _*),
       filter match {
-        case "assigned"  => condition.copy(assigned  = Some(Some(userName)))
+        case "assigned"  => condition.copy(assigned  = Some(userName))
         case "mentioned" => condition.copy(mentioned = Some(userName))
         case _           => condition.copy(author    = Some(userName))
       },
       filter,
-      getGroupNames(userName),
-      getVisibleRepositories(context.loginAccount, withoutPhysicalInfo = true),
-      getUserRepositories(userName, withoutPhysicalInfo = true))
+      getGroupNames(userName))
   }
 
 

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

@@ -1,26 +1,18 @@
 package gitbucket.core.controller
 
-import gitbucket.core.model.Account
-import gitbucket.core.service.{AccountService, RepositoryService}
-import gitbucket.core.servlet.Database
-import gitbucket.core.util._
+import gitbucket.core.util.{Keys, FileUtil}
 import gitbucket.core.util.ControlUtil._
 import gitbucket.core.util.Directory._
-import gitbucket.core.util.Implicits._
-import org.eclipse.jgit.api.Git
-import org.eclipse.jgit.dircache.DirCache
-import org.eclipse.jgit.lib.{FileMode, Constants}
-import org.scalatra
 import org.scalatra._
 import org.scalatra.servlet.{MultipartConfig, FileUploadSupport, FileItem}
-import org.apache.commons.io.{IOUtils, FileUtils}
+import org.apache.commons.io.FileUtils
 
 /**
  * Provides Ajax based file upload functionality.
  *
  * This servlet saves uploaded file.
  */
-class FileUploadController extends ScalatraServlet with FileUploadSupport with RepositoryService with AccountService {
+class FileUploadController extends ScalatraServlet with FileUploadSupport {
 
   configureMultipartHandling(MultipartConfig(maxFileSize = Some(3 * 1024 * 1024)))
 
@@ -39,69 +31,6 @@ class FileUploadController extends ScalatraServlet with FileUploadSupport with R
     }, FileUtil.isUploadableType)
   }
 
-  post("/wiki/:owner/:repository"){
-    // Don't accept not logged-in users
-    session.get(Keys.Session.LoginAccount).collect { case loginAccount: Account =>
-      val owner      = params("owner")
-      val repository = params("repository")
-
-      // Check whether logged-in user is collaborator
-      collaboratorsOnly(owner, repository, loginAccount){
-        execute({ (file, fileId) =>
-          val fileName   = file.getName
-          LockUtil.lock(s"${owner}/${repository}/wiki") {
-            using(Git.open(Directory.getWikiRepositoryDir(owner, repository))) { git =>
-              val builder  = DirCache.newInCore.builder()
-              val inserter = git.getRepository.newObjectInserter()
-              val headId   = git.getRepository.resolve(Constants.HEAD + "^{commit}")
-
-              if(headId != null){
-                JGitUtil.processTree(git, headId){ (path, tree) =>
-                  if(path != fileName){
-                    builder.add(JGitUtil.createDirCacheEntry(path, tree.getEntryFileMode, tree.getEntryObjectId))
-                  }
-                }
-              }
-
-              val bytes = IOUtils.toByteArray(file.getInputStream)
-              builder.add(JGitUtil.createDirCacheEntry(fileName, FileMode.REGULAR_FILE, inserter.insert(Constants.OBJ_BLOB, bytes)))
-              builder.finish()
-
-              val newHeadId = JGitUtil.createNewCommit(git, inserter, headId, builder.getDirCache.writeTree(inserter),
-                Constants.HEAD, loginAccount.userName, loginAccount.mailAddress, s"Uploaded ${fileName}")
-
-              fileName
-            }
-          }
-        }, FileUtil.isUploadableType)
-      }
-    } getOrElse BadRequest
-  }
-
-  post("/import") {
-    session.get(Keys.Session.LoginAccount).collect { case loginAccount: Account if loginAccount.isAdmin =>
-      execute({ (file, fileId) =>
-        if(file.getName.endsWith(".xml")){
-          import JDBCUtil._
-          val conn = request2Session(request).conn
-          conn.importAsXML(file.getInputStream)
-        } else {
-          throw new RuntimeException("Import is available for only the XML file.")
-        }
-      }, _ => true)
-    }
-    redirect("/admin/data")
-  }
-
-  private def collaboratorsOnly(owner: String, repository: String, loginAccount: Account)(action: => Any): Any = {
-    implicit val session = Database.getSession(request)
-    loginAccount match {
-      case x if(x.isAdmin) => action
-      case x if(getCollaborators(owner, repository).contains(x.userName)) => action
-      case _ => BadRequest
-    }
-  }
-
   private def execute(f: (FileItem, String) => Unit, mimeTypeChcker: (String) => Boolean) = fileParams.get("file") match {
     case Some(file) if(mimeTypeChcker(file.name)) =>
       defining(FileUtil.generateFileId){ fileId =>

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

@@ -1,8 +1,9 @@
 package gitbucket.core.controller
 
+import gitbucket.core.api._
 import gitbucket.core.helper.xml
 import gitbucket.core.model.Account
-import gitbucket.core.service._
+import gitbucket.core.service.{RepositoryService, ActivityService, AccountService, RepositorySearchService, IssuesService}
 import gitbucket.core.util.Implicits._
 import gitbucket.core.util.ControlUtil._
 import gitbucket.core.util.{LDAPUtil, Keys, UsersAuthenticator, ReferrerAuthenticator, StringUtil}
@@ -109,7 +110,7 @@ trait IndexControllerBase extends ControllerBase {
   get("/_user/proposals")(usersOnly {
     contentType = formats("json")
     org.json4s.jackson.Serialization.write(
-      Map("options" -> getAllUsers(false).filter(!_.isGroupAccount).map(_.userName).toArray)
+      Map("options" -> getAllUsers(false).filter(!_.groupAccount).map(_.userName).toArray)
     )
   })
 
@@ -117,9 +118,7 @@ trait IndexControllerBase extends ControllerBase {
    * JSON API for checking user existence.
    */
   post("/_user/existence")(usersOnly {
-    getAccountByUserName(params("userName")).map { account =>
-      if(params.get("userOnly").isDefined) !account.isGroupAccount else true
-    } getOrElse false
+    getAccountByUserName(params("userName")).isDefined
   })
 
   // TODO Move to RepositoryViwerController?
@@ -139,21 +138,13 @@ trait IndexControllerBase extends ControllerBase {
 
       target.toLowerCase match {
         case "issue" => gitbucket.core.search.html.issues(
-          countFiles(repository.owner, repository.name, query),
           searchIssues(repository.owner, repository.name, query),
-          countWikiPages(repository.owner, repository.name, query),
-          query, page, repository)
-
-        case "wiki" => gitbucket.core.search.html.wiki(
           countFiles(repository.owner, repository.name, query),
-          countIssues(repository.owner, repository.name, query),
-          searchWikiPages(repository.owner, repository.name, query),
           query, page, repository)
 
         case _ => gitbucket.core.search.html.code(
           searchFiles(repository.owner, repository.name, query),
           countIssues(repository.owner, repository.name, query),
-          countWikiPages(repository.owner, repository.name, query),
           query, page, repository)
       }
     }

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

@@ -67,7 +67,7 @@ trait IssuesControllerBase extends ControllerBase {
           _,
           getComments(owner, name, issueId.toInt),
           getIssueLabels(owner, name, issueId.toInt),
-          (getCollaborators(owner, name) ::: (if(getAccountByUserName(owner).get.isGroupAccount) Nil else List(owner))).sorted,
+          (getCollaborators(owner, name) ::: (if(getAccountByUserName(owner).get.groupAccount) Nil else List(owner))).sorted,
           getMilestonesWithIssueCount(owner, name),
           getLabels(owner, name),
           hasWritePermission(owner, name, context.loginAccount),
@@ -79,7 +79,7 @@ trait IssuesControllerBase extends ControllerBase {
   get("/:owner/:repository/issues/new")(readableUsersOnly { repository =>
     defining(repository.owner, repository.name){ case (owner, name) =>
       html.create(
-        (getCollaborators(owner, name) ::: (if(getAccountByUserName(owner).get.isGroupAccount) Nil else List(owner))).sorted,
+        (getCollaborators(owner, name) ::: (if(getAccountByUserName(owner).get.groupAccount) Nil else List(owner))).sorted,
           getMilestones(owner, name),
           getLabels(owner, name),
           hasWritePermission(owner, name, context.loginAccount),
@@ -380,7 +380,7 @@ trait IssuesControllerBase extends ControllerBase {
           "issues",
           searchIssue(condition, false, (page - 1) * IssueLimit, IssueLimit, owner -> repoName),
           page,
-          if(!getAccountByUserName(owner).exists(_.isGroupAccount)){
+          if(!getAccountByUserName(owner).exists(_.groupAccount)){
             (getCollaborators(owner, repoName) :+ owner).sorted
           } else {
             getCollaborators(owner, repoName)

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

@@ -23,7 +23,6 @@ trait LabelsControllerBase extends ControllerBase {
     "labelColor" -> trim(label("Color",      text(required, color)))
   )(LabelForm.apply)
 
-
   get("/:owner/:repository/issues/labels")(referrersOnly { repository =>
     html.list(
       getLabels(repository.owner, repository.name),
@@ -85,11 +84,7 @@ trait LabelsControllerBase extends ControllerBase {
     override def validate(name: String, value: String, params: Map[String, String], messages: Messages): Option[String] = {
       val owner = params("owner")
       val repository = params("repository")
-      params.get("labelId").map { labelId =>
-        getLabel(owner, repository, value).filter(_.labelId != labelId.toInt).map(_ => "Name has already been taken.")
-      }.getOrElse {
-        getLabel(owner, repository, value).map(_ => "Name has already been taken.")
-      }
+      getLabel(owner, repository, value).map(_ => "Name has already been taken.")
     }
   }
 

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

@@ -94,7 +94,7 @@ trait PullRequestsControllerBase extends ControllerBase {
             (commits.flatten.map(commit => getCommitComments(owner, name, commit.id, true)).flatten.toList ::: getComments(owner, name, issueId))
               .sortWith((a, b) => a.registeredDate before b.registeredDate),
             getIssueLabels(owner, name, issueId),
-            (getCollaborators(owner, name) ::: (if(getAccountByUserName(owner).get.isGroupAccount) Nil else List(owner))).sorted,
+            (getCollaborators(owner, name) ::: (if(getAccountByUserName(owner).get.groupAccount) Nil else List(owner))).sorted,
             getMilestonesWithIssueCount(owner, name),
             getLabels(owner, name),
             commits,
@@ -178,7 +178,7 @@ trait PullRequestsControllerBase extends ControllerBase {
           }
           val existIds = using(Git.open(Directory.getRepositoryDir(owner, name))) { git => JGitUtil.getAllCommitIds(git) }.toSet
           pullRemote(owner, name, pullreq.requestBranch, pullreq.userName, pullreq.repositoryName, pullreq.branch, loginAccount,
-                     s"Merge branch '${alias}' into ${pullreq.requestBranch}") match {
+                     "Merge branch '${alias}' into ${pullreq.requestBranch}") match {
             case None => // conflict
               flash += "error" -> s"Can't automatic merging branch '${alias}' into ${pullreq.requestBranch}."
             case Some(oldId) =>
@@ -202,7 +202,7 @@ trait PullRequestsControllerBase extends ControllerBase {
 
                 // close issue by commit message
                 if(pullreq.requestBranch == repository.repository.defaultBranch){
-                  commits.map { commit =>
+                  commits.map{ commit =>
                     closeIssuesFromMessage(commit.fullMessage, loginAccount.userName, owner, name)
                   }
                 }
@@ -255,7 +255,10 @@ trait PullRequestsControllerBase extends ControllerBase {
               commits.flatten.foreach { commit =>
                 closeIssuesFromMessage(commit.fullMessage, loginAccount.userName, owner, name)
               }
-              closeIssuesFromMessage(issue.title + " " + issue.content.getOrElse(""), loginAccount.userName, owner, name)
+              issue.content match {
+                case Some(content) => closeIssuesFromMessage(content, loginAccount.userName, owner, name)
+                case _ =>
+              }
               closeIssuesFromMessage(form.message, loginAccount.userName, owner, name)
             }
 
@@ -351,15 +354,7 @@ trait PullRequestsControllerBase extends ControllerBase {
               originRepository.owner, originRepository.name, oldId.getName,
               forkedRepository.owner, forkedRepository.name, newId.getName)
 
-            val title = if(commits.flatten.length == 1){
-              commits.flatten.head.shortMessage
-            } else {
-              val text = forkedId.replaceAll("[\\-_]", " ")
-              text.substring(0, 1).toUpperCase + text.substring(1)
-            }
-
             html.compare(
-              title,
               commits,
               diffs,
               (forkedRepository.repository.originUserName, forkedRepository.repository.originRepositoryName) match {
@@ -375,7 +370,7 @@ trait PullRequestsControllerBase extends ControllerBase {
               originRepository,
               forkedRepository,
               hasWritePermission(originRepository.owner, originRepository.name, context.loginAccount),
-              (getCollaborators(originRepository.owner, originRepository.name) ::: (if(getAccountByUserName(originRepository.owner).get.isGroupAccount) Nil else List(originRepository.owner))).sorted,
+              (getCollaborators(originRepository.owner, originRepository.name) ::: (if(getAccountByUserName(originRepository.owner).get.groupAccount) Nil else List(originRepository.owner))).sorted,
               getMilestones(originRepository.owner, originRepository.name),
               getLabels(originRepository.owner, originRepository.name)
             )
@@ -529,7 +524,7 @@ trait PullRequestsControllerBase extends ControllerBase {
         "pulls",
         searchIssue(condition, true, (page - 1) * PullRequestLimit, PullRequestLimit, owner -> repoName),
         page,
-        if(!getAccountByUserName(owner).exists(_.isGroupAccount)){
+        if(!getAccountByUserName(owner).exists(_.groupAccount)){
           (getCollaborators(owner, repoName) :+ owner).sorted
         } else {
           getCollaborators(owner, repoName)

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

@@ -15,7 +15,6 @@ import org.scalatra.i18n.Messages
 import org.eclipse.jgit.api.Git
 import org.eclipse.jgit.lib.Constants
 import org.eclipse.jgit.lib.ObjectId
-import gitbucket.core.model.WebHookContentType
 
 
 class RepositorySettingsController extends RepositorySettingsControllerBase
@@ -50,16 +49,13 @@ trait RepositorySettingsControllerBase extends ControllerBase {
   )(CollaboratorForm.apply)
 
   // for web hook url addition
-  case class WebHookForm(url: String, events: Set[WebHook.Event], ctype: WebHookContentType, token: Option[String])
+  case class WebHookForm(url: String, events: Set[WebHook.Event], token: Option[String])
 
   def webHookForm(update:Boolean) = mapping(
     "url"    -> trim(label("url", text(required, webHook(update)))),
     "events" -> webhookEvents,
-    "ctype" -> label("ctype", text()),
     "token" -> optional(trim(label("token", text(maxlength(100)))))
-  )(
-    (url, events, ctype, token) => WebHookForm(url, events, WebHookContentType.valueOf(ctype), token)
-  )
+  )(WebHookForm.apply)
 
   // for transfer ownership
   case class TransferOwnerShipForm(newOwner: String)
@@ -91,7 +87,7 @@ trait RepositorySettingsControllerBase extends ControllerBase {
       repository.name,
       form.description,
       repository.repository.parentUserName.map { _ =>
-        repository.repository.isPrivate
+        repository.repository.`private`
       } getOrElse form.isPrivate
     )
     // Change repository name
@@ -152,7 +148,7 @@ trait RepositorySettingsControllerBase extends ControllerBase {
   get("/:owner/:repository/settings/collaborators")(ownerOnly { repository =>
     html.collaborators(
       getCollaborators(repository.owner, repository.name),
-      getAccountByUserName(repository.owner).get.isGroupAccount,
+      getAccountByUserName(repository.owner).get.groupAccount,
       repository)
   })
 
@@ -160,7 +156,7 @@ trait RepositorySettingsControllerBase extends ControllerBase {
    * Add the collaborator.
    */
   post("/:owner/:repository/settings/collaborators/add", collaboratorForm)(ownerOnly { (form, repository) =>
-    if(!getAccountByUserName(repository.owner).get.isGroupAccount){
+    if(!getAccountByUserName(repository.owner).get.groupAccount){
       addCollaborator(repository.owner, repository.name, form.userName)
     }
     redirect(s"/${repository.owner}/${repository.name}/settings/collaborators")
@@ -170,7 +166,7 @@ trait RepositorySettingsControllerBase extends ControllerBase {
    * Add the collaborator.
    */
   get("/:owner/:repository/settings/collaborators/remove")(ownerOnly { repository =>
-    if(!getAccountByUserName(repository.owner).get.isGroupAccount){
+    if(!getAccountByUserName(repository.owner).get.groupAccount){
       removeCollaborator(repository.owner, repository.name, params("name"))
     }
     redirect(s"/${repository.owner}/${repository.name}/settings/collaborators")
@@ -187,7 +183,7 @@ trait RepositorySettingsControllerBase extends ControllerBase {
    * Display the web hook edit page.
    */
   get("/:owner/:repository/settings/hooks/new")(ownerOnly { repository =>
-    val webhook = WebHook(repository.owner, repository.name, "", WebHookContentType.FORM, None)
+    val webhook = WebHook(repository.owner, repository.name, "", None)
     html.edithooks(webhook, Set(WebHook.Push), repository, flash.get("info"), true)
   })
 
@@ -195,7 +191,7 @@ trait RepositorySettingsControllerBase extends ControllerBase {
    * Add the web hook URL.
    */
   post("/:owner/:repository/settings/hooks/new", webHookForm(false))(ownerOnly { (form, repository) =>
-    addWebHook(repository.owner, repository.name, form.url, form.events, form.ctype, form.token)
+    addWebHook(repository.owner, repository.name, form.url, form.events, form.token)
     flash += "info" -> s"Webhook ${form.url} created"
     redirect(s"/${repository.owner}/${repository.name}/settings/hooks")
   })
@@ -225,8 +221,7 @@ trait RepositorySettingsControllerBase extends ControllerBase {
 
       val url = params("url")
       val token = Some(params("token"))
-      val ctype = WebHookContentType.valueOf(params("ctype"))
-      val dummyWebHookInfo = WebHook(repository.owner, repository.name, url, ctype, token)
+      val dummyWebHookInfo = WebHook(repository.owner, repository.name, url, token)
       val dummyPayload = {
         val ownerAccount = getAccountByUserName(repository.owner).get
         val commits = if(repository.commitCount == 0) List.empty else git.log
@@ -285,7 +280,7 @@ trait RepositorySettingsControllerBase extends ControllerBase {
    * Update web hook settings.
    */
   post("/:owner/:repository/settings/hooks/edit", webHookForm(true))(ownerOnly { (form, repository) =>
-    updateWebHook(repository.owner, repository.name, form.url, form.events, form.ctype, form.token)
+    updateWebHook(repository.owner, repository.name, form.url, form.events, form.token)
     flash += "info" -> s"webhook ${form.url} updated"
     redirect(s"/${repository.owner}/${repository.name}/settings/hooks")
   })
@@ -369,7 +364,7 @@ trait RepositorySettingsControllerBase extends ControllerBase {
     override def validate(name: String, value: String, messages: Messages): Option[String] =
       getAccountByUserName(value) match {
         case None => Some("User does not exist.")
-        case Some(x) if(x.isGroupAccount)
+        case Some(x) if(x.groupAccount)
                   => Some("User does not exist.")
         case Some(x) if(x.userName == params("owner") || getCollaborators(params("owner"), params("repository")).contains(x.userName))
                   => Some("User can access this repository already.")

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

@@ -497,10 +497,6 @@ trait RepositoryViewerControllerBase extends ControllerBase {
       getForkedRepositories(
         repository.repository.originUserName.getOrElse(repository.owner),
         repository.repository.originRepositoryName.getOrElse(repository.name)),
-      context.loginAccount match {
-        case None => List()
-        case account: Option[Account] => getGroupsByUserName(account.get.userName)
-      }, // groups of current user
       repository)
   })
 
@@ -511,7 +507,13 @@ trait RepositoryViewerControllerBase extends ControllerBase {
     using(Git.open(getRepositoryDir(repository.owner, repository.name))){ git =>
       val ref = multiParams("splat").head
       JGitUtil.getTreeId(git, ref).map{ treeId =>
-        html.find(ref, treeId, repository)
+        html.find(ref,
+                  treeId,
+                  repository,
+                  context.loginAccount match {
+                    case None => List()
+                    case account: Option[Account] => getGroupsByUserName(account.get.userName)
+                  })
       } getOrElse NotFound
     }
   })
@@ -573,6 +575,10 @@ trait RepositoryViewerControllerBase extends ControllerBase {
 
             html.files(revision, repository,
               if(path == ".") Nil else path.split("/").toList, // current path
+              context.loginAccount match {
+                case None => List()
+                case account: Option[Account] => getGroupsByUserName(account.get.userName)
+              }, // groups of current user
               new JGitUtil.CommitInfo(lastModifiedCommit), // last modified commit
               files, readme, hasWritePermission(repository.owner, repository.name, context.loginAccount),
               getPullRequestFromBranch(repository.owner, repository.name, revstr, repository.repository.defaultBranch),

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

@@ -1,7 +1,5 @@
 package gitbucket.core.controller
 
-import java.io.FileInputStream
-
 import gitbucket.core.admin.html
 import gitbucket.core.service.{AccountService, SystemSettingsService, RepositoryService}
 import gitbucket.core.util.AdminAuthenticator
@@ -13,7 +11,7 @@ import gitbucket.core.util.ControlUtil._
 import gitbucket.core.util.Directory._
 import gitbucket.core.util.StringUtil._
 import io.github.gitbucket.scalatra.forms._
-import org.apache.commons.io.{IOUtils, FileUtils}
+import org.apache.commons.io.FileUtils
 import org.scalatra.i18n.Messages
 
 class SystemSettingsController extends SystemSettingsControllerBase
@@ -76,7 +74,6 @@ trait SystemSettingsControllerBase extends AccountManagementControllerBase {
 
   case class PluginForm(pluginIds: List[String])
 
-  case class DataExportForm(tableNames: List[String])
 
   case class NewUserForm(userName: String, password: String, fullName: String,
                          mailAddress: String, isAdmin: Boolean,
@@ -160,7 +157,7 @@ trait SystemSettingsControllerBase extends AccountManagementControllerBase {
   get("/admin/users")(adminOnly {
     val includeRemoved = params.get("includeRemoved").map(_.toBoolean).getOrElse(false)
     val users          = getAllUsers(includeRemoved)
-    val members        = users.collect { case account if(account.isGroupAccount) =>
+    val members        = users.collect { case account if(account.groupAccount) =>
       account.userName -> getGroupMembers(account.userName).map(_.userName)
     }.toMap
 
@@ -179,39 +176,36 @@ trait SystemSettingsControllerBase extends AccountManagementControllerBase {
 
   get("/admin/users/:userName/_edituser")(adminOnly {
     val userName = params("userName")
-    html.user(getAccountByUserName(userName, true), flash.get("error"))
+    html.user(getAccountByUserName(userName, true))
   })
 
   post("/admin/users/:name/_edituser", editUserForm)(adminOnly { form =>
     val userName = params("userName")
     getAccountByUserName(userName, true).map { account =>
-      if(account.isAdmin && (form.isRemoved || !form.isAdmin) && isLastAdministrator(account)){
-        flash += "error" -> "Account can't be turned off because this is last one administrator."
-        redirect(s"/admin/users/${userName}/_edituser")
-      } else {
-        if(form.isRemoved){
-          // Remove repositories
-          //        getRepositoryNamesOfUser(userName).foreach { repositoryName =>
-          //          deleteRepository(userName, repositoryName)
-          //          FileUtils.deleteDirectory(getRepositoryDir(userName, repositoryName))
-          //          FileUtils.deleteDirectory(getWikiRepositoryDir(userName, repositoryName))
-          //          FileUtils.deleteDirectory(getTemporaryDir(userName, repositoryName))
-          //        }
-          // Remove from GROUP_MEMBER, COLLABORATOR and REPOSITORY
-          removeUserRelatedData(userName)
-        }
 
-        updateAccount(account.copy(
-          password     = form.password.map(sha1).getOrElse(account.password),
-          fullName     = form.fullName,
-          mailAddress  = form.mailAddress,
-          isAdmin      = form.isAdmin,
-          url          = form.url,
-          isRemoved    = form.isRemoved))
-
-        updateImage(userName, form.fileId, form.clearImage)
-        redirect("/admin/users")
+      if(form.isRemoved){
+        // Remove repositories
+        //        getRepositoryNamesOfUser(userName).foreach { repositoryName =>
+        //          deleteRepository(userName, repositoryName)
+        //          FileUtils.deleteDirectory(getRepositoryDir(userName, repositoryName))
+        //          FileUtils.deleteDirectory(getWikiRepositoryDir(userName, repositoryName))
+        //          FileUtils.deleteDirectory(getTemporaryDir(userName, repositoryName))
+        //        }
+        // Remove from GROUP_MEMBER, COLLABORATOR and REPOSITORY
+        removeUserRelatedData(userName)
       }
+
+      updateAccount(account.copy(
+        password      = form.password.map(sha1).getOrElse(account.password),
+        fullName      = form.fullName,
+        mailAddress   = form.mailAddress,
+        administrator = form.isAdmin,
+        url           = form.url,
+        removed       = form.isRemoved))
+
+      updateImage(userName, form.fileId, form.clearImage)
+      redirect("/admin/users")
+
     } getOrElse NotFound
   })
 
@@ -274,32 +268,6 @@ trait SystemSettingsControllerBase extends AccountManagementControllerBase {
     }
   })
 
-  get("/admin/data")(adminOnly {
-    import gitbucket.core.util.JDBCUtil._
-    val session = request2Session(request)
-    html.data(session.conn.allTableNames())
-  })
-
-  post("/admin/export")(adminOnly {
-    import gitbucket.core.util.JDBCUtil._
-    val session = request2Session(request)
-    val file = if(params("type") == "sql"){
-      session.conn.exportAsSQL(request.getParameterValues("tableNames").toSeq)
-    } else {
-      session.conn.exportAsXML(request.getParameterValues("tableNames").toSeq)
-    }
-
-    contentType = "application/octet-stream"
-    response.setHeader("Content-Disposition", "attachment; filename=" + file.getName)
-    response.setContentLength(file.length.toInt)
-
-    using(new FileInputStream(file)){ in =>
-      IOUtils.copy(in, response.outputStream)
-    }
-
-    ()
-  })
-
   private def members: Constraint = new Constraint(){
     override def validate(name: String, value: String, messages: Messages): Option[String] = {
       if(value.split(",").exists {

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

@@ -12,8 +12,7 @@ import org.eclipse.jgit.api.Git
 import org.scalatra.i18n.Messages
 
 class WikiController extends WikiControllerBase 
-  with WikiService with RepositoryService with AccountService with ActivityService
-  with CollaboratorsAuthenticator with ReferrerAuthenticator
+  with WikiService with RepositoryService with AccountService with ActivityService with CollaboratorsAuthenticator with ReferrerAuthenticator
 
 trait WikiControllerBase extends ControllerBase {
   self: WikiService with RepositoryService with ActivityService with CollaboratorsAuthenticator with ReferrerAuthenticator =>

src/main/scala/gitbucket/core/model/Account.scala

@@ -11,7 +11,7 @@ trait AccountComponent { self: Profile =>
     val fullName = column[String]("FULL_NAME")
     val mailAddress = column[String]("MAIL_ADDRESS")
     val password = column[String]("PASSWORD")
-    val isAdmin = column[Boolean]("ADMINISTRATOR")
+    val administrator = column[Boolean]("ADMINISTRATOR")
     val url = column[String]("URL")
     val registeredDate = column[java.util.Date]("REGISTERED_DATE")
     val updatedDate = column[java.util.Date]("UPDATED_DATE")
@@ -19,7 +19,7 @@ trait AccountComponent { self: Profile =>
     val image = column[String]("IMAGE")
     val groupAccount = column[Boolean]("GROUP_ACCOUNT")
     val removed = column[Boolean]("REMOVED")
-    def * = (userName, fullName, mailAddress, password, isAdmin, url.?, registeredDate, updatedDate, lastLoginDate.?, image.?, groupAccount, removed) <> (Account.tupled, Account.unapply)
+    def * = (userName, fullName, mailAddress, password, administrator, url.?, registeredDate, updatedDate, lastLoginDate.?, image.?, groupAccount, removed) <> (Account.tupled, Account.unapply)
   }
 }
 
@@ -28,12 +28,12 @@ case class Account(
   fullName: String,
   mailAddress: String,
   password: String,
-  isAdmin: Boolean,
+  administrator: Boolean,
   url: Option[String],
   registeredDate: java.util.Date,
   updatedDate: java.util.Date,
   lastLoginDate: Option[java.util.Date],
   image: Option[String],
-  isGroupAccount: Boolean,
-  isRemoved: Boolean
+  groupAccount: Boolean,
+  removed: Boolean
 )

src/main/scala/gitbucket/core/model/GroupMembers.scala

@@ -8,13 +8,13 @@ trait GroupMemberComponent { self: Profile =>
   class GroupMembers(tag: Tag) extends Table[GroupMember](tag, "GROUP_MEMBER") {
     val groupName = column[String]("GROUP_NAME", O PrimaryKey)
     val userName = column[String]("USER_NAME", O PrimaryKey)
-    val isManager = column[Boolean]("MANAGER")
-    def * = (groupName, userName, isManager) <> (GroupMember.tupled, GroupMember.unapply)
+    val manager = column[Boolean]("MANAGER")
+    def * = (groupName, userName, manager) <> (GroupMember.tupled, GroupMember.unapply)
   }
 }
 
 case class GroupMember(
   groupName: String,
   userName: String,
-  isManager: Boolean
+  manager: Boolean
 )

src/main/scala/gitbucket/core/model/Plugin.scala

@@ -0,0 +1,19 @@
+package gitbucket.core.model
+
+trait PluginComponent extends TemplateComponent { self: Profile =>
+  import profile.simple._
+  import self._
+
+  lazy val Plugins = TableQuery[Plugins]
+
+  class Plugins(tag: Tag) extends Table[Plugin](tag, "PLUGIN"){
+    val pluginId = column[String]("PLUGIN_ID", O PrimaryKey)
+    val version = column[String]("VERSION")
+    def * = (pluginId, version) <> (Plugin.tupled, Plugin.unapply)
+  }
+}
+
+case class Plugin(
+  pluginId: String,
+  version: String
+)

src/main/scala/gitbucket/core/model/Profile.scala

@@ -1,6 +1,5 @@
 package gitbucket.core.model
 
-import gitbucket.core.util.DatabaseConfig
 
 trait Profile {
   val profile: slick.driver.JdbcProfile
@@ -29,9 +28,7 @@ trait Profile {
 }
 
 trait ProfileProvider { self: Profile =>
-
-  lazy val profile = DatabaseConfig.slickDriver
-
+  val profile = slick.driver.H2Driver
 }
 
 trait CoreProfile extends ProfileProvider with Profile
@@ -52,6 +49,7 @@ trait CoreProfile extends ProfileProvider with Profile
   with SshKeyComponent
   with WebHookComponent
   with WebHookEventComponent
+  with PluginComponent
   with ProtectedBranchComponent
 
 object Profile extends CoreProfile

src/main/scala/gitbucket/core/model/Repository.scala

@@ -26,7 +26,7 @@ trait RepositoryComponent extends TemplateComponent { self: Profile =>
 case class Repository(
   userName: String,
   repositoryName: String,
-  isPrivate: Boolean,
+  `private`: Boolean,
   description: Option[String],
   defaultBranch: String,
   registeredDate: java.util.Date,

src/main/scala/gitbucket/core/model/WebHook.scala

@@ -3,42 +3,21 @@ package gitbucket.core.model
 trait WebHookComponent extends TemplateComponent { self: Profile =>
   import profile.simple._
 
-  implicit val whContentTypeColumnType = MappedColumnType.base[WebHookContentType, String](whct => whct.code , code => WebHookContentType.valueOf(code))
-  
   lazy val WebHooks = TableQuery[WebHooks]
 
   class WebHooks(tag: Tag) extends Table[WebHook](tag, "WEB_HOOK") with BasicTemplate {
     val url = column[String]("URL")
     val token = column[Option[String]]("TOKEN", O.Nullable)
-    val ctype = column[WebHookContentType]("CTYPE", O.NotNull)
-    def * = (userName, repositoryName, url, ctype, token) <> ((WebHook.apply _).tupled, WebHook.unapply)
+    def * = (userName, repositoryName, url, token) <> ((WebHook.apply _).tupled, WebHook.unapply)
 
     def byPrimaryKey(owner: String, repository: String, url: String) = byRepository(owner, repository) && (this.url === url.bind)
   }
 }
 
-case class WebHookContentType(val code: String, val ctype: String)
-
-object WebHookContentType {
-  object JSON extends WebHookContentType("json", "application/json")
-
-  object FORM extends WebHookContentType("form", "application/x-www-form-urlencoded")
-
-  val values: Vector[WebHookContentType] = Vector(JSON, FORM)
-
-  private val map: Map[String, WebHookContentType] = values.map(enum => enum.code -> enum).toMap
-
-  def apply(code: String): WebHookContentType = map(code)
-
-  def valueOf(code: String): WebHookContentType = map(code)
-  def valueOpt(code: String): Option[WebHookContentType] = map.get(code)
-}
-
 case class WebHook(
   userName: String,
   repositoryName: String,
   url: String,
-  ctype: WebHookContentType,
   token: Option[String]
 )
 

src/main/scala/gitbucket/core/plugin/Plugin.scala

@@ -1,18 +1,16 @@
 package gitbucket.core.plugin
 
 import javax.servlet.ServletContext
-import gitbucket.core.controller.{Context, ControllerBase}
-import gitbucket.core.model.Account
-import gitbucket.core.service.RepositoryService.RepositoryInfo
+import gitbucket.core.controller.ControllerBase
 import gitbucket.core.service.SystemSettingsService.SystemSettings
 import gitbucket.core.util.ControlUtil._
-import io.github.gitbucket.solidbase.model.Version
+import gitbucket.core.util.Version
 
 /**
  * Trait for define plugin interface.
- * To provide a plugin, put a Plugin class which extends this class into the package root.
+ * To provide plugin, put Plugin class which mixed in this trait into the package root.
  */
-abstract class Plugin {
+trait Plugin {
 
   val pluginId: String
   val pluginName: String
@@ -79,76 +77,6 @@ abstract class Plugin {
    */
   def receiveHooks(registry: PluginRegistry, context: ServletContext, settings: SystemSettings): Seq[ReceiveHook] = Nil
 
-  /**
-   * Override to add global menus.
-   */
-  val globalMenus: Seq[(Context) => Option[Link]] = Nil
-
-  /**
-   * Override to add global menus.
-   */
-  def globalMenus(registry: PluginRegistry, context: ServletContext, settings: SystemSettings): Seq[(Context) => Option[Link]] = Nil
-
-  /**
-   * Override to add repository menus.
-   */
-  val repositoryMenus: Seq[(RepositoryInfo, Context) => Option[Link]] = Nil
-
-  /**
-   * Override to add repository menus.
-   */
-  def repositoryMenus(registry: PluginRegistry, context: ServletContext, settings: SystemSettings): Seq[(RepositoryInfo, Context) => Option[Link]] = Nil
-
-  /**
-   * Override to add repository setting tabs.
-   */
-  val repositorySettingTabs: Seq[(RepositoryInfo, Context) => Option[Link]] = Nil
-
-  /**
-   * Override to add repository setting tabs.
-   */
-  def repositorySettingTabs(registry: PluginRegistry, context: ServletContext, settings: SystemSettings): Seq[(RepositoryInfo, Context) => Option[Link]] = Nil
-
-  /**
-   * Override to add profile tabs.
-   */
-  val profileTabs: Seq[(Account, Context) => Option[Link]] = Nil
-
-  /**
-   * Override to add profile tabs.
-   */
-  def profileTabs(registry: PluginRegistry, context: ServletContext, settings: SystemSettings): Seq[(Account, Context) => Option[Link]] = Nil
-
-  /**
-   * Override to add system setting menus.
-   */
-  val systemSettingMenus: Seq[(Context) => Option[Link]] = Nil
-
-  /**
-   * Override to add system setting menus.
-   */
-  def systemSettingMenus(registry: PluginRegistry, context: ServletContext, settings: SystemSettings): Seq[(Context) => Option[Link]] = Nil
-
-  /**
-   * Override to add account setting menus.
-   */
-  val accountSettingMenus: Seq[(Context) => Option[Link]] = Nil
-
-  /**
-   * Override to add account setting menus.
-   */
-  def accountSettingMenus(registry: PluginRegistry, context: ServletContext, settings: SystemSettings): Seq[(Context) => Option[Link]] = Nil
-
-  /**
-   * Override to add dashboard tabs.
-   */
-  val dashboardTabs: Seq[(Context) => Option[Link]] = Nil
-
-  /**
-   * Override to add dashboard tabs.
-   */
-  def dashboardTabs(registry: PluginRegistry, context: ServletContext, settings: SystemSettings): Seq[(Context) => Option[Link]] = Nil
-
   /**
    * This method is invoked in initialization of plugin system.
    * Register plugin functionality to PluginRegistry.
@@ -172,27 +100,6 @@ abstract class Plugin {
     (receiveHooks ++ receiveHooks(registry, context, settings)).foreach { receiveHook =>
       registry.addReceiveHook(receiveHook)
     }
-    (globalMenus ++ globalMenus(registry, context, settings)).foreach { globalMenu =>
-      registry.addGlobalMenu(globalMenu)
-    }
-    (repositoryMenus ++ repositoryMenus(registry, context, settings)).foreach { repositoryMenu =>
-      registry.addRepositoryMenu(repositoryMenu)
-    }
-    (repositorySettingTabs ++ repositorySettingTabs(registry, context, settings)).foreach { repositorySettingTab =>
-      registry.addRepositorySettingTab(repositorySettingTab)
-    }
-    (profileTabs ++ profileTabs(registry, context, settings)).foreach { profileTab =>
-      registry.addProfileTab(profileTab)
-    }
-    (systemSettingMenus ++ systemSettingMenus(registry, context, settings)).foreach { systemSettingMenu =>
-      registry.addSystemSettingMenu(systemSettingMenu)
-    }
-    (accountSettingMenus ++ accountSettingMenus(registry, context, settings)).foreach { accountSettingMenu =>
-      registry.addAccountSettingMenu(accountSettingMenu)
-    }
-    (dashboardTabs ++ dashboardTabs(registry, context, settings)).foreach { dashboardTab =>
-      registry.addDashboardTab(dashboardTab)
-    }
   }
 
   /**

src/main/scala/gitbucket/core/plugin/PluginRegistory.scala

@@ -3,18 +3,16 @@ package gitbucket.core.plugin
 import java.io.{File, FilenameFilter, InputStream}
 import java.net.URLClassLoader
 import javax.servlet.ServletContext
+import javax.servlet.http.{HttpServletRequest, HttpServletResponse}
 
 import gitbucket.core.controller.{Context, ControllerBase}
-import gitbucket.core.model.Account
 import gitbucket.core.service.ProtectedBranchService.ProtectedBranchReceiveHook
 import gitbucket.core.service.RepositoryService.RepositoryInfo
 import gitbucket.core.service.SystemSettingsService.SystemSettings
 import gitbucket.core.util.ControlUtil._
-import gitbucket.core.util.DatabaseConfig
 import gitbucket.core.util.Directory._
-import io.github.gitbucket.solidbase.Solidbase
-import io.github.gitbucket.solidbase.model.Module
-import liquibase.database.core.H2Database
+import gitbucket.core.util.JDBCUtil._
+import gitbucket.core.util.{Version, Versions}
 import org.apache.commons.codec.binary.{Base64, StringUtils}
 import org.slf4j.LoggerFactory
 
@@ -35,14 +33,6 @@ class PluginRegistry {
   private val receiveHooks = new ListBuffer[ReceiveHook]
   receiveHooks += new ProtectedBranchReceiveHook()
 
-  private val globalMenus = new ListBuffer[(Context) => Option[Link]]
-  private val repositoryMenus = new ListBuffer[(RepositoryInfo, Context) => Option[Link]]
-  private val repositorySettingTabs = new ListBuffer[(RepositoryInfo, Context) => Option[Link]]
-  private val profileTabs = new ListBuffer[(Account, Context) => Option[Link]]
-  private val systemSettingMenus = new ListBuffer[(Context) => Option[Link]]
-  private val accountSettingMenus = new ListBuffer[(Context) => Option[Link]]
-  private val dashboardTabs = new ListBuffer[(Context) => Option[Link]]
-
   def addPlugin(pluginInfo: PluginInfo): Unit = {
     plugins += pluginInfo
   }
@@ -117,47 +107,17 @@ class PluginRegistry {
 
   def getReceiveHooks: Seq[ReceiveHook] = receiveHooks.toSeq
 
-  def addGlobalMenu(globalMenu: (Context) => Option[Link]): Unit = {
-    globalMenus += globalMenu
-  }
+  private case class GlobalAction(
+    method: String,
+    path: String,
+    function: (HttpServletRequest, HttpServletResponse, Context) => Any
+  )
 
-  def getGlobalMenus: Seq[(Context) => Option[Link]] = globalMenus.toSeq
-
-  def addRepositoryMenu(repositoryMenu: (RepositoryInfo, Context) => Option[Link]): Unit = {
-    repositoryMenus += repositoryMenu
-  }
-
-  def getRepositoryMenus: Seq[(RepositoryInfo, Context) => Option[Link]] = repositoryMenus.toSeq
-
-  def addRepositorySettingTab(repositorySettingTab: (RepositoryInfo, Context) => Option[Link]): Unit = {
-    repositorySettingTabs += repositorySettingTab
-  }
-
-  def getRepositorySettingTabs: Seq[(RepositoryInfo, Context) => Option[Link]] = repositorySettingTabs.toSeq
-
-  def addProfileTab(profileTab: (Account, Context) => Option[Link]): Unit = {
-    profileTabs += profileTab
-  }
-
-  def getProfileTabs: Seq[(Account, Context) => Option[Link]] = profileTabs.toSeq
-
-  def addSystemSettingMenu(systemSettingMenu: (Context) => Option[Link]): Unit = {
-    systemSettingMenus += systemSettingMenu
-  }
-
-  def getSystemSettingMenus: Seq[(Context) => Option[Link]] = systemSettingMenus.toSeq
-
-  def addAccountSettingMenu(accountSettingMenu: (Context) => Option[Link]): Unit = {
-    accountSettingMenus += accountSettingMenu
-  }
-
-  def getAccountSettingMenus: Seq[(Context) => Option[Link]] = accountSettingMenus.toSeq
-
-  def addDashboardTab(dashboardTab: (Context) => Option[Link]): Unit = {
-    dashboardTabs += dashboardTab
-  }
-
-  def getDashboardTabs: Seq[(Context) => Option[Link]] = dashboardTabs.toSeq
+  private case class RepositoryAction(
+    method: String,
+    path: String,
+    function: (HttpServletRequest, HttpServletResponse, Context, RepositoryInfo) => Any
+  )
 
 }
 
@@ -189,15 +149,30 @@ object PluginRegistry {
           val plugin = classLoader.loadClass("Plugin").newInstance().asInstanceOf[Plugin]
 
           // Migration
-          val solidbase = new Solidbase()
-          solidbase.migrate(conn, classLoader, DatabaseConfig.liquiDriver, new Module(plugin.pluginId, plugin.versions: _*))
+          val headVersion = plugin.versions.head
+          val currentVersion = conn.find("SELECT * FROM PLUGIN WHERE PLUGIN_ID = ?", plugin.pluginId)(_.getString("VERSION")) match {
+            case Some(x) => {
+              val dim = x.split("\\.")
+              Version(dim(0).toInt, dim(1).toInt)
+            }
+            case None => Version(0, 0)
+          }
+
+          Versions.update(conn, headVersion, currentVersion, plugin.versions, new URLClassLoader(Array(pluginJar.toURI.toURL))){ conn =>
+            currentVersion.versionString match {
+              case "0.0" =>
+                conn.update("INSERT INTO PLUGIN (PLUGIN_ID, VERSION) VALUES (?, ?)", plugin.pluginId, headVersion.versionString)
+              case _ =>
+                conn.update("UPDATE PLUGIN SET VERSION = ? WHERE PLUGIN_ID = ?", headVersion.versionString, plugin.pluginId)
+            }
+          }
 
           // Initialize
           plugin.initialize(instance, context, settings)
           instance.addPlugin(PluginInfo(
             pluginId    = plugin.pluginId,
             pluginName  = plugin.pluginName,
-            version     = plugin.versions.head.getVersion,
+            version     = plugin.versions.head.versionString,
             description = plugin.description,
             pluginClass = plugin
           ))
@@ -226,8 +201,6 @@ object PluginRegistry {
 
 }
 
-case class Link(id: String, label: String, path: String, icon: Option[String] = None)
-
 case class PluginInfo(
   pluginId: String,
   pluginName: String,

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

@@ -5,6 +5,8 @@ import profile.simple._
 
 import gitbucket.core.model.{Account, AccessToken}
 import gitbucket.core.util.StringUtil
+import gitbucket.core.servlet.Database._
+import io.getquill._
 
 import scala.util.Random
 
@@ -27,28 +29,36 @@ trait AccessTokenService {
     var hash: String = null
     do{
       token = makeAccessTokenString
-      hash = tokenToHash(token)
-    }while(AccessTokens.filter(_.tokenHash === hash.bind).exists.run)
+      hash  = tokenToHash(token)
+    } while (
+      db.run(quote { (hash: String) => query[AccessToken].filter(_.tokenHash == hash).nonEmpty })(hash).head
+    )
     val newToken = AccessToken(
         userName = userName,
         note = note,
         tokenHash = hash)
+
+    // TODO Remain Slick code
     val tokenId = (AccessTokens returning AccessTokens.map(_.accessTokenId)) += newToken
     (tokenId, token)
   }
 
-  def getAccountByAccessToken(token: String)(implicit s: Session): Option[Account] =
-    Accounts
-      .innerJoin(AccessTokens)
-      .filter{ case (ac, t) => (ac.userName === t.userName) && (t.tokenHash === tokenToHash(token).bind) && (ac.removed === false.bind) }
-      .map{ case (ac, t) => ac }
-      .firstOption
+  def getAccountByAccessToken(token: String): Option[Account] =
+    db.run(quote { (tokenHash: String) =>
+        query[AccessToken].filter(_.tokenHash == tokenHash)
+          .join(query[Account]).on { (t, a) => t.userName == a.userName && a.registeredDate == false }
+          .map { case (t, a) => a }
+    })(tokenToHash(token)).headOption
 
-  def getAccessTokens(userName: String)(implicit s: Session): List[AccessToken] =
-    AccessTokens.filter(_.userName === userName.bind).sortBy(_.accessTokenId.desc).list
+  def getAccessTokens(userName: String): List[AccessToken] =
+    db.run(quote { (userName: String) =>
+      query[AccessToken].filter(_.userName == userName).sortBy(_.accessTokenId)(Ord.desc)
+    })(userName)
 
-  def deleteAccessToken(userName: String, accessTokenId: Int)(implicit s: Session): Unit =
-    AccessTokens filter (t => t.userName === userName.bind && t.accessTokenId === accessTokenId) delete
+  def deleteAccessToken(userName: String, accessTokenId: Int): Unit =
+    db.run(quote { (userName: String, accessTokenId: Int) =>
+      query[AccessToken].filter { t => t.userName == userName && t.accessTokenId == accessTokenId }.delete
+    })(List((userName, accessTokenId)))
 
 }
 

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

@@ -1,20 +1,23 @@
 package gitbucket.core.service
 
-import gitbucket.core.model.{GroupMember, Account}
+import java.util.Date
+
+import gitbucket.core.model.{GroupMember, Account, Collaborator, Repository}
 import gitbucket.core.model.Profile._
 import gitbucket.core.util.{StringUtil, LDAPUtil}
 import gitbucket.core.service.SystemSettingsService.SystemSettings
 import profile.simple._
 import StringUtil._
 import org.slf4j.LoggerFactory
-// TODO Why is direct import required?
-import gitbucket.core.model.Profile.dateColumnType
+
+import gitbucket.core.servlet.Database._
+import io.getquill._
 
 trait AccountService {
 
   private val logger = LoggerFactory.getLogger(classOf[AccountService])
 
-  def authenticate(settings: SystemSettings, userName: String, password: String)(implicit s: Session): Option[Account] =
+  def authenticate(settings: SystemSettings, userName: String, password: String): Option[Account] =
     if(settings.ldapAuthentication){
       ldapAuthentication(settings, userName, password)
     } else {
@@ -24,22 +27,21 @@ trait AccountService {
   /**
    * Authenticate by internal database.
    */
-  private def defaultAuthentication(userName: String, password: String)(implicit s: Session) = {
+  private def defaultAuthentication(userName: String, password: String) = {
     getAccountByUserName(userName).collect {
-      case account if(!account.isGroupAccount && account.password == sha1(password)) => Some(account)
+      case account if(!account.groupAccount && account.password == sha1(password)) => Some(account)
     } getOrElse None
   }
 
   /**
    * Authenticate by LDAP.
    */
-  private def ldapAuthentication(settings: SystemSettings, userName: String, password: String)
-                                (implicit s: Session): Option[Account] = {
+  private def ldapAuthentication(settings: SystemSettings, userName: String, password: String): Option[Account] = {
     LDAPUtil.authenticate(settings.ldap.get, userName, password) match {
       case Right(ldapUserInfo) => {
         // Create or update account by LDAP information
         getAccountByUserName(ldapUserInfo.userName, true) match {
-          case Some(x) if(!x.isRemoved) => {
+          case Some(x) if(!x.removed) => {
             if(settings.ldap.get.mailAttribute.getOrElse("").isEmpty) {
               updateAccount(x.copy(fullName = ldapUserInfo.fullName))
             } else {
@@ -47,16 +49,16 @@ trait AccountService {
             }
             getAccountByUserName(ldapUserInfo.userName)
           }
-          case Some(x) if(x.isRemoved)  => {
+          case Some(x) if(x.removed)  => {
             logger.info("LDAP Authentication Failed: Account is already registered but disabled.")
             defaultAuthentication(userName, password)
           }
           case None => getAccountByMailAddress(ldapUserInfo.mailAddress, true) match {
-            case Some(x) if(!x.isRemoved) => {
+            case Some(x) if(!x.removed) => {
               updateAccount(x.copy(fullName = ldapUserInfo.fullName))
               getAccountByUserName(ldapUserInfo.userName)
             }
-            case Some(x) if(x.isRemoved)  => {
+            case Some(x) if(x.removed)  => {
               logger.info("LDAP Authentication Failed: Account is already registered but disabled.")
               defaultAuthentication(userName, password)
             }
@@ -74,119 +76,163 @@ trait AccountService {
     }
   }
 
-  def getAccountByUserName(userName: String, includeRemoved: Boolean = false)(implicit s: Session): Option[Account] =
-    Accounts filter(t => (t.userName === userName.bind) && (t.removed === false.bind, !includeRemoved)) firstOption
+  def getAccountByUserName(userName: String, includeRemoved: Boolean = false): Option[Account] = {
+    db.run(quote { (userName: String, includeRemoved: Boolean) =>
+      query[Account].filter { t =>
+        if(includeRemoved){
+          t.userName == userName
+        } else {
+          t.userName == userName && t.removed == false
+        }
+      }
+    })(userName, includeRemoved).headOption
+  }
 
-  def getAccountsByUserNames(userNames: Set[String], knowns:Set[Account], includeRemoved: Boolean = false)(implicit s: Session): Map[String, Account] = {
+
+  def getAccountsByUserNames(userNames: Set[String], knowns:Set[Account], includeRemoved: Boolean = false): Map[String, Account] = {
     val map = knowns.map(a => a.userName -> a).toMap
     val needs = userNames -- map.keySet
     if(needs.isEmpty){
       map
-    }else{
-      map ++ Accounts.filter(t => (t.userName inSetBind needs) && (t.removed === false.bind, !includeRemoved)).list.map(a => a.userName -> a).toMap
-    }
-  }
-
-  def getAccountByMailAddress(mailAddress: String, includeRemoved: Boolean = false)(implicit s: Session): Option[Account] =
-    Accounts filter(t => (t.mailAddress.toLowerCase === mailAddress.toLowerCase.bind) && (t.removed === false.bind, !includeRemoved)) firstOption
-
-  def getAllUsers(includeRemoved: Boolean = true)(implicit s: Session): List[Account] =
-    if(includeRemoved){
-      Accounts sortBy(_.userName) list
     } else {
-      Accounts filter (_.removed === false.bind) sortBy(_.userName) list
+      map ++ db.run(quote { (userNames: Set[String]) =>
+          query[Account].filter { t => userNames.contains(t.userName) && t.removed == false }
+      })(userNames.toSet).map { a => a.userName -> a }.toMap
     }
-
-  def isLastAdministrator(account: Account)(implicit s: Session): Boolean = {
-    if(account.isAdmin){
-      (Accounts filter (_.removed === false.bind) filter (_.isAdmin === true.bind) map (_.userName.length)).first == 1
-    } else false
   }
 
-  def createAccount(userName: String, password: String, fullName: String, mailAddress: String, isAdmin: Boolean, url: Option[String])
-                   (implicit s: Session): Unit =
-    Accounts insert Account(
+  def getAccountByMailAddress(mailAddress: String, includeRemoved: Boolean = false): Option[Account] = {
+    db.run(quote { (mailAddress: String, includeRemoved: Boolean) =>
+      query[Account].filter { t =>
+        if(includeRemoved){
+          t.mailAddress.toLowerCase == mailAddress.toLowerCase
+        } else {
+          t.mailAddress.toLowerCase == mailAddress.toLowerCase && t.removed == false
+        }
+      }
+    })(mailAddress, includeRemoved).headOption
+  }
+
+  def getAllUsers(includeRemoved: Boolean = true): List[Account] = {
+    db.run(
+      if(includeRemoved){
+        quote { query[Account].sortBy(_.userName) }
+      } else {
+        quote { query[Account].filter(_.removed == false).sortBy(_.userName) }
+      }
+    )
+  }
+
+  def createAccount(userName: String, password: String, fullName: String, mailAddress: String, isAdmin: Boolean, url: Option[String]): Unit = {
+    db.run(quote { query[Account].insert })(Account(
       userName       = userName,
       password       = password,
       fullName       = fullName,
       mailAddress    = mailAddress,
-      isAdmin        = isAdmin,
+      administrator  = isAdmin,
       url            = url,
       registeredDate = currentDate,
       updatedDate    = currentDate,
       lastLoginDate  = None,
       image          = None,
-      isGroupAccount = false,
-      isRemoved      = false)
+      groupAccount   = false,
+      removed        = false
+    ))
+  }
 
-  def updateAccount(account: Account)(implicit s: Session): Unit =
-    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) }
-      .update (
-        account.password,
-        account.fullName,
-        account.mailAddress,
-        account.isAdmin,
-        account.url,
-        account.registeredDate,
-        currentDate,
-        account.lastLoginDate,
-        account.isRemoved)
+  def updateAccount(account: Account): Unit = {
+    db.run(quote { (userName: String, password: String, fullName: String, mailAddress: String, administrator: Boolean,
+                    url: Option[String], registeredDate: Date, updatedDate: Date, lastLoginDate: Option[Date], removed: Boolean) =>
+      query[Account].filter(_.userName == userName).update(
+        _.password       -> password,
+        _.fullName       -> fullName,
+        _.mailAddress    -> mailAddress,
+        _.administrator  -> administrator,
+        _.url            -> url,
+        _.registeredDate -> registeredDate,
+        _.updatedDate    -> updatedDate,
+        _.lastLoginDate  -> lastLoginDate,
+        _.removed        -> removed
+      )
+    })((
+      account.userName,
+      account.password,
+      account.fullName,
+      account.mailAddress,
+      account.administrator,
+      account.url,
+      account.registeredDate,
+      currentDate,
+      account.lastLoginDate,
+      account.removed
+    ))
+  }
 
-  def updateAvatarImage(userName: String, image: Option[String])(implicit s: Session): Unit =
-    Accounts.filter(_.userName === userName.bind).map(_.image.?).update(image)
+  def updateAvatarImage(userName: String, image: Option[String]): Unit = {
+    db.run(quote { (userName: String, image: Option[String]) =>
+      query[Account].filter(_.userName == userName).update(_.image -> image)
+    })((userName, image))
+  }
 
-  def updateLastLoginDate(userName: String)(implicit s: Session): Unit =
-    Accounts.filter(_.userName === userName.bind).map(_.lastLoginDate).update(currentDate)
+  def updateLastLoginDate(userName: String): Unit = {
+    db.run(quote { (userName: String, lastLoginDate: Option[Date]) =>
+      query[Account].filter(_.userName == userName).update(_.lastLoginDate -> lastLoginDate)
+    })((userName, Some(currentDate)))
+  }
 
-  def createGroup(groupName: String, url: Option[String])(implicit s: Session): Unit =
-    Accounts insert Account(
+  def createGroup(groupName: String, url: Option[String]): Unit = {
+    db.run( quote { query[Account].insert })(List(Account(
       userName       = groupName,
       password       = "",
       fullName       = groupName,
       mailAddress    = groupName + "@devnull",
-      isAdmin        = false,
+      administrator  = false,
       url            = url,
       registeredDate = currentDate,
       updatedDate    = currentDate,
       lastLoginDate  = None,
       image          = None,
-      isGroupAccount = true,
-      isRemoved      = false)
+      groupAccount  = true,
+      removed       = 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).update(url, removed)
+  def updateGroup(groupName: String, url: Option[String], removed: Boolean): Unit = {
+    db.run(quote { (groupName: String, url: Option[String], removed: Boolean) =>
+      query[Account].filter(_.userName == groupName).update(_.url -> url, _.removed -> removed)
+    })(List((groupName, url, removed)))
+  }
+
+  def updateGroupMembers(groupName: String, members: List[(String, Boolean)]): Unit = {
+    db.run(quote { (groupName: String) => query[GroupMember].filter(_.groupName == groupName).delete })(groupName)
 
-  def updateGroupMembers(groupName: String, members: List[(String, Boolean)])(implicit s: Session): Unit = {
-    GroupMembers.filter(_.groupName === groupName.bind).delete
     members.foreach { case (userName, isManager) =>
-      GroupMembers insert GroupMember (groupName, userName, isManager)
+      db.run(quote { query[GroupMember].insert })(GroupMember(groupName, userName, isManager))
     }
   }
 
-  def getGroupMembers(groupName: String)(implicit s: Session): List[GroupMember] =
-    GroupMembers
-      .filter(_.groupName === groupName.bind)
-      .sortBy(_.userName)
-      .list
-
-  def getGroupsByUserName(userName: String)(implicit s: Session): List[String] =
-    GroupMembers
-      .filter(_.userName === userName.bind)
-      .sortBy(_.groupName)
-      .map(_.groupName)
-      .list
-
-  def removeUserRelatedData(userName: String)(implicit s: Session): Unit = {
-    GroupMembers.filter(_.userName === userName.bind).delete
-    Collaborators.filter(_.collaboratorName === userName.bind).delete
-    Repositories.filter(_.userName === userName.bind).delete
+  def getGroupMembers(groupName: String): List[GroupMember] = {
+    db.run(quote { (groupName: String) =>
+      query[GroupMember].filter(_.groupName == groupName).sortBy(_.userName)
+    })(groupName)
   }
 
-  def getGroupNames(userName: String)(implicit s: Session): List[String] = {
-    List(userName) ++
-      Collaborators.filter(_.collaboratorName === userName.bind).sortBy(_.userName).map(_.userName).list
+  def getGroupsByUserName(userName: String): List[String] = {
+    db.run(quote { (userName: String) =>
+      query[GroupMember].filter(_.userName == userName).sortBy(_.groupName).map(_.groupName)
+    })(userName)
+  }
+
+  def removeUserRelatedData(userName: String): Unit = {
+    db.run(quote { (userName: String) => query[GroupMember].filter(_.userName == userName).delete })(userName)
+    db.run(quote { (userName: String) => query[Collaborator].filter(_.collaboratorName == userName).delete })(userName)
+    db.run(quote { (userName: String) => query[Repository].filter(_.userName == userName).delete })(userName)
+  }
+
+  def getGroupNames(userName: String): List[String] = {
+    List(userName) ++ db.run(quote { (userName: String) =>
+      query[Collaborator].filter(_.collaboratorName == userName).sortBy(_.userName).map(_.userName)
+    })(userName)
   }
 
 }

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

@@ -1,194 +1,180 @@
 package gitbucket.core.service
 
-import gitbucket.core.model.Activity
+import gitbucket.core.model._
 import gitbucket.core.model.Profile._
 import gitbucket.core.util.JGitUtil
 import profile.simple._
 
+import gitbucket.core.servlet.Database._
+import io.getquill._
+
 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).delete
+  def deleteOldActivities(limit: Int): Int =
+    db.run (quote { (limit: Int) =>
+      query[Activity].map(_.activityId).sortBy(x => x)(Ord.desc).drop(limit)
+    })(limit).headOption.map { activityId =>
+      db.run (
+        quote { (activityId: Int) => query[Activity].filter(_.activityId <= activityId).delete }
+      )(activityId)
     } getOrElse 0
-  }
 
-  def getActivitiesByUser(activityUserName: String, isPublic: Boolean)(implicit s: Session): List[Activity] =
-    Activities
-      .innerJoin(Repositories).on((t1, t2) => t1.byRepository(t2.userName, t2.repositoryName))
-      .filter { case (t1, t2) =>
-        if(isPublic){
-          (t1.activityUserName === activityUserName.bind) && (t2.isPrivate === false.bind)
-        } else {
-          (t1.activityUserName === activityUserName.bind)
+  def getActivitiesByUser(activityUserName: String, isPublic: Boolean): List[Activity] =
+    db.run(quote { (activityUserName: String, isPublic: Boolean) =>
+      query[Activity].join(query[Repository]).on((a, r) => a.userName == r.userName && a.repositoryName == r.repositoryName)
+        .filter { case (a, r) =>
+          if(isPublic){
+            a.activityUserName == activityUserName
+          } else {
+            a.activityUserName == activityUserName && r.`private` == false
+          }
         }
-      }
-      .sortBy { case (t1, t2) => t1.activityId desc }
-      .map    { case (t1, t2) => t1 }
-      .take(30)
-      .list
+        .sortBy { case (a, r) => a.activityId }(Ord.desc)
+        .map    { case (a, r) => a }
+        .take(30)
+    })(activityUserName, isPublic)
 
-  def getRecentActivities()(implicit s: Session): List[Activity] =
-    Activities
-      .innerJoin(Repositories).on((t1, t2) => t1.byRepository(t2.userName, t2.repositoryName))
-      .filter { case (t1, t2) =>  t2.isPrivate === false.bind }
-      .sortBy { case (t1, t2) => t1.activityId desc }
-      .map    { case (t1, t2) => t1 }
-      .take(30)
-      .list
+  def getRecentActivities(): List[Activity] =
+    db.run(quote {
+      query[Activity].join(query[Repository]).on((a, r) => a.userName == r.userName && a.repositoryName == r.repositoryName)
+        .filter { case (a, r) => r.`private` == false}
+        .sortBy { case (a, r) => a.activityId }(Ord.desc)
+        .map    { case (a, r) => a }
+        .take(30)
+    })
 
-  def getRecentActivitiesByOwners(owners : Set[String])(implicit s: Session): List[Activity] =
-    Activities
-      .innerJoin(Repositories).on((t1, t2) => t1.byRepository(t2.userName, t2.repositoryName))
-      .filter { case (t1, t2) => (t2.isPrivate === false.bind) || (t2.userName inSetBind owners) }
-      .sortBy { case (t1, t2) => t1.activityId desc }
-      .map    { case (t1, t2) => t1 }
-      .take(30)
-      .list
+  def getRecentActivitiesByOwners(owners : Set[String]): List[Activity] =
+    db.run(quote { (owners: Set[String]) =>
+      query[Activity].join(query[Repository]).on((a, r) => a.userName == r.userName && a.repositoryName == r.repositoryName)
+        .filter { case (a, r) => r.`private` == false || owners.contains(r.userName) }
+        .sortBy { case (a, r) => a.activityId }(Ord.desc)
+        .map    { case (a, r) => a }
+        .take(30)
+    })(owners)
 
-  def recordCreateRepositoryActivity(userName: String, repositoryName: String, activityUserName: String)
-                                    (implicit s: Session): Unit =
-    Activities insert Activity(userName, repositoryName, activityUserName,
+  def recordCreateRepositoryActivity(userName: String, repositoryName: String, activityUserName: String): Unit =
+    insertActivity(userName, repositoryName, activityUserName,
       "create_repository",
       s"[user:${activityUserName}] created [repo:${userName}/${repositoryName}]",
-      None,
-      currentDate)
+      None)
 
-  def recordCreateIssueActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, title: String)
-                               (implicit s: Session): Unit =
-    Activities insert Activity(userName, repositoryName, activityUserName,
+  def recordCreateIssueActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, title: String): Unit =
+    insertActivity(userName, repositoryName, activityUserName,
       "open_issue",
       s"[user:${activityUserName}] opened issue [issue:${userName}/${repositoryName}#${issueId}]",
-      Some(title), 
-      currentDate)
+      Some(title))
 
-  def recordCloseIssueActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, title: String)
-                              (implicit s: Session): Unit =
-    Activities insert Activity(userName, repositoryName, activityUserName,
+  def recordCloseIssueActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, title: String): Unit =
+    insertActivity(userName, repositoryName, activityUserName,
       "close_issue",
       s"[user:${activityUserName}] closed issue [issue:${userName}/${repositoryName}#${issueId}]",
-      Some(title),
-      currentDate)
+      Some(title))
 
-  def recordClosePullRequestActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, title: String)
-                                    (implicit s: Session): Unit =
-    Activities insert Activity(userName, repositoryName, activityUserName,
+  def recordClosePullRequestActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, title: String): Unit =
+    insertActivity(userName, repositoryName, activityUserName,
       "close_issue",
       s"[user:${activityUserName}] closed pull request [pullreq:${userName}/${repositoryName}#${issueId}]",
-      Some(title),
-      currentDate)
+      Some(title))
 
-  def recordReopenIssueActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, title: String)
-                               (implicit s: Session): Unit =
-    Activities insert Activity(userName, repositoryName, activityUserName,
+  def recordReopenIssueActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, title: String): Unit =
+    insertActivity(userName, repositoryName, activityUserName,
       "reopen_issue",
       s"[user:${activityUserName}] reopened issue [issue:${userName}/${repositoryName}#${issueId}]",
-      Some(title),
-      currentDate)
+      Some(title))
 
-  def recordCommentIssueActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, comment: String)
-                                (implicit s: Session): Unit =
-    Activities insert Activity(userName, repositoryName, activityUserName,
+  def recordCommentIssueActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, comment: String): Unit =
+    insertActivity(userName, repositoryName, activityUserName,
       "comment_issue",
       s"[user:${activityUserName}] commented on issue [issue:${userName}/${repositoryName}#${issueId}]",
-      Some(cut(comment, 200)),
-      currentDate)
+      Some(cut(comment, 200)))
 
-  def recordCommentPullRequestActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, comment: String)
-                                      (implicit s: Session): Unit =
-    Activities insert Activity(userName, repositoryName, activityUserName,
+  def recordCommentPullRequestActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, comment: String): Unit =
+    insertActivity(userName, repositoryName, activityUserName,
       "comment_issue",
       s"[user:${activityUserName}] commented on pull request [pullreq:${userName}/${repositoryName}#${issueId}]",
-      Some(cut(comment, 200)),
-      currentDate)
+      Some(cut(comment, 200)))
 
-  def recordCommentCommitActivity(userName: String, repositoryName: String, activityUserName: String, commitId: String, comment: String)
-                                 (implicit s: Session): Unit =
-    Activities insert Activity(userName, repositoryName, activityUserName,
+  def recordCommentCommitActivity(userName: String, repositoryName: String, activityUserName: String, commitId: String, comment: String): Unit =
+    insertActivity(userName, repositoryName, activityUserName,
       "comment_commit",
       s"[user:${activityUserName}] commented on commit [commit:${userName}/${repositoryName}@${commitId}]",
-      Some(cut(comment, 200)),
-      currentDate
-    )
+      Some(cut(comment, 200)))
 
-  def recordCreateWikiPageActivity(userName: String, repositoryName: String, activityUserName: String, pageName: String)
-                                  (implicit s: Session): Unit =
-    Activities insert Activity(userName, repositoryName, activityUserName,
+  def recordCreateWikiPageActivity(userName: String, repositoryName: String, activityUserName: String, pageName: String): Unit =
+    insertActivity(userName, repositoryName, activityUserName,
       "create_wiki",
       s"[user:${activityUserName}] created the [repo:${userName}/${repositoryName}] wiki",
-      Some(pageName),
-      currentDate)
+      Some(pageName))
 
-  def recordEditWikiPageActivity(userName: String, repositoryName: String, activityUserName: String, pageName: String, commitId: String)
-                                (implicit s: Session): Unit =
-    Activities insert Activity(userName, repositoryName, activityUserName,
+  def recordEditWikiPageActivity(userName: String, repositoryName: String, activityUserName: String, pageName: String, commitId: String): Unit =
+    insertActivity(userName, repositoryName, activityUserName,
       "edit_wiki",
       s"[user:${activityUserName}] edited the [repo:${userName}/${repositoryName}] wiki",
-      Some(pageName + ":" + commitId),
-      currentDate)
+      Some(pageName + ":" + commitId))
 
   def recordPushActivity(userName: String, repositoryName: String, activityUserName: String,
-      branchName: String, commits: List[JGitUtil.CommitInfo])(implicit s: Session): Unit =
-    Activities insert Activity(userName, repositoryName, activityUserName,
+      branchName: String, commits: List[JGitUtil.CommitInfo]): Unit =
+    insertActivity(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")),
-      currentDate)
+      Some(commits.map { commit => commit.id + ":" + commit.shortMessage }.mkString("\n")))
 
   def recordCreateTagActivity(userName: String, repositoryName: String, activityUserName: String, 
-      tagName: String, commits: List[JGitUtil.CommitInfo])(implicit s: Session): Unit =
-    Activities insert Activity(userName, repositoryName, activityUserName,
+      tagName: String, commits: List[JGitUtil.CommitInfo]): Unit =
+    insertActivity(userName, repositoryName, activityUserName,
       "create_tag",
       s"[user:${activityUserName}] created tag [tag:${userName}/${repositoryName}#${tagName}] at [repo:${userName}/${repositoryName}]",
-      None,
-      currentDate)
+      None)
 
   def recordDeleteTagActivity(userName: String, repositoryName: String, activityUserName: String,
-                              tagName: String, commits: List[JGitUtil.CommitInfo])(implicit s: Session): Unit =
-    Activities insert Activity(userName, repositoryName, activityUserName,
+                              tagName: String, commits: List[JGitUtil.CommitInfo]): Unit =
+    insertActivity(userName, repositoryName, activityUserName,
       "delete_tag",
       s"[user:${activityUserName}] deleted tag ${tagName} at [repo:${userName}/${repositoryName}]",
-      None,
-      currentDate)
+      None)
 
-  def recordCreateBranchActivity(userName: String, repositoryName: String, activityUserName: String, branchName: String)
-                                (implicit s: Session): Unit =
-    Activities insert Activity(userName, repositoryName, activityUserName,
+  def recordCreateBranchActivity(userName: String, repositoryName: String, activityUserName: String, branchName: String): Unit =
+    insertActivity(userName, repositoryName, activityUserName,
       "create_branch",
       s"[user:${activityUserName}] created branch [branch:${userName}/${repositoryName}#${branchName}] at [repo:${userName}/${repositoryName}]",
-      None,
-      currentDate)
+      None)
 
-  def recordDeleteBranchActivity(userName: String, repositoryName: String, activityUserName: String, branchName: String)
-                                (implicit s: Session): Unit =
-    Activities insert Activity(userName, repositoryName, activityUserName,
+  def recordDeleteBranchActivity(userName: String, repositoryName: String, activityUserName: String, branchName: String): Unit =
+    insertActivity(userName, repositoryName, activityUserName,
       "delete_branch",
       s"[user:${activityUserName}] deleted branch ${branchName} at [repo:${userName}/${repositoryName}]",
-      None,
-      currentDate)
+      None)
 
-  def recordForkActivity(userName: String, repositoryName: String, activityUserName: String, forkedUserName: String)(implicit s: Session): Unit = 
-    Activities insert Activity(userName, repositoryName, activityUserName,
+  def recordForkActivity(userName: String, repositoryName: String, activityUserName: String, forkedUserName: String): Unit =
+    insertActivity(userName, repositoryName, activityUserName,
       "fork",
       s"[user:${activityUserName}] forked [repo:${userName}/${repositoryName}] to [repo:${forkedUserName}/${repositoryName}]",
-      None,
-      currentDate)
+      None)
 
-  def recordPullRequestActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, title: String)
-                               (implicit s: Session): Unit =
-    Activities insert Activity(userName, repositoryName, activityUserName,
+  def recordPullRequestActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, title: String): Unit =
+    insertActivity(userName, repositoryName, activityUserName,
       "open_pullreq",
       s"[user:${activityUserName}] opened pull request [pullreq:${userName}/${repositoryName}#${issueId}]",
-      Some(title),
-      currentDate)
+      Some(title))
 
-  def recordMergeActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, message: String)
-                         (implicit s: Session): Unit =
-    Activities insert Activity(userName, repositoryName, activityUserName,
+  def recordMergeActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, message: String): Unit =
+    insertActivity(userName, repositoryName, activityUserName,
       "merge_pullreq",
       s"[user:${activityUserName}] merged pull request [pullreq:${userName}/${repositoryName}#${issueId}]",
-      Some(message),
-      currentDate)
+      Some(message))
+
+  private def insertActivity(userName: String, repositoryName: String, activityUserName: String, activityType: String,
+                             message: String, additionalInfo: Option[String]): Unit = {
+    db.run(quote { query[Activity].insert })(Activity(
+      userName         = userName,
+      repositoryName   = repositoryName,
+      activityUserName = activityUserName,
+      activityType     = activityType,
+      message          = message,
+      additionalInfo   = additionalInfo,
+      activityDate     = currentDate
+    ))
+  }
 
   private def cut(value: String, length: Int): String =
     if(value.length > length) value.substring(0, length) + "..." else value

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

@@ -1,35 +1,34 @@
 package gitbucket.core.service
 
 import gitbucket.core.model.CommitComment
-import gitbucket.core.util.{StringUtil, Implicits}
-
-import scala.slick.jdbc.{StaticQuery => Q}
-import Q.interpolation
 import gitbucket.core.model.Profile._
 import profile.simple._
-import Implicits._
-import StringUtil._
+
+import gitbucket.core.servlet.Database._
+import io.getquill._
 
 
 trait CommitsService {
 
-  def getCommitComments(owner: String, repository: String, commitId: String, includePullRequest: Boolean)(implicit s: Session) =
-    CommitComments filter {
-      t => t.byCommit(owner, repository, commitId) && (t.issueId.isEmpty || includePullRequest)
-    } list
+  def getCommitComments(owner: String, repository: String, commitId: String, includePullRequest: Boolean) =
+    db.run(quote { (owner: String, repository: String, commitId: String, includePullRequest: Boolean) =>
+      query[CommitComment].filter { t =>
+        t.userName == owner && t.repositoryName == repository && t.commitId == commitId && (t.issueId.isEmpty || includePullRequest)
+      }
+    })(owner, repository, commitId, includePullRequest)
 
-  def getCommitComment(owner: String, repository: String, commentId: String)(implicit s: Session) =
+  def getCommitComment(owner: String, repository: String, commentId: String) =
     if (commentId forall (_.isDigit))
-      CommitComments filter { t =>
-        t.byPrimaryKey(commentId.toInt) && t.byRepository(owner, repository)
-      } firstOption
+      db.run(quote { (owner: String, repository: String, commentId: Int) =>
+        query[CommitComment].filter(t => t.userName == owner && t.repositoryName == repository && t.commentId == commentId)
+      })(owner, repository, commentId.toInt).headOption
     else
       None
 
   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.autoInc insert CommitComment(
+    CommitComments.autoInc insert CommitComment( // TODO Remain Slick code
       userName          = owner,
       repositoryName    = repository,
       commitId          = commitId,
@@ -42,13 +41,12 @@ trait CommitsService {
       updatedDate       = currentDate,
       issueId           = issueId)
 
-  def updateCommitComment(commentId: Int, content: String)(implicit s: Session) =
-    CommitComments
-      .filter (_.byPrimaryKey(commentId))
-      .map { t =>
-      t.content -> t.updatedDate
-    }.update (content, currentDate)
+  def updateCommitComment(commentId: Int, content: String) =
+    db.run(quote { (commentId: Int, content: String, updatedDate: java.util.Date) =>
+      query[CommitComment].filter(_.commentId == commentId).update(_.content -> content, _.updatedDate -> updatedDate)
+    })(commentId, content, currentDate)
+
+  def deleteCommitComment(commentId: Int) =
+    db.run(quote { (commentId: Int) => query[CommitComment].filter(_.commentId == commentId).delete })(commentId)
 
-  def deleteCommitComment(commentId: Int)(implicit s: Session) =
-    CommitComments filter (_.byPrimaryKey(commentId)) delete
 }

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

@@ -108,41 +108,25 @@ trait IssuesService {
       }
       import gitbucket.core.model.Profile.commitStateColumnType
       val query = Q.query[Seq[(String, String, Int)], (String, String, Int, Int, Int, Option[String], Option[CommitState], Option[String], Option[String])](s"""
-        SELECT
-          SUMM.USER_NAME,
-          SUMM.REPOSITORY_NAME,
-          SUMM.ISSUE_ID,
-          CS_ALL,
-          CS_SUCCESS,
-          CSD.CONTEXT,
-          CSD.STATE,
-          CSD.TARGET_URL,
-          CSD.DESCRIPTION
-        FROM (
-          SELECT
-            PR.USER_NAME,
-            PR.REPOSITORY_NAME,
-            PR.ISSUE_ID,
-            COUNT(CS.STATE) AS CS_ALL,
-            CSS.CS_SUCCESS  AS CS_SUCCESS,
-            PR.COMMIT_ID_TO AS COMMIT_ID
+        SELECT SUMM.USER_NAME, SUMM.REPOSITORY_NAME, SUMM.ISSUE_ID, CS_ALL, CS_SUCCESS
+             , CSD.CONTEXT, CSD.STATE, CSD.TARGET_URL, CSD.DESCRIPTION
+        FROM (SELECT
+           PR.USER_NAME
+         , PR.REPOSITORY_NAME
+         , PR.ISSUE_ID
+         , COUNT(CS.STATE) AS CS_ALL
+         , SUM(CS.STATE='success') AS CS_SUCCESS
+         , PR.COMMIT_ID_TO AS COMMIT_ID
           FROM PULL_REQUEST PR
           JOIN COMMIT_STATUS CS
-            ON PR.USER_NAME = CS.USER_NAME AND PR.REPOSITORY_NAME = CS.REPOSITORY_NAME AND PR.COMMIT_ID_TO = CS.COMMIT_ID
-          JOIN (
-            SELECT
-              COUNT(*) AS CS_SUCCESS,
-              USER_NAME,
-              REPOSITORY_NAME,
-              COMMIT_ID
-            FROM COMMIT_STATUS WHERE STATE = 'success' GROUP BY USER_NAME, REPOSITORY_NAME, COMMIT_ID
-          ) CSS ON PR.USER_NAME = CSS.USER_NAME AND PR.REPOSITORY_NAME = CSS.REPOSITORY_NAME AND PR.COMMIT_ID_TO = CSS.COMMIT_ID
-          WHERE $issueIdQuery
-          GROUP BY PR.USER_NAME, PR.REPOSITORY_NAME, PR.ISSUE_ID, CSS.CS_SUCCESS
-        ) as SUMM
+            ON PR.USER_NAME=CS.USER_NAME
+           AND PR.REPOSITORY_NAME=CS.REPOSITORY_NAME
+           AND PR.COMMIT_ID_TO=CS.COMMIT_ID
+         WHERE $issueIdQuery
+         GROUP BY PR.USER_NAME, PR.REPOSITORY_NAME, PR.ISSUE_ID) as SUMM
         LEFT OUTER JOIN COMMIT_STATUS CSD
           ON SUMM.CS_ALL = 1 AND SUMM.COMMIT_ID = CSD.COMMIT_ID""");
-      query(issueList).list.map {
+      query(issueList).list.map{
         case(userName, repositoryName, issueId, count, successCount, context, state, targetUrl, description) =>
           (userName, repositoryName, issueId) -> CommitStatusInfo(count, successCount, context, state, targetUrl, description)
         }.toMap
@@ -234,8 +218,9 @@ trait IssuesService {
         .map { case (owner, repository) => t1.byRepository(owner, repository) }
         .foldLeft[Column[Boolean]](false) ( _ || _ ) &&
       (t1.closed           === (condition.state == "closed").bind) &&
-      (t1.milestoneId.?      isEmpty, condition.milestone == Some(None)) &&
-      (t1.assignedUserName.? isEmpty, condition.assigned  == Some(None)) &&
+      //(t1.milestoneId      === condition.milestoneId.get.get.bind, condition.milestoneId.flatten.isDefined) &&
+      (t1.milestoneId.?    isEmpty, condition.milestone == Some(None)) &&
+      (t1.assignedUserName === condition.assigned.get.bind, condition.assigned.isDefined) &&
       (t1.openedUserName   === condition.author.get.bind, condition.author.isDefined) &&
       (t1.pullRequest      === pullRequest.bind) &&
       // Milestone filter
@@ -243,8 +228,6 @@ trait IssuesService {
         (t2.byPrimaryKey(t1.userName, t1.repositoryName, t1.milestoneId)) &&
         (t2.title === condition.milestone.get.get.bind)
       } exists, condition.milestone.flatten.isDefined) &&
-      // Assignee filter
-      (t1.assignedUserName === condition.assigned.get.get.bind, condition.assigned.flatten.isDefined) &&
       // Label filter
       (IssueLabels filter { t2 =>
         (t2.byIssue(t1.userName, t1.repositoryName, t1.issueId)) &&
@@ -448,7 +431,7 @@ object IssuesService {
       labels: Set[String] = Set.empty,
       milestone: Option[Option[String]] = None,
       author: Option[String] = None,
-      assigned: Option[Option[String]] = None,
+      assigned: Option[String] = None,
       mentioned: Option[String] = None,
       state: String = "open",
       sort: String = "created",
@@ -492,15 +475,12 @@ object IssuesService {
     def toURL: String =
       "?" + List(
         if(labels.isEmpty) None else Some("labels=" + urlEncode(labels.mkString(","))),
-        milestone.map {
+        milestone.map { _ match {
           case Some(x) => "milestone=" + urlEncode(x)
           case None    => "milestone=none"
-        },
+        }},
         author   .map(x => "author="    + urlEncode(x)),
-        assigned.map {
-          case Some(x) => "assigned="  + urlEncode(x)
-          case None    => "assigned=none"
-        },
+        assigned .map(x => "assigned="  + urlEncode(x)),
         mentioned.map(x => "mentioned=" + urlEncode(x)),
         Some("state="     + urlEncode(state)),
         Some("sort="      + urlEncode(sort)),
@@ -545,14 +525,10 @@ object IssuesService {
         conditions.get("milestone").flatMap(_.headOption) match {
           case None         => None
           case Some("none") => Some(None)
-          case Some(x)      => Some(Some(x))
+          case Some(x)      => Some(Some(x)) //milestones.get(x).map(x => Some(x))
         },
         conditions.get("author").flatMap(_.headOption),
-        conditions.get("assignee").flatMap(_.headOption) match {
-          case None         => None
-          case Some("none") => Some(None)
-          case Some(x)      => Some(Some(x))
-        },
+        conditions.get("assignee").flatMap(_.headOption),
         conditions.get("mentions").flatMap(_.headOption),
         conditions.get("is").getOrElse(Seq.empty).find(x => x == "open" || x == "closed").getOrElse("open"),
         sort,
@@ -573,10 +549,7 @@ object IssuesService {
           case x      => Some(x)
         },
         param(request, "author"),
-        param(request, "assigned").map {
-          case "none" => None
-          case x      => Some(x)
-        },
+        param(request, "assigned"),
         param(request, "mentioned"),
         param(request, "state",     Seq("open", "closed")).getOrElse("open"),
         param(request, "sort",      Seq("created", "comments", "updated")).getOrElse("created"),

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

@@ -0,0 +1,24 @@
+package gitbucket.core.service
+
+import gitbucket.core.model.Plugin
+import gitbucket.core.model.Profile._
+import profile.simple._
+
+trait PluginService {
+
+  def getPlugins()(implicit s: Session): List[Plugin] =
+    Plugins.sortBy(_.pluginId).list
+
+  def registerPlugin(plugin: Plugin)(implicit s: Session): Unit =
+    Plugins.insert(plugin)
+
+  def updatePlugin(plugin: Plugin)(implicit s: Session): Unit =
+    Plugins.filter(_.pluginId === plugin.pluginId.bind).map(_.version).update(plugin.version)
+
+  def deletePlugin(pluginId: String)(implicit s: Session): Unit =
+    Plugins.filter(_.pluginId === pluginId.bind).delete
+
+  def getPlugin(pluginId: String)(implicit s: Session): Option[Plugin] =
+    Plugins.filter(_.pluginId === pluginId.bind).firstOption
+
+}

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

@@ -76,7 +76,7 @@ object ProtectedBranchService {
     includeAdministrators: Boolean) extends AccountService with CommitStatusService {
 
     def isAdministrator(pusher: String)(implicit session: Session): Boolean =
-      pusher == owner || getGroupMembers(owner).filter(gm => gm.userName == pusher && gm.isManager).nonEmpty
+      pusher == owner || getGroupMembers(owner).filter(gm => gm.userName == pusher && gm.manager).nonEmpty
 
     /**
      * Can't be force pushed

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

@@ -22,7 +22,7 @@ trait RepositoryCreationService {
     insertRepository(name, owner, description, isPrivate)
 
     // Add collaborators for group repository
-    if(ownerAccount.isGroupAccount){
+    if(ownerAccount.groupAccount){
       getGroupMembers(owner).foreach { member =>
         addCollaborator(owner, name, member.userName)
       }

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

@@ -53,30 +53,7 @@ trait RepositorySearchService { self: IssuesService =>
       }
     }
 
-  def countWikiPages(owner: String, repository: String, query: String): Int =
-    using(Git.open(Directory.getWikiRepositoryDir(owner, repository))){ git =>
-      if(JGitUtil.isEmpty(git)) 0 else searchRepositoryFiles(git, query).length
-    }
-
-  def searchWikiPages(owner: String, repository: String, query: String): List[FileSearchResult] =
-    using(Git.open(Directory.getWikiRepositoryDir(owner, repository))){ git =>
-      if(JGitUtil.isEmpty(git)){
-        Nil
-      } else {
-        val files = searchRepositoryFiles(git, query)
-        val commits = JGitUtil.getLatestCommitFromPaths(git, files.map(_._1), "HEAD")
-        files.map { case (path, text) =>
-          val (highlightText, lineNumber) = getHighlightText(text, query)
-          FileSearchResult(
-            path.replaceFirst("\\.md$", ""),
-            commits(path).getCommitterIdent.getWhen,
-            highlightText,
-            lineNumber)
-        }
-      }
-    }
-
-  def searchRepositoryFiles(git: Git, query: String): List[(String, String)] = {
+  private def searchRepositoryFiles(git: Git, query: String): List[(String, String)] = {
     val revWalk   = new RevWalk(git.getRepository)
     val objectId  = git.getRepository.resolve("HEAD")
     val revCommit = revWalk.parseCommit(objectId)

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

@@ -27,7 +27,7 @@ trait RepositoryService { self: AccountService =>
       Repository(
         userName             = userName,
         repositoryName       = repositoryName,
-        isPrivate            = isPrivate,
+        `private`            = isPrivate,
         description          = description,
         defaultBranch        = "master",
         registeredDate       = currentDate,
@@ -115,7 +115,7 @@ trait RepositoryService { self: AccountService =>
           repositoryName = newRepositoryName
         )) :_*)
 
-        if(account.isGroupAccount){
+        if(account.groupAccount){
           Collaborators.insertAll(getGroupMembers(newUserName).map(m => Collaborator(newUserName, newRepositoryName, m.userName)) :_*)
         } else {
           Collaborators.insertAll(collaborators.map(_.copy(userName = newUserName, repositoryName = newRepositoryName)) :_*)
@@ -270,9 +270,9 @@ trait RepositoryService { self: AccountService =>
                             (implicit s: Session): List[RepositoryInfo] = {
     (loginAccount match {
       // for Administrators
-      case Some(x) if(x.isAdmin) => Repositories
+      case Some(x) if(x.administrator) => Repositories
       // for Normal Users
-      case Some(x) if(!x.isAdmin) =>
+      case Some(x) if(!x.administrator) =>
         Repositories filter { t => (t.isPrivate === false.bind) || (t.userName === x.userName) ||
           (Collaborators.filter { t2 => t2.byRepository(t.userName, t.repositoryName) && (t2.collaboratorName === x.userName.bind)} exists)
         }
@@ -297,8 +297,8 @@ trait RepositoryService { self: AccountService =>
   }
 
   private def getRepositoryManagers(userName: String)(implicit s: Session): Seq[String] =
-    if(getAccountByUserName(userName).exists(_.isGroupAccount)){
-      getGroupMembers(userName).collect { case x if(x.isManager) => x.userName }
+    if(getAccountByUserName(userName).exists(_.groupAccount)){
+      getGroupMembers(userName).collect { case x if(x.manager) => x.userName }
     } else {
       Seq(userName)
     }
@@ -365,7 +365,7 @@ trait RepositoryService { self: AccountService =>
 
   def hasWritePermission(owner: String, repository: String, loginAccount: Option[Account])(implicit s: Session): Boolean = {
     loginAccount match {
-      case Some(a) if(a.isAdmin) => true
+      case Some(a) if(a.administrator) => true
       case Some(a) if(a.userName == owner) => true
       case Some(a) if(getCollaborators(owner, repository).contains(a.userName)) => true
       case _ => false
@@ -417,7 +417,9 @@ object RepositoryService {
   def httpUrl(owner: String, name: String)(implicit context: Context): String = s"${context.baseUrl}/git/${owner}/${name}.git"
   def sshUrl(owner: String, name: String)(implicit context: Context): Option[String] =
     if(context.settings.ssh){
-      context.settings.sshAddress.map { x => s"ssh://${x.genericUser}@${x.host}:${x.port}/${owner}/${name}.git" }
+      context.loginAccount.flatMap { loginAccount =>
+        context.settings.sshAddress.map { x => s"ssh://${loginAccount.userName}@${x.host}:${x.port}/${owner}/${name}.git" }
+      }
     } else None
   def openRepoUrl(openUrl: String)(implicit context: Context): String = s"github-${context.platform}://openRepo/${openUrl}"
 

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

@@ -12,9 +12,6 @@ trait SshKeyService {
   def getPublicKeys(userName: String)(implicit s: Session): List[SshKey] =
     SshKeys.filter(_.userName === userName.bind).sortBy(_.sshKeyId).list
 
-  def getAllKeys()(implicit s: Session): List[SshKey] =
-    SshKeys.filter(_.publicKey.trim =!= "").list
-
   def deletePublicKey(userName: String, sshKeyId: Int)(implicit s: Session): Unit =
     SshKeys filter (_.byPrimaryKey(userName, sshKeyId)) delete
 

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

@@ -141,11 +141,7 @@ object SystemSettingsService {
       for {
         host <- sshHost if ssh
       }
-      yield SshAddress(
-        host,
-        sshPort.getOrElse(DefaultSshPort),
-        "git"
-      )
+      yield SshAddress(host, sshPort.getOrElse(DefaultSshPort))
   }
 
   case class Ldap(
@@ -173,8 +169,7 @@ object SystemSettingsService {
 
   case class SshAddress(
     host:String,
-    port:Int,
-    genericUser:String)
+    port:Int)
 
   val DefaultSshPort = 29418
   val DefaultSmtpPort = 25

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

@@ -1,6 +1,7 @@
 package gitbucket.core.service
 
 import java.io.ByteArrayInputStream
+
 import fr.brouillard.oss.security.xhub.XHub
 import fr.brouillard.oss.security.xhub.XHub.{XHubDigest, XHubConverter}
 import gitbucket.core.api._
@@ -11,6 +12,7 @@ import profile.simple._
 import gitbucket.core.util.JGitUtil.CommitInfo
 import gitbucket.core.util.RepositoryName
 import gitbucket.core.service.RepositoryService.RepositoryInfo
+
 import org.apache.http.NameValuePair
 import org.apache.http.client.entity.UrlEncodedFormEntity
 import org.apache.http.message.BasicNameValuePair
@@ -20,8 +22,6 @@ import org.slf4j.LoggerFactory
 import scala.concurrent._
 import org.apache.http.HttpRequest
 import org.apache.http.HttpResponse
-import gitbucket.core.model.WebHookContentType
-import org.apache.http.client.entity.EntityBuilder
 
 
 trait WebHookService {
@@ -52,15 +52,15 @@ trait WebHookService {
       .map{ case (w,t) => w -> t.event }
       .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 insert WebHook(owner, repository, url, ctype, token)
+  def addWebHook(owner: String, repository: String, url :String, events: Set[WebHook.Event], token: Option[String])(implicit s: Session): Unit = {
+    WebHooks insert WebHook(owner, repository, url, token)
     events.toSet.map{ event: WebHook.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)).update((ctype, token))
+  def updateWebHook(owner: String, repository: String, url :String, events: Set[WebHook.Event], token: Option[String])(implicit s: Session): Unit = {
+    WebHooks.filter(_.byPrimaryKey(owner, repository, url)).map(w => w.token).update(token)
     WebHookEvents.filter(_.byWebHook(owner, repository, url)).delete
     events.toSet.map{ event: WebHook.Event =>
       WebHookEvents insert WebHookEvent(owner, repository, url, event)
@@ -97,32 +97,22 @@ trait WebHookService {
             }
           }
           try{
-            val httpClient = HttpClientBuilder.create.useSystemProperties.addInterceptorLast(itcp).build
+            val httpClient = HttpClientBuilder.create.addInterceptorLast(itcp).build
             logger.debug(s"start web hook invocation for ${webHook.url}")
             val httpPost = new HttpPost(webHook.url)
-            logger.info(s"Content-Type: ${webHook.ctype.ctype}")
-            httpPost.addHeader("Content-Type", webHook.ctype.ctype)
+            httpPost.addHeader("Content-Type", "application/x-www-form-urlencoded")
             httpPost.addHeader("X-Github-Event", event.name)
             httpPost.addHeader("X-Github-Delivery", java.util.UUID.randomUUID().toString)
 
-            webHook.ctype match {
-              case WebHookContentType.FORM => {
-            	  val params: java.util.List[NameValuePair] = new java.util.ArrayList()
-                params.add(new BasicNameValuePair("payload", json))
-                def postContent = new UrlEncodedFormEntity(params, "UTF-8")
-                httpPost.setEntity(postContent)
-                if (webHook.token.exists(_.trim.nonEmpty)) {
-                  // TODO find a better way and see how to extract content from postContent
-                  val contentAsBytes = URLEncodedUtils.format(params, "UTF-8").getBytes("UTF-8")
-                  httpPost.addHeader("X-Hub-Signature", XHub.generateHeaderXHubToken(XHubConverter.HEXA_LOWERCASE, XHubDigest.SHA1, webHook.token.get, contentAsBytes))
-                }
-              }
-              case WebHookContentType.JSON => {
-            	  httpPost.setEntity(EntityBuilder.create().setText(json).build())
-                if (!webHook.token.isEmpty) {
-                  httpPost.addHeader("X-Hub-Signature", XHub.generateHeaderXHubToken(XHubConverter.HEXA_LOWERCASE, XHubDigest.SHA1, webHook.token.orNull, json.getBytes("UTF-8")))
-                }
-              }
+            val params: java.util.List[NameValuePair] = new java.util.ArrayList()
+            params.add(new BasicNameValuePair("payload", json))
+            def postContent = new UrlEncodedFormEntity(params, "UTF-8")
+            httpPost.setEntity(postContent)
+
+            if (!webHook.token.isEmpty) {
+              // TODO find a better way and see how to extract content from postContent
+              val contentAsBytes = URLEncodedUtils.format(params, "UTF-8").getBytes("UTF-8")
+              httpPost.addHeader("X-Hub-Signature", XHub.generateHeaderXHubToken(XHubConverter.HEXA_LOWERCASE, XHubDigest.SHA1, webHook.token.orNull, contentAsBytes))
             }
 
             val res = httpClient.execute(httpPost)

src/main/scala/gitbucket/core/servlet/AutoUpdate.scala

@@ -0,0 +1,186 @@
+package gitbucket.core.servlet
+
+import java.io.File
+import java.sql.{DriverManager, Connection}
+import gitbucket.core.plugin.PluginRegistry
+import gitbucket.core.service.SystemSettingsService
+import gitbucket.core.util._
+import org.apache.commons.io.FileUtils
+import javax.servlet.{ServletContextListener, ServletContextEvent}
+import org.slf4j.LoggerFactory
+import Directory._
+import ControlUtil._
+import JDBCUtil._
+import org.eclipse.jgit.api.Git
+import gitbucket.core.util.Versions
+import gitbucket.core.util.Directory
+
+object AutoUpdate {
+
+  /**
+   * The history of versions. A head of this sequence is the current GitBucket version.
+   */
+  val versions = Seq(
+    new Version(3, 13),
+    new Version(3, 12),
+    new Version(3, 11),
+    new Version(3, 10),
+    new Version(3, 9),
+    new Version(3, 8),
+    new Version(3, 7) with SystemSettingsService {
+      override def update(conn: Connection, cl: ClassLoader): Unit = {
+        super.update(conn, cl)
+        val settings = loadSystemSettings()
+        if(settings.notification){
+          saveSystemSettings(settings.copy(useSMTP = true))
+        }
+      }
+    },
+    new Version(3, 6),
+    new Version(3, 5),
+    new Version(3, 4),
+    new Version(3, 3),
+    new Version(3, 2),
+    new Version(3, 1),
+    new Version(3, 0),
+    new Version(2, 8),
+    new Version(2, 7) {
+      override def update(conn: Connection, cl: ClassLoader): Unit = {
+        super.update(conn, cl)
+        conn.select("SELECT * FROM REPOSITORY"){ rs =>
+          // Rename attached files directory from /issues to /comments
+          val userName = rs.getString("USER_NAME")
+          val repoName = rs.getString("REPOSITORY_NAME")
+          defining(Directory.getAttachedDir(userName, repoName)){ newDir =>
+            val oldDir = new File(newDir.getParentFile, "issues")
+            if(oldDir.exists && oldDir.isDirectory){
+              oldDir.renameTo(newDir)
+            }
+          }
+          // Update ORIGIN_USER_NAME and ORIGIN_REPOSITORY_NAME if it does not exist
+          val originalUserName = rs.getString("ORIGIN_USER_NAME")
+          val originalRepoName = rs.getString("ORIGIN_REPOSITORY_NAME")
+          if(originalUserName != null && originalRepoName != null){
+            if(conn.selectInt("SELECT COUNT(*) FROM REPOSITORY WHERE USER_NAME = ? AND REPOSITORY_NAME = ?",
+              originalUserName, originalRepoName) == 0){
+              conn.update("UPDATE REPOSITORY SET ORIGIN_USER_NAME = NULL, ORIGIN_REPOSITORY_NAME = NULL " +
+                "WHERE USER_NAME = ? AND REPOSITORY_NAME = ?", userName, repoName)
+            }
+          }
+          // Update PARENT_USER_NAME and PARENT_REPOSITORY_NAME if it does not exist
+          val parentUserName = rs.getString("PARENT_USER_NAME")
+          val parentRepoName = rs.getString("PARENT_REPOSITORY_NAME")
+          if(parentUserName != null && parentRepoName != null){
+            if(conn.selectInt("SELECT COUNT(*) FROM REPOSITORY WHERE USER_NAME = ? AND REPOSITORY_NAME = ?",
+              parentUserName, parentRepoName) == 0){
+              conn.update("UPDATE REPOSITORY SET PARENT_USER_NAME = NULL, PARENT_REPOSITORY_NAME = NULL " +
+                "WHERE USER_NAME = ? AND REPOSITORY_NAME = ?", userName, repoName)
+            }
+          }
+        }
+      }
+    },
+    new Version(2, 6),
+    new Version(2, 5),
+    new Version(2, 4),
+    new Version(2, 3) {
+      override def update(conn: Connection, cl: ClassLoader): Unit = {
+        super.update(conn, cl)
+        conn.select("SELECT ACTIVITY_ID, ADDITIONAL_INFO FROM ACTIVITY WHERE ACTIVITY_TYPE='push'"){ rs =>
+          val curInfo = rs.getString("ADDITIONAL_INFO")
+          val newInfo = curInfo.split("\n").filter(_ matches "^[0-9a-z]{40}:.*").mkString("\n")
+          if (curInfo != newInfo) {
+            conn.update("UPDATE ACTIVITY SET ADDITIONAL_INFO = ? WHERE ACTIVITY_ID = ?", newInfo, rs.getInt("ACTIVITY_ID"))
+          }
+        }
+        ignore {
+          FileUtils.deleteDirectory(Directory.getPluginCacheDir())
+          //FileUtils.deleteDirectory(new File(Directory.PluginHome))
+        }
+      }
+    },
+    new Version(2, 2),
+    new Version(2, 1),
+    new Version(2, 0){
+      override def update(conn: Connection, cl: ClassLoader): Unit = {
+        import eu.medsea.mimeutil.{MimeUtil2, MimeType}
+
+        val mimeUtil = new MimeUtil2()
+        mimeUtil.registerMimeDetector("eu.medsea.mimeutil.detector.MagicMimeMimeDetector")
+
+        super.update(conn, cl)
+        conn.select("SELECT USER_NAME, REPOSITORY_NAME FROM REPOSITORY"){ rs =>
+          defining(Directory.getAttachedDir(rs.getString("USER_NAME"), rs.getString("REPOSITORY_NAME"))){ dir =>
+            if(dir.exists && dir.isDirectory){
+              dir.listFiles.foreach { file =>
+                if(file.getName.indexOf('.') < 0){
+                  val mimeType = MimeUtil2.getMostSpecificMimeType(mimeUtil.getMimeTypes(file, new MimeType("application/octet-stream"))).toString
+                  if(mimeType.startsWith("image/")){
+                    file.renameTo(new File(file.getParent, file.getName + "." + mimeType.split("/")(1)))
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    Version(1, 13),
+    Version(1, 12),
+    Version(1, 11),
+    Version(1, 10),
+    Version(1, 9),
+    Version(1, 8),
+    Version(1, 7),
+    Version(1, 6),
+    Version(1, 5),
+    Version(1, 4),
+    new Version(1, 3){
+      override def update(conn: Connection, cl: ClassLoader): Unit = {
+        super.update(conn, cl)
+        // Fix wiki repository configuration
+        conn.select("SELECT USER_NAME, REPOSITORY_NAME FROM REPOSITORY"){ rs =>
+          using(Git.open(getWikiRepositoryDir(rs.getString("USER_NAME"), rs.getString("REPOSITORY_NAME")))){ git =>
+            defining(git.getRepository.getConfig){ config =>
+              if(!config.getBoolean("http", "receivepack", false)){
+                config.setBoolean("http", null, "receivepack", true)
+                config.save
+              }
+            }
+          }
+        }
+      }
+    },
+    Version(1, 2),
+    Version(1, 1),
+    Version(1, 0),
+    Version(0, 0)
+  )
+
+  /**
+   * The head version of GitBucket.
+   */
+  val headVersion = versions.head
+
+  /**
+   * The version file (GITBUCKET_HOME/version).
+   */
+  lazy val versionFile = new File(GitBucketHome, "version")
+
+  /**
+   * Returns the current version from the version file.
+   */
+  def getCurrentVersion(): Version = {
+    if(versionFile.exists){
+      FileUtils.readFileToString(versionFile, "UTF-8").trim.split("\\.") match {
+        case Array(majorVersion, minorVersion) => {
+          versions.find { v =>
+            v.majorVersion == majorVersion.toInt && v.minorVersion == minorVersion.toInt
+          }.getOrElse(Version(0, 0))
+        }
+        case _ => Version(0, 0)
+      }
+    } else Version(0, 0)
+  }
+
+}

src/main/scala/gitbucket/core/servlet/BasicAuthenticationFilter.scala

@@ -76,14 +76,14 @@ class BasicAuthenticationFilter extends Filter with RepositoryService with Accou
       case Array(_, repositoryOwner, repositoryName, _*) =>
         getRepository(repositoryOwner, repositoryName.replaceFirst("\\.wiki\\.git$|\\.git$", "")) match {
           case Some(repository) => {
-            if(!isUpdating && !repository.repository.isPrivate && settings.allowAnonymousAccess){
+            if(!isUpdating && !repository.repository.`private` && settings.allowAnonymousAccess){
               chain.doFilter(request, response)
             } else {
               val passed = for {
                 auth <- Option(request.getHeader("Authorization"))
                 Array(username, password) = decodeAuthHeader(auth).split(":", 2)
                 account <- authenticate(settings, username, password)
-              } yield if(isUpdating || repository.repository.isPrivate){
+              } yield if(isUpdating || repository.repository.`private`){
                   if(hasWritePermission(repository.owner, repository.name, Some(account))){
                     request.setAttribute(Keys.Request.UserName, account.userName)
                     true

src/main/scala/gitbucket/core/servlet/InitializeListener.scala

@@ -1,22 +1,16 @@
 package gitbucket.core.servlet
 
-import java.io.File
-
 import akka.event.Logging
 import com.typesafe.config.ConfigFactory
-import gitbucket.core.GitBucketCoreModule
 import gitbucket.core.plugin.PluginRegistry
 import gitbucket.core.service.{ActivityService, SystemSettingsService}
-import gitbucket.core.util.DatabaseConfig
-import gitbucket.core.util.Directory._
-import gitbucket.core.util.JDBCUtil._
-import io.github.gitbucket.solidbase.Solidbase
-import io.github.gitbucket.solidbase.manager.JDBCVersionManager
-import javax.servlet.{ServletContextListener, ServletContextEvent}
 import org.apache.commons.io.FileUtils
+import javax.servlet.{ServletContextListener, ServletContextEvent}
 import org.slf4j.LoggerFactory
+import gitbucket.core.util.Versions
 import akka.actor.{Actor, Props, ActorSystem}
 import com.typesafe.akka.extension.quartz.QuartzSchedulerExtension
+import AutoUpdate._
 
 /**
  * Initialize GitBucket system.
@@ -36,49 +30,14 @@ class InitializeListener extends ServletContextListener with SystemSettingsServi
     Database() withTransaction { session =>
       val conn = session.conn
 
-      // Check version
-      val versionFile = new File(GitBucketHome, "version")
-
-      if(versionFile.exists()){
-        val version = FileUtils.readFileToString(versionFile, "UTF-8")
-        if(version == "3.14"){
-          // Initialization for GitBucket 3.14
-          logger.info("Migration to GitBucket 4.x start")
-
-          // Backup current data
-          val dataMvFile = new File(GitBucketHome, "data.mv.db")
-          if(dataMvFile.exists) {
-            FileUtils.copyFile(dataMvFile, new File(GitBucketHome, "data.mv.db_3.14"))
-          }
-          val dataTraceFile = new File(GitBucketHome, "data.trace.db")
-          if(dataTraceFile.exists) {
-            FileUtils.copyFile(dataTraceFile, new File(GitBucketHome, "data.trace.db_3.14"))
-          }
-
-          // Change form
-          val manager = new JDBCVersionManager(conn)
-          manager.initialize()
-          manager.updateVersion(GitBucketCoreModule.getModuleId, "4.0")
-          conn.select("SELECT PLUGIN_ID, VERSION FROM PLUGIN"){ rs =>
-            manager.updateVersion(rs.getString("PLUGIN_ID"), rs.getString("VERSION"))
-          }
-          conn.update("DROP TABLE PLUGIN")
-          versionFile.delete()
-
-          logger.info("Migration to GitBucket 4.x completed")
-
-        } else {
-          throw new Exception("GitBucket can't migrate from this version. Please update to 3.14 at first.")
-        }
+      // Migration
+      logger.debug("Start schema update")
+      Versions.update(conn, headVersion, getCurrentVersion(), versions, Thread.currentThread.getContextClassLoader){ conn =>
+        FileUtils.writeStringToFile(versionFile, headVersion.versionString, "UTF-8")
       }
 
-      // Run normal migration
-      logger.info("Start schema update")
-      val solidbase = new Solidbase()
-      solidbase.migrate(conn, Thread.currentThread.getContextClassLoader, DatabaseConfig.liquiDriver, GitBucketCoreModule)
-
       // Load plugins
-      logger.info("Initialize plugins")
+      logger.debug("Initialize plugins")
       PluginRegistry.initialize(event.getServletContext, loadSystemSettings(), conn)
     }
 

src/main/scala/gitbucket/core/servlet/TransactionFilter.scala

@@ -2,12 +2,16 @@ package gitbucket.core.servlet
 
 import javax.servlet._
 import javax.servlet.http.HttpServletRequest
-import com.zaxxer.hikari._
+import com.mchange.v2.c3p0.ComboPooledDataSource
 import gitbucket.core.util.DatabaseConfig
+import io.getquill._
+import io.getquill.naming.SnakeCase
+import io.getquill.sources.sql.idiom.H2Dialect
 import org.scalatra.ScalatraBase
 import org.slf4j.LoggerFactory
 import slick.jdbc.JdbcBackend.{Database => SlickDatabase, Session}
 import gitbucket.core.util.Keys
+import Database._
 
 /**
  * Controls the transaction with the open session in view pattern.
@@ -25,17 +29,20 @@ class TransactionFilter extends Filter {
       // assets don't need transaction
       chain.doFilter(req, res)
     } else {
-      Database() withTransaction { session =>
-        // Register Scalatra error callback to rollback transaction
-        ScalatraBase.onFailure { _ =>
-          logger.debug("Rolled back transaction")
-          session.rollback()
-        }(req.asInstanceOf[HttpServletRequest])
+      db.transaction {
+        // TODO Delete after moving to quill
+        Database() withTransaction { session =>
+          // Register Scalatra error callback to rollback transaction
+          ScalatraBase.onFailure { _ =>
+            logger.debug("Rolled back transaction")
+            session.rollback()
+          }(req.asInstanceOf[HttpServletRequest])
 
-        logger.debug("begin transaction")
-        req.setAttribute(Keys.Request.DBSession, session)
-        chain.doFilter(req, res)
-        logger.debug("end transaction")
+          logger.debug("begin transaction")
+          req.setAttribute(Keys.Request.DBSession, session)
+          chain.doFilter(req, res)
+          logger.debug("end transaction")
+        }
       }
     }
   }
@@ -46,25 +53,32 @@ object Database {
 
   private val logger = LoggerFactory.getLogger(Database.getClass)
 
-  private val dataSource: HikariDataSource = {
-    val config = new HikariConfig()
-    config.setDriverClassName(DatabaseConfig.jdbcDriver)
-    config.setJdbcUrl(DatabaseConfig.url)
-    config.setUsername(DatabaseConfig.user)
-    config.setPassword(DatabaseConfig.password)
+  lazy val db = source(new JdbcSourceConfig[H2Dialect, SnakeCase]("db"))
+
+  // TODO Delete after moving to quill
+  private val dataSource: ComboPooledDataSource = {
+    val ds = new ComboPooledDataSource
+    ds.setDriverClass(DatabaseConfig.driver)
+    ds.setJdbcUrl(DatabaseConfig.url)
+    ds.setUser(DatabaseConfig.user)
+    ds.setPassword(DatabaseConfig.password)
     logger.debug("load database connection pool")
-    new HikariDataSource(config)
+    ds
   }
 
-  private val db: SlickDatabase = {
+  // TODO Delete after moving to quill
+  private val slickDatabase: SlickDatabase = {
     SlickDatabase.forDataSource(dataSource)
   }
 
-  def apply(): SlickDatabase = db
+  // TODO Delete after moving to quill
+  def apply(): SlickDatabase = slickDatabase
 
+  // TODO Delete after moving to quill
   def getSession(req: ServletRequest): Session =
     req.getAttribute(Keys.Request.DBSession).asInstanceOf[Session]
 
+  // TODO Delete after moving to quill
   def closeDataSource(): Unit = dataSource.close
 
 }

src/main/scala/gitbucket/core/ssh/GitCommand.scala

@@ -5,8 +5,7 @@ import gitbucket.core.plugin.{GitRepositoryRouting, PluginRegistry}
 import gitbucket.core.service.{RepositoryService, AccountService, SystemSettingsService}
 import gitbucket.core.servlet.{Database, CommitLogHook}
 import gitbucket.core.util.{Directory, ControlUtil}
-import org.apache.sshd.server.{CommandFactory, Environment, ExitCallback, Command, SessionAware}
-import org.apache.sshd.server.session.ServerSession
+import org.apache.sshd.server.{CommandFactory, Environment, ExitCallback, Command}
 import org.slf4j.LoggerFactory
 import java.io.{File, InputStream, OutputStream}
 import ControlUtil._
@@ -21,44 +20,37 @@ object GitCommand {
   val SimpleCommandRegex  = """\Agit-(upload|receive)-pack '/(.+\.git)'\Z""".r
 }
 
-abstract class GitCommand extends Command with SessionAware {
+abstract class GitCommand() extends Command {
 
   private val logger = LoggerFactory.getLogger(classOf[GitCommand])
   @volatile protected var err: OutputStream = null
   @volatile protected var in: InputStream = null
   @volatile protected var out: OutputStream = null
   @volatile protected var callback: ExitCallback = null
-  @volatile private var authUser:Option[String] = None
 
-  protected def runTask(authUser: String)(implicit session: Session): Unit
+  protected def runTask(user: String)(implicit session: Session): Unit
 
-  private def newTask(): Runnable = new Runnable {
+  private def newTask(user: String): Runnable = new Runnable {
     override def run(): Unit = {
-      authUser match {
-        case Some(authUser) =>
-          Database() withSession { implicit session =>
-            try {
-              runTask(authUser)
-              callback.onExit(0)
-            } catch {
-              case e: RepositoryNotFoundException =>
-                logger.info(e.getMessage)
-                callback.onExit(1, "Repository Not Found")
-              case e: Throwable =>
-                logger.error(e.getMessage, e)
-                callback.onExit(1)
-            }
-          }
-        case None =>
-          val message = "User not authenticated"
-          logger.error(message)
-          callback.onExit(1, message)
+      Database() withSession { implicit session =>
+        try {
+          runTask(user)
+          callback.onExit(0)
+        } catch {
+          case e: RepositoryNotFoundException =>
+            logger.info(e.getMessage)
+            callback.onExit(1, "Repository Not Found")
+          case e: Throwable =>
+            logger.error(e.getMessage, e)
+            callback.onExit(1)
+        }
       }
     }
   }
 
-  final override def start(env: Environment): Unit = {
-    val thread = new Thread(newTask())
+  override def start(env: Environment): Unit = {
+    val user = env.getEnv.get("USER")
+    val thread = new Thread(newTask(user))
     thread.start()
   }
 
@@ -80,10 +72,6 @@ abstract class GitCommand extends Command with SessionAware {
     this.in = in
   }
 
-  override def setSession(serverSession:ServerSession) {
-  	this.authUser = PublicKeyAuthenticator.getUserName(serverSession)
-  }
-
 }
 
 abstract class DefaultGitCommand(val owner: String, val repoName: String) extends GitCommand {
@@ -104,7 +92,7 @@ class DefaultGitUploadPack(owner: String, repoName: String) extends DefaultGitCo
 
   override protected def runTask(user: String)(implicit session: Session): Unit = {
     getRepository(owner, repoName.replaceFirst("\\.wiki\\Z", "")).foreach { repositoryInfo =>
-      if(!repositoryInfo.repository.isPrivate || isWritableUser(user, repositoryInfo)){
+      if(!repositoryInfo.repository.`private` || isWritableUser(user, repositoryInfo)){
         using(Git.open(getRepositoryDir(owner, repoName))) { git =>
           val repository = git.getRepository
           val upload = new UploadPack(repository)

src/main/scala/gitbucket/core/ssh/NoShell.scala

@@ -15,6 +15,7 @@ class NoShell(sshAddress:SshAddress) extends Factory[Command] {
     private var callback: ExitCallback = null
 
     override def start(env: Environment): Unit = {
+      val user = env.getEnv.get("USER")
       val message =
         """
           | Welcome to
@@ -31,7 +32,7 @@ class NoShell(sshAddress:SshAddress) extends Factory[Command] {
           | Please use:
           |
           | git clone ssh://%s@%s:%d/OWNER/REPOSITORY_NAME.git
-        """.stripMargin.format(sshAddress.genericUser, sshAddress.host, sshAddress.port).replace("\n", "\r\n") + "\r\n"
+        """.stripMargin.format(user, sshAddress.host, sshAddress.port).replace("\n", "\r\n") + "\r\n"
       err.write(Constants.encode(message))
       err.flush()
       in.close()

src/main/scala/gitbucket/core/ssh/PublicKeyAuthenticator.scala

@@ -2,73 +2,22 @@ package gitbucket.core.ssh
 
 import java.security.PublicKey
 
-import gitbucket.core.model.SshKey
 import gitbucket.core.service.SshKeyService
 import gitbucket.core.servlet.Database
 import org.apache.sshd.server.auth.pubkey.PublickeyAuthenticator
 import org.apache.sshd.server.session.ServerSession
-import org.apache.sshd.common.session.Session
-import org.slf4j.LoggerFactory
 
-object PublicKeyAuthenticator {
-  // put in the ServerSession here to be read by GitCommand later
-  private val userNameSessionKey = new Session.AttributeKey[String]
+class PublicKeyAuthenticator extends PublickeyAuthenticator with SshKeyService {
 
-  def putUserName(serverSession:ServerSession, userName:String):Unit =
-    serverSession.setAttribute(userNameSessionKey, userName)
-
-  def getUserName(serverSession:ServerSession):Option[String] =
-    Option(serverSession.getAttribute(userNameSessionKey))
-}
-
-class PublicKeyAuthenticator(genericUser:String) extends PublickeyAuthenticator with SshKeyService {
-  private val logger = LoggerFactory.getLogger(classOf[PublicKeyAuthenticator])
-
-  override def authenticate(username: String, key: PublicKey, session: ServerSession): Boolean =
-    if (username == genericUser) authenticateGenericUser(username, key, session, genericUser)
-    else                         authenticateLoginUser(username, key, session)
-
-  private def authenticateLoginUser(username: String, key: PublicKey, session: ServerSession): Boolean = {
-    val authenticated =
-      Database()
-      .withSession { implicit dbSession => getPublicKeys(username) }
-      .map(_.publicKey)
-      .flatMap(SshUtil.str2PublicKey)
-      .contains(key)
-    if (authenticated) {
-      logger.info(s"authentication as ssh user ${username} succeeded")
-      PublicKeyAuthenticator.putUserName(session, username)
+  override def authenticate(username: String, key: PublicKey, session: ServerSession): Boolean = {
+    Database() withSession { implicit session =>
+      getPublicKeys(username).exists { sshKey =>
+        SshUtil.str2PublicKey(sshKey.publicKey) match {
+          case Some(publicKey) => key.equals(publicKey)
+          case _ => false
+        }
+      }
     }
-    else {
-      logger.info(s"authentication as ssh user ${username} failed")
-    }
-    authenticated
   }
 
-  private def authenticateGenericUser(username: String, key: PublicKey, session: ServerSession, genericUser:String): Boolean = {
-    // find all users having the key we got from ssh
-    val possibleUserNames =
-      Database()
-      .withSession { implicit dbSession => getAllKeys() }
-      .filter { sshKey =>
-        SshUtil.str2PublicKey(sshKey.publicKey).exists(_ == key)
-      }
-      .map(_.userName)
-      .distinct
-    // determine the user - if different accounts share the same key, tough luck
-    val uniqueUserName =
-      possibleUserNames match {
-        case List()     =>
-          logger.info(s"authentication as generic user ${genericUser} failed, public key not found")
-          None
-        case List(name) =>
-          logger.info(s"authentication as generic user ${genericUser} succeeded, identified ${name}")
-          Some(name)
-        case _          =>
-          logger.info(s"authentication as generic user ${genericUser} failed, public key is ambiguous")
-          None
-      }
-    uniqueUserName.foreach(PublicKeyAuthenticator.putUserName(session, _))
-    uniqueUserName.isDefined
-  }
 }

src/main/scala/gitbucket/core/ssh/SshServerListener.scala

@@ -21,7 +21,7 @@ object SshServer {
     provider.setAlgorithm("RSA")
     provider.setOverwriteAllowed(false)
     server.setKeyPairProvider(provider)
-    server.setPublickeyAuthenticator(new PublicKeyAuthenticator(sshAddress.genericUser))
+    server.setPublickeyAuthenticator(new PublicKeyAuthenticator)
     server.setCommandFactory(new GitCommandFactory(baseUrl))
     server.setShellFactory(new NoShell(sshAddress))
   }

src/main/scala/gitbucket/core/ssh/SshUtil.scala

@@ -31,7 +31,9 @@ object SshUtil {
     }
   }
 
-  def fingerPrint(key: String): Option[String] =
-    str2PublicKey(key) map KeyUtils.getFingerPrint
+  def fingerPrint(key: String): Option[String] = str2PublicKey(key) match {
+    case Some(publicKey) => Some(KeyUtils.getFingerPrint(publicKey))
+    case None => None
+  }
 
 }

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

@@ -17,7 +17,7 @@ trait OneselfAuthenticator { self: ControllerBase =>
     {
       defining(request.paths){ paths =>
         context.loginAccount match {
-          case Some(x) if(x.isAdmin) => action
+          case Some(x) if(x.administrator) => action
           case Some(x) if(paths(0) == x.userName) => action
           case _ => Unauthorized()
         }
@@ -38,10 +38,10 @@ trait OwnerAuthenticator { self: ControllerBase with RepositoryService with Acco
       defining(request.paths){ paths =>
         getRepository(paths(0), paths(1)).map { repository =>
           context.loginAccount match {
-            case Some(x) if(x.isAdmin) => action(repository)
+            case Some(x) if(x.administrator) => action(repository)
             case Some(x) if(repository.owner == x.userName) => action(repository)
             case Some(x) if(getGroupMembers(repository.owner).exists { member =>
-              member.userName == x.userName && member.isManager == true
+              member.userName == x.userName && member.manager == true
             }) => action(repository)
             case _ => Unauthorized()
           }
@@ -78,7 +78,7 @@ trait AdminAuthenticator { self: ControllerBase =>
   private def authenticate(action: => Any) = {
     {
       context.loginAccount match {
-        case Some(x) if(x.isAdmin) => action
+        case Some(x) if(x.administrator) => action
         case _ => Unauthorized()
       }
     }
@@ -97,7 +97,7 @@ trait CollaboratorsAuthenticator { self: ControllerBase with RepositoryService =
       defining(request.paths){ paths =>
         getRepository(paths(0), paths(1)).map { repository =>
           context.loginAccount match {
-            case Some(x) if(x.isAdmin) => action(repository)
+            case Some(x) if(x.administrator) => action(repository)
             case Some(x) if(paths(0) == x.userName) => action(repository)
             case Some(x) if(getCollaborators(paths(0), paths(1)).contains(x.userName)) => action(repository)
             case _ => Unauthorized()
@@ -119,11 +119,11 @@ trait ReferrerAuthenticator { self: ControllerBase with RepositoryService =>
     {
       defining(request.paths){ paths =>
         getRepository(paths(0), paths(1)).map { repository =>
-          if(!repository.repository.isPrivate){
+          if(!repository.repository.`private`){
             action(repository)
           } else {
             context.loginAccount match {
-              case Some(x) if(x.isAdmin) => action(repository)
+              case Some(x) if(x.administrator) => action(repository)
               case Some(x) if(paths(0) == x.userName) => action(repository)
               case Some(x) if(getCollaborators(paths(0), paths(1)).contains(x.userName)) => action(repository)
               case _ => Unauthorized()
@@ -147,8 +147,8 @@ trait ReadableUsersAuthenticator { self: ControllerBase with RepositoryService =
       defining(request.paths){ paths =>
         getRepository(paths(0), paths(1)).map { repository =>
           context.loginAccount match {
-            case Some(x) if(x.isAdmin) => action(repository)
-            case Some(x) if(!repository.repository.isPrivate) => action(repository)
+            case Some(x) if(x.administrator) => action(repository)
+            case Some(x) if(!repository.repository.`private`) => action(repository)
             case Some(x) if(paths(0) == x.userName) => action(repository)
             case Some(x) if(getCollaborators(paths(0), paths(1)).contains(x.userName)) => action(repository)
             case _ => Unauthorized()
@@ -171,7 +171,7 @@ trait GroupManagerAuthenticator { self: ControllerBase with AccountService =>
       defining(request.paths){ paths =>
         context.loginAccount match {
           case Some(x) if(getGroupMembers(paths(0)).exists { member =>
-            member.userName == x.userName && member.isManager
+            member.userName == x.userName && member.manager
           }) => action
           case _ => Unauthorized()
         }

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

@@ -1,83 +1,19 @@
 package gitbucket.core.util
 
 import com.typesafe.config.ConfigFactory
-import java.io.File
-import Directory._
-import liquibase.database.AbstractJdbcDatabase
-import liquibase.database.core.{PostgresDatabase, MySQLDatabase, H2Database}
-import org.apache.commons.io.FileUtils
+import Directory.DatabaseHome
 
 object DatabaseConfig {
 
-  private lazy val config = {
-    val file = new File(GitBucketHome, "database.conf")
-    if(!file.exists){
-      FileUtils.write(file,
-        """db {
-          |  url = "jdbc:h2:${DatabaseHome};MVCC=true"
-          |  user = "sa"
-          |  password = "sa"
-          |}
-          |""".stripMargin, "UTF-8")
-    }
-    ConfigFactory.parseFile(file)
-  }
-
-  private lazy val dbUrl = config.getString("db.url")
+  private val config = ConfigFactory.load("database")
+  private val dbUrl = config.getString("db.url")
 
   def url(directory: Option[String]): String =
     dbUrl.replace("${DatabaseHome}", directory.getOrElse(DatabaseHome))
 
-  lazy val url: String = url(None)
-  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: slick.driver.JdbcProfile = DatabaseType(url).slickDriver
-  lazy val liquiDriver: AbstractJdbcDatabase = DatabaseType(url).liquiDriver
+  val url: String = url(None)
+  val user: String = config.getString("db.user")
+  val password: String = config.getString("db.password")
+  val driver: String = config.getString("db.driver")
 
 }
-
-sealed trait DatabaseType {
-  val jdbcDriver: String
-  val slickDriver: slick.driver.JdbcProfile
-  val liquiDriver: AbstractJdbcDatabase
-}
-
-object DatabaseType {
-
-  def apply(url: String): DatabaseType = {
-    if(url.startsWith("jdbc:h2:")){
-      H2
-    } else if(url.startsWith("jdbc:mysql:")){
-      MySQL
-    } else if(url.startsWith("jdbc:postgresql:")){
-      PostgreSQL
-    } else {
-      throw new IllegalArgumentException(s"${url} is not supported.")
-    }
-  }
-
-  object H2 extends DatabaseType {
-    val jdbcDriver = "org.h2.Driver"
-    val slickDriver = slick.driver.H2Driver
-    val liquiDriver = new H2Database()
-  }
-
-  object MySQL extends DatabaseType {
-    val jdbcDriver = "com.mysql.jdbc.Driver"
-    val slickDriver = slick.driver.MySQLDriver
-    val liquiDriver = new MySQLDatabase()
-  }
-
-  object PostgreSQL extends DatabaseType {
-    val jdbcDriver = "org.postgresql.Driver2"
-    val slickDriver = new slick.driver.PostgresDriver {
-      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
-        (s append '"').toString
-      }
-    }
-    val liquiDriver = new PostgresDatabase()
-  }
-}

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

@@ -1,13 +1,7 @@
 package gitbucket.core.util
 
-import java.io._
 import java.sql._
-import java.text.SimpleDateFormat
-import javax.xml.stream.{XMLStreamConstants, XMLInputFactory, XMLOutputFactory}
 import ControlUtil._
-import scala.StringBuilder
-import scala.annotation.tailrec
-import scala.collection.mutable
 import scala.collection.mutable.ListBuffer
 
 /**
@@ -64,265 +58,6 @@ object JDBCUtil {
       }
     }
 
-    def importAsXML(in: InputStream): Unit = {
-      conn.setAutoCommit(false)
-      try {
-        val factory = XMLInputFactory.newInstance()
-        using(factory.createXMLStreamReader(in, "UTF-8")){ reader =>
-          // stateful objects
-          var elementName   = ""
-          var insertTable   = ""
-          var insertColumns = Map.empty[String, (String, String)]
-
-          while(reader.hasNext){
-            reader.next()
-
-            reader.getEventType match {
-              case XMLStreamConstants.START_ELEMENT =>
-                elementName = reader.getName.getLocalPart
-                if(elementName == "insert"){
-                  insertTable = reader.getAttributeValue(null, "table")
-                } else if(elementName == "delete"){
-                  val tableName = reader.getAttributeValue(null, "table")
-                  conn.update(s"DELETE FROM ${tableName}")
-                } else if(elementName == "column"){
-                  val columnName  = reader.getAttributeValue(null, "name")
-                  val columnType  = reader.getAttributeValue(null, "type")
-                  val columnValue = reader.getElementText
-                  insertColumns = insertColumns + (columnName -> (columnType, columnValue))
-                }
-              case XMLStreamConstants.END_ELEMENT =>
-                // Execute insert statement
-                reader.getName.getLocalPart match {
-                  case "insert" => {
-                    val sb = new StringBuilder()
-                    sb.append(s"INSERT INTO ${insertTable} (")
-                    sb.append(insertColumns.map { case (columnName, _) => columnName }.mkString(", "))
-                    sb.append(") VALUES (")
-                    sb.append(insertColumns.map { case (_, (columnType, columnValue)) =>
-                      if(columnType == null || columnValue == null){
-                        "NULL"
-                      } else if(columnType == "string"){
-                        "'" + columnValue.replace("'", "''") + "'"
-                      } else if(columnType == "timestamp"){
-                        "'" + columnValue + "'"
-                      } else {
-                        columnValue.toString
-                      }
-                    }.mkString(", "))
-                    sb.append(")")
-
-                    conn.update(sb.toString)
-
-                    insertColumns = Map.empty[String, (String, String)] // Clear column information
-                  }
-                  case _ => // Nothing to do
-                }
-              case _ => // Nothing to do
-            }
-          }
-        }
-
-        conn.commit()
-
-      } catch {
-        case e: Exception => {
-          conn.rollback()
-          throw e
-        }
-      }
-    }
-
-    def exportAsXML(targetTables: Seq[String]): File = {
-      val dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss")
-      val file = File.createTempFile("gitbucket-export-", ".xml")
-
-      val factory = XMLOutputFactory.newInstance()
-      using(factory.createXMLStreamWriter(new FileOutputStream(file), "UTF-8")){ writer =>
-        val dbMeta = conn.getMetaData
-        val allTablesInDatabase = allTablesOrderByDependencies(dbMeta)
-
-        writer.writeStartDocument("UTF-8", "1.0")
-        writer.writeStartElement("tables")
-
-        println(allTablesInDatabase.mkString(", "))
-
-        allTablesInDatabase.reverse.foreach { tableName =>
-          if (targetTables.contains(tableName)) {
-            writer.writeStartElement("delete")
-            writer.writeAttribute("table", tableName)
-            writer.writeEndElement()
-          }
-        }
-
-        allTablesInDatabase.foreach { tableName =>
-          if (targetTables.contains(tableName)) {
-            select(s"SELECT * FROM ${tableName}") { rs =>
-              writer.writeStartElement("insert")
-              writer.writeAttribute("table", tableName)
-              val rsMeta = rs.getMetaData
-              (1 to rsMeta.getColumnCount).foreach { i =>
-                val columnName = rsMeta.getColumnName(i)
-                val (columnType, columnValue) = if(rs.getObject(columnName) == null){
-                  (null, null)
-                } else {
-                  rsMeta.getColumnType(i) match {
-                    case Types.BOOLEAN | Types.BIT => ("boolean", rs.getBoolean(columnName))
-                    case Types.VARCHAR | Types.CLOB | Types.CHAR | Types.LONGVARCHAR => ("string", rs.getString(columnName))
-                    case Types.INTEGER => ("int", rs.getInt(columnName))
-                    case Types.TIMESTAMP => ("timestamp", dateFormat.format(rs.getTimestamp(columnName)))
-                  }
-                }
-                writer.writeStartElement("column")
-                writer.writeAttribute("name", columnName)
-                if(columnType != null){
-                  writer.writeAttribute("type", columnType)
-                }
-                if(columnValue != null){
-                  writer.writeCharacters(columnValue.toString)
-                }
-                writer.writeEndElement()
-              }
-              writer.writeEndElement()
-            }
-          }
-        }
-
-        writer.writeEndElement()
-        writer.writeEndDocument()
-      }
-
-      file
-    }
-
-    def exportAsSQL(targetTables: Seq[String]): File = {
-      val dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss")
-      val file = File.createTempFile("gitbucket-export-", ".sql")
-
-      using(new FileOutputStream(file)) { out =>
-        val dbMeta = conn.getMetaData
-        val allTablesInDatabase = allTablesOrderByDependencies(dbMeta)
-
-        allTablesInDatabase.reverse.foreach { tableName =>
-          if (targetTables.contains(tableName)) {
-            out.write(s"DELETE FROM ${tableName};\n".getBytes("UTF-8"))
-          }
-        }
-
-        allTablesInDatabase.foreach { tableName =>
-          if (targetTables.contains(tableName)) {
-            val sb = new StringBuilder()
-            select(s"SELECT * FROM ${tableName}") { rs =>
-              sb.append(s"INSERT INTO ${tableName} (")
-
-              val rsMeta = rs.getMetaData
-              val columns = (1 to rsMeta.getColumnCount).map { i =>
-                (rsMeta.getColumnName(i), rsMeta.getColumnType(i))
-              }
-              sb.append(columns.map(_._1).mkString(", "))
-              sb.append(") VALUES (")
-
-              val values = columns.map { case (columnName, columnType) =>
-                if(rs.getObject(columnName) == null){
-                  null
-                } else {
-                  columnType match {
-                    case Types.BOOLEAN | Types.BIT => rs.getBoolean(columnName)
-                    case Types.VARCHAR | Types.CLOB | Types.CHAR | Types.LONGVARCHAR => rs.getString(columnName)
-                    case Types.INTEGER   => rs.getInt(columnName)
-                    case Types.TIMESTAMP => rs.getTimestamp(columnName)
-                  }
-                }
-              }
-
-              val columnValues = values.map { value =>
-                value match {
-                  case x: String    => "'" + x.replace("'", "''") + "'"
-                  case x: Timestamp => "'" + dateFormat.format(x) + "'"
-                  case null         => "NULL"
-                  case x            => x
-                }
-              }
-              sb.append(columnValues.mkString(", "))
-              sb.append(");\n")
-            }
-
-            out.write(sb.toString.getBytes("UTF-8"))
-          }
-        }
-      }
-
-      file
-    }
-
-    def allTableNames(): Seq[String] = {
-      using(conn.getMetaData.getTables(null, null, "%", Seq("TABLE").toArray)) { rs =>
-        val tableNames = new ListBuffer[String]
-        while (rs.next) {
-          val name = rs.getString("TABLE_NAME").toUpperCase
-          if (name != "VERSIONS" && name != "PLUGIN") {
-            tableNames += name
-          }
-        }
-        tableNames.toSeq
-      }
-    }
-
-    private def childTables(meta: DatabaseMetaData, tableName: String): Seq[String] = {
-      val normalizedTableName =
-        if(meta.getDatabaseProductName == "PostgreSQL"){
-          tableName.toLowerCase
-        } else {
-          tableName
-        }
-
-      using(meta.getExportedKeys(null, null, normalizedTableName)) { rs =>
-        val children = new ListBuffer[String]
-        while (rs.next) {
-          val childTableName = rs.getString("FKTABLE_NAME").toUpperCase
-          if(!children.contains(childTableName)){
-            children += childTableName
-            children ++= childTables(meta, childTableName)
-          }
-        }
-        children.distinct.toSeq
-      }
-    }
-
-
-    private def allTablesOrderByDependencies(meta: DatabaseMetaData): Seq[String] = {
-      val tables = allTableNames.map { tableName =>
-        val result = TableDependency(tableName, childTables(meta, tableName))
-        result
-      }
-
-      val edges = tables.flatMap { table =>
-        table.children.map { child => (table.tableName, child) }
-      }
-
-      tsort(edges).toSeq
-    }
-
-    case class TableDependency(tableName: String, children: Seq[String])
-
-
-    def tsort[A](edges: Traversable[(A, A)]): Iterable[A] = {
-      @tailrec
-      def tsort(toPreds: Map[A, Set[A]], done: Iterable[A]): Iterable[A] = {
-        val (noPreds, hasPreds) = toPreds.partition { _._2.isEmpty }
-        if (noPreds.isEmpty) {
-          if (hasPreds.isEmpty) done else sys.error(hasPreds.toString)
-        } else {
-          val found = noPreds.map { _._1 }
-          tsort(hasPreds.mapValues { _ -- found }, done ++ found)
-        }
-      }
-
-      val toPred = edges.foldLeft(Map[A, Set[A]]()) { (acc, e) =>
-        acc + (e._1 -> acc.getOrElse(e._1, Set())) + (e._2 -> (acc.getOrElse(e._2, Set()) + e._1))
-      }
-      tsort(toPred, Seq())
-    }
   }
 
 }

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

@@ -896,13 +896,17 @@ object JGitUtil {
       git.branchList.call.asScala.map { ref =>
         val walk = new RevWalk(repo)
         try {
-          val defaultCommit  = walk.parseCommit(defaultObject)
-          val branchName     = ref.getName.stripPrefix("refs/heads/")
-          val branchCommit   = walk.parseCommit(ref.getObjectId)
-          val when           = branchCommit.getCommitterIdent.getWhen
-          val committer      = branchCommit.getCommitterIdent.getName
+          val defaultCommit = walk.parseCommit(defaultObject)
+          val branchName = ref.getName.stripPrefix("refs/heads/")
+          val branchCommit = if(branchName == defaultBranch){
+            defaultCommit
+          } else {
+            walk.parseCommit(ref.getObjectId)
+          }
+          val when = branchCommit.getCommitterIdent.getWhen
+          val committer = branchCommit.getCommitterIdent.getName
           val committerEmail = branchCommit.getCommitterIdent.getEmailAddress
-          val mergeInfo      = if(origin && branchName == defaultBranch){
+          val mergeInfo = if(origin && branchName == defaultBranch){
             None
           } else {
             walk.reset()

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

@@ -30,7 +30,7 @@ trait Notifier extends RepositoryService with AccountService with IssuesService
     )
     .distinct
     .withFilter ( _ != context.loginAccount.get.userName )  // the operation in person is excluded
-    .foreach ( getAccountByUserName(_) filterNot (_.isGroupAccount) filterNot (LDAPUtil.isDummyMailAddress(_)) foreach (x => notify(x.mailAddress)) )
+    .foreach ( getAccountByUserName(_) filterNot (_.groupAccount) filterNot (LDAPUtil.isDummyMailAddress(_)) foreach (x => notify(x.mailAddress)) )
 
 }
 

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

@@ -1,6 +1,5 @@
 package gitbucket.core.util
 
-// TODO Move to gitbucket.core.api package?
 case class RepositoryName(owner:String, name:String){
   val fullName = s"${owner}/${name}"
 }

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

@@ -0,0 +1,67 @@
+package gitbucket.core.util
+
+import java.sql.Connection
+
+import org.apache.commons.io.IOUtils
+import org.slf4j.LoggerFactory
+import ControlUtil._
+
+case class Version(majorVersion: Int, minorVersion: Int) {
+
+  private val logger = LoggerFactory.getLogger(classOf[Version])
+
+  /**
+   * Execute update/MAJOR_MINOR.sql to update schema to this version.
+   * If corresponding SQL file does not exist, this method do nothing.
+   */
+  def update(conn: Connection, cl: ClassLoader): Unit = {
+    val sqlPath = s"update/${majorVersion}_${minorVersion}.sql"
+
+    using(cl.getResourceAsStream(sqlPath)){ in =>
+      if(in != null){
+        val sql = IOUtils.toString(in, "UTF-8")
+        using(conn.createStatement()){ stmt =>
+          logger.debug(sqlPath + "=" + sql)
+          stmt.executeUpdate(sql)
+        }
+      }
+    }
+  }
+
+
+  /**
+   * MAJOR.MINOR
+   */
+  val versionString = s"${majorVersion}.${minorVersion}"
+
+}
+
+object Versions {
+
+  private val logger = LoggerFactory.getLogger(Versions.getClass)
+
+  def update(conn: Connection, headVersion: Version, currentVersion: Version, versions: Seq[Version], cl: ClassLoader)
+            (save: Connection => Unit): Unit = {
+    logger.debug("Start schema update")
+    try {
+      if(currentVersion == headVersion){
+        logger.debug("No update")
+      } else if(currentVersion.versionString != "0.0" && !versions.contains(currentVersion)){
+        logger.warn(s"Skip migration because ${currentVersion.versionString} is illegal version.")
+      } else {
+        versions.takeWhile(_ != currentVersion).reverse.foreach(_.update(conn, cl))
+        save(conn)
+        logger.debug(s"Updated from ${currentVersion.versionString} to ${headVersion.versionString}")
+      }
+    } catch {
+      case ex: Throwable => {
+        logger.error("Failed to schema update", ex)
+        ex.printStackTrace()
+        conn.rollback()
+      }
+    }
+    logger.debug("End schema update")
+  }
+
+}
+

src/main/twirl/gitbucket/core/account/application.scala.html

@@ -5,51 +5,56 @@
 @import gitbucket.core.view.helpers._
 @html.main("Applications"){
 <div class="container body">
-  @menu("application", settings.ssh){
-    <div class="panel panel-default">
-      <div class="panel-heading strong">Personal access tokens</div>
-      <div class="panel-body">
-        @if(personalTokens.isEmpty && gneratedToken.isEmpty){
-          No tokens.
-        } else {
-          Tokens you have generated that can be used to access the GitBucket API.
-          <hr style="margin-top: 10px;">
-        }
-        @gneratedToken.map{ case (token, tokenString) =>
-          <div class="alert alert-info">
-            Make sure to copy your new personal access token now. You won't be able to see it again!
-          </div>
-          <a href="@path/@account.userName/_personalToken/delete/@token.accessTokenId" class="btn btn-sm btn-danger pull-right">Delete</a>
-          <div style="width: 50%;">
-            @helper.html.copy("generated-token-copy", tokenString){
-              <input type="text" value="@tokenString" class="form-control input-sm" readonly>
-            }
-          </div>
-          <hr style="margin-top: 10px;">
-        }
-        @personalTokens.zipWithIndex.map { case (token, i) =>
-          @if(i != 0){
-            <hr>
-          }
-          <strong style="line-height: 30px;">@token.note</strong>
-          <a href="@path/@account.userName/_personalToken/delete/@token.accessTokenId" class="btn btn-sm btn-danger pull-right">Delete</a>
-        }
-      </div>
+  <div class="row">
+    <div class="col-md-3">
+      @menu("application", settings.ssh)
     </div>
-    <form method="POST" action="@path/@account.userName/_personalToken" validate="true">
+    <div class="col-md-9">
       <div class="panel panel-default">
-        <div class="panel-heading strong">Generate new token</div>
+        <div class="panel-heading strong">Personal access tokens</div>
         <div class="panel-body">
-          <fieldset>
-            <label for="note" class="strong">Token description</label>
-            <div><span id="error-note" class="error"></span></div>
-            <input type="text" name="note" id="note" class="form-control"/>
-            <p class="muted">What's this token for?</p>
-          </fieldset>
-          <input type="submit" class="btn btn-success" value="Generate token"/>
+          @if(personalTokens.isEmpty && gneratedToken.isEmpty){
+            No tokens.
+          } else {
+            Tokens you have generated that can be used to access the GitBucket API.
+            <hr style="margin-top: 10px;">
+          }
+          @gneratedToken.map{ case (token, tokenString) =>
+            <div class="alert alert-info">
+              Make sure to copy your new personal access token now. You won't be able to see it again!
+            </div>
+            <a href="@path/@account.userName/_personalToken/delete/@token.accessTokenId" class="btn btn-sm btn-danger pull-right">Delete</a>
+            <div style="width: 50%;">
+              @helper.html.copy("generated-token-copy", tokenString){
+                <input type="text" value="@tokenString" class="form-control input-sm" readonly>
+              }
+            </div>
+            <hr style="margin-top: 10px;">
+          }
+          @personalTokens.zipWithIndex.map { case (token, i) =>
+            @if(i != 0){
+              <hr style="margin-top: 10px;">
+            }
+            <strong>@token.note</strong>
+            <a href="@path/@account.userName/_personalToken/delete/@token.accessTokenId" class="btn btn-sm btn-danger pull-right">Delete</a>
+          }
         </div>
       </div>
-    </form>
-  }
+      <form method="POST" action="@path/@account.userName/_personalToken" validate="true">
+        <div class="panel panel-default">
+          <div class="panel-heading strong">Generate new token</div>
+          <div class="panel-body">
+            <fieldset>
+              <label for="note" class="strong">Token description</label>
+              <div><span id="error-note" class="error"></span></div>
+              <input type="text" name="note" id="note" class="form-control"/>
+              <p class="muted">What's this token for?</p>
+            </fieldset>
+            <input type="submit" class="btn btn-success" value="Generate token"/>
+          </div>
+        </div>
+      </form>
+    </div>
+  </div>
 </div>
 }

src/main/twirl/gitbucket/core/account/edit.scala.html

@@ -1,14 +1,17 @@
-@(account: gitbucket.core.model.Account, info: Option[Any], error: Option[Any])(implicit context: gitbucket.core.controller.Context)
+@(account: gitbucket.core.model.Account, info: Option[Any])(implicit context: gitbucket.core.controller.Context)
 @import gitbucket.core.util.LDAPUtil
 @import context._
 @import gitbucket.core.view.helpers._
 @html.main("Edit your profile"){
 <div class="container body">
-  @menu("profile", settings.ssh){
-    @helper.html.information(info)
-    @helper.html.error(error)
-    @if(LDAPUtil.isDummyMailAddress(account)){<div class="alert alert-danger">Please register your mail address.</div>}
-    <form action="@url(account.userName)/_edit" method="POST" validate="true">
+  <div class="row">
+    <div class="col-md-3">
+      @menu("profile", settings.ssh)
+    </div>
+    <div class="col-md-9">
+      @helper.html.information(info)
+      @if(LDAPUtil.isDummyMailAddress(account)){<div class="alert alert-danger">Please register your mail address.</div>}
+      <form action="@url(account.userName)/_edit" method="POST" validate="true">
       <div class="panel panel-default">
         <div class="panel-heading strong">Profile</div>
         <div class="panel-body">
@@ -46,17 +49,17 @@
               </fieldset>
             </div>
           </div>
+          <div style="margin-top: 20px;">
+            <div class="pull-right">
+              <a href="@path/@account.userName/_delete" class="btn btn-danger" id="delete">Delete account</a>
+            </div>
+            <input type="submit" class="btn btn-success" value="Save"/>
+            @if(!LDAPUtil.isDummyMailAddress(account)){<a href="@url(account.userName)" class="btn btn-default">Cancel</a>}
+          </div>
         </div>
       </div>
-      <div>
-        <div class="pull-right">
-          <a href="@path/@account.userName/_delete" class="btn btn-danger" id="delete">Delete account</a>
-        </div>
-        <input type="submit" class="btn btn-success" value="Save"/>
-        @if(!LDAPUtil.isDummyMailAddress(account)){<a href="@url(account.userName)" class="btn btn-default">Cancel</a>}
-      </div>
     </form>
-  }
+  </div>
 </div>
 }
 <script>

src/main/twirl/gitbucket/core/account/group.scala.html

@@ -2,7 +2,7 @@
 @import context._
 @import gitbucket.core.view.helpers._
 @html.main(if(account.isEmpty) "Create group" else "Edit group"){
-<div class="body main-center">
+<div class="container body">
   <form id="form" method="post" action="@if(account.isEmpty){@path/groups/new} else {@path/@account.get.userName/_editgroup}" validate="true">
       <div class="row">
         <div class="col-md-5">
@@ -32,7 +32,7 @@
             </ul>
             @helper.html.account("memberName", 200)
             <input type="button" class="btn btn-default" value="Add" id="addMember"/>
-            <input type="hidden" id="members" name="members" value="@members.map(member => member.userName + ":" + member.isManager).mkString(",")"/>
+            <input type="hidden" id="members" name="members" value="@members.map(member => member.userName + ":" + member.manager).mkString(",")"/>
             <div>
               <span class="error" id="error-members"></span>
             </div>
@@ -42,12 +42,12 @@
       <fieldset class="margin">
         @if(account.isDefined){
           <div class="pull-right">
-            <a href="@url(account.get.userName)/_deletegroup" id="delete" class="btn btn-danger">Delete Group</a>
+            <a href="@url(account.get.userName)/_deletegroup" id="delete" class="btn btn-danger btn-lg">Delete Group</a>
           </div>
         }
-        <input type="submit" class="btn btn-success" value="@if(account.isEmpty){Create Group} else {Update Group}"/>
+        <input type="submit" class="btn btn-success btn-lg" value="@if(account.isEmpty){Create Group} else {Update Group}"/>
         @if(account.isDefined){
-          <a href="@url(account.get.userName)" class="btn btn-default">Cancel</a>
+          <a href="@url(account.get.userName)" class="btn btn-default btn-lg">Cancel</a>
         }
       </fieldset>
   </form>
@@ -103,22 +103,22 @@ $(function(){
   });
 
   @members.map { member =>
-    addMemberHTML('@member.userName', @member.isManager);
+    addMemberHTML('@member.userName', @member.manager);
   }
 
   function addMemberHTML(userName, isManager){
-    var memberButton = $('<label class="btn btn-default btn-mini"><input type="radio" value="false" name="' + userName + '">Member</label>');
+    var memberButton = $('<button type="button" class="btn btn-default btn-mini" value="false">Member</button>').data('name', userName);
     if(!isManager){
       memberButton.addClass('active');
     }
-    var managerButton = $('<label class="btn btn-default btn-mini"><input type="radio" value="true" name="' + userName + '">Manager</label>');
+    var managerButton = $('<button type="button" class="btn btn-default btn-mini" value="true">Manager</button>').data('name', userName);
     if(isManager){
       managerButton.addClass('active');
     }
 
     $('#member-list').append($('<li>')
       .data('name', userName)
-      .append($('<div class="btn-group is_manager" data-toggle="buttons">')
+      .append($('<div class="btn-group is_manager" data-toggle="buttons-radio">')
         .append(memberButton)
         .append(managerButton))
       .append(' ')
@@ -130,7 +130,9 @@ $(function(){
   function updateMembers(){
     var members = $('#member-list li').map(function(i, e){
       var userName = $(e).data('name');
-      return userName + ':' + $(e).find('label.active input[type=radio]').attr('value');
+      return userName + ':' + $('button.active').filter(function(i, e){
+        return $(e).data('name') == userName;
+      }).attr('value');
     }).get().join(',');
     $('#members').val(members);
   }

src/main/twirl/gitbucket/core/account/main.scala.html

@@ -4,56 +4,56 @@
 @import gitbucket.core.view.helpers._
 @html.main(account.userName){
   <div class="container body">
-    <div class="main-sidebar">
-      <div class="block">
-        <div class="account-image">@avatar(account.userName, 240)</div>
-        <div class="account-fullname">@account.fullName</div>
-        <div class="account-username">@account.userName</div>
-      </div>
-      <div class="block">
-        @if(account.url.isDefined){
-          <div><i class="octicon octicon-home"></i> <a href="@account.url">@account.url</a></div>
-        }
-        <div><i class="octicon octicon-clock"></i> <span class="muted">Joined on</span> @date(account.registeredDate)</div>
-      </div>
-      @if(groupNames.nonEmpty){
-        <div>
-          <div>Groups</div>
-          @groupNames.map { groupName =>
-            @avatarLink(groupName, 36, tooltip = true)
+    <div class="container-fluid">
+      <div class="row">
+        <div class="col-md-4">
+          <div class="block">
+            <div class="account-image">@avatar(account.userName, 270)</div>
+            <div class="account-fullname">@account.fullName</div>
+            <div class="account-username">@account.userName</div>
+          </div>
+          <div class="block">
+            @if(account.url.isDefined){
+              <div><i class="octicon octicon-home"></i> <a href="@account.url">@account.url</a></div>
+            }
+            <div><i class="octicon octicon-clock"></i> <span class="muted">Joined on</span> @date(account.registeredDate)</div>
+          </div>
+          @if(groupNames.nonEmpty){
+            <div>
+              <div>Groups</div>
+              @groupNames.map { groupName =>
+                @avatarLink(groupName, 36, tooltip = true)
+              }
+            </div>
           }
+
         </div>
-      }
-    </div>
-    <div class="main-content">
-      <ul class="nav nav-tabs" style="margin-bottom: 5px;">
-        <li@if(active == "repositories"){ class="active"}><a href="@url(account.userName)?tab=repositories">Repositories</a></li>
-        @if(account.isGroupAccount){
-          <li@if(active == "members"){ class="active"}><a href="@url(account.userName)?tab=members">Members</a></li>
-        } else {
-          <li@if(active == "activity"){ class="active"}><a href="@url(account.userName)?tab=activity">Public Activity</a></li>
-        }
-        @gitbucket.core.plugin.PluginRegistry().getProfileTabs.map { tab =>
-          @tab(account, context).map { link =>
-            <li@if(active == link.id){ class="active"}><a href="@path/@link.path">@link.label</a></li>
-          }
-        }
-        @if(loginAccount.isDefined && loginAccount.get.userName == account.userName){
-          <li class="pull-right">
-            <div class="button-group">
-              <a href="@url(account.userName)/_edit" class="btn btn-default">Edit Your Profile</a>
-            </div>
-          </li>
-        }
-        @if(loginAccount.isDefined && account.isGroupAccount && isGroupManager){
-          <li class="pull-right">
-            <div class="button-group">
-              <a href="@url(account.userName)/_editgroup" class="btn btn-default">Edit Group</a>
-            </div>
-          </li>
-        }
-      </ul>
-      @body
+        <div class="col-md-8">
+          <ul class="nav nav-tabs" style="margin-bottom: 5px;">
+            <li@if(active == "repositories"){ class="active"}><a href="@url(account.userName)?tab=repositories">Repositories</a></li>
+            @if(account.groupAccount){
+              <li@if(active == "members"){ class="active"}><a href="@url(account.userName)?tab=members">Members</a></li>
+            } else {
+              <li@if(active == "activity"){ class="active"}><a href="@url(account.userName)?tab=activity">Public Activity</a></li>
+            }
+            @if(loginAccount.isDefined && loginAccount.get.userName == account.userName){
+              <li class="pull-right">
+                <div class="button-group">
+                  <a href="@url(account.userName)/_edit" class="btn btn-default">Edit Your Profile</a>
+                </div>
+              </li>
+            }
+            @if(loginAccount.isDefined && account.groupAccount && isGroupManager){
+              <li class="pull-right">
+                <div class="button-groRepiosup">
+                  <a href="@url(account.userName)/_editgroup" class="btn btn-default">Edit Group</a>
+                </div>
+              </li>
+            }
+          </ul>
+          @body
+        </div>
+      </div>
     </div>
   </div>
 }

src/main/twirl/gitbucket/core/account/menu.scala.html

@@ -1,7 +1,7 @@
-@(active: String, ssh: Boolean)(body: Html)(implicit context: gitbucket.core.controller.Context)
+@(active: String, ssh: Boolean)(implicit context: gitbucket.core.controller.Context)
 @import context._
-<div class="main-sidebar">
-  <ul class="nav nav-pills nav-stacked">
+<div class="box">
+  <ul class="nav nav-tabs nav-stacked side-menu">
     <li@if(active=="profile"){ class="active"}>
       <a href="@path/@loginAccount.get.userName/_edit">Profile</a>
     </li>
@@ -13,15 +13,5 @@
     <li@if(active=="application"){ class="active"}>
       <a href="@path/@loginAccount.get.userName/_application">Applications</a>
     </li>
-    @gitbucket.core.plugin.PluginRegistry().getAccountSettingMenus.map { menu =>
-      @menu(context).map { link =>
-        <li@if(active==link.id){ class="active"}>
-          <a href="@path/@link.path">@link.label</a>
-        </li>
-      }
-    }
   </ul>
 </div>
-<div class="main-content">
-  @body
-</div>

src/main/twirl/gitbucket/core/account/newrepo.scala.html

@@ -3,7 +3,7 @@ isCreateRepoOptionPublic: Boolean)(implicit context: gitbucket.core.controller.C
 @import context._
 @import gitbucket.core.view.helpers._
 @html.main("Create a New Repository"){
-<div class="body main-center">
+<div class="body" style="width: 600px; margin: 10px auto;">
   <h2>Create a new repository</h2>
   <p class="muted">
     A repository contains all the files for your project, including the revision history.
@@ -67,7 +67,7 @@ isCreateRepoOptionPublic: Boolean)(implicit context: gitbucket.core.controller.C
       </label>
     </fieldset>
     <fieldset class="margin form-actions">
-      <input type="submit" class="btn btn-success" value="Create repository"/>
+      <input type="submit" class="btn btn-success btn-lg" value="Create repository"/>
     </fieldset>
   </form>
 </div>

src/main/twirl/gitbucket/core/account/register.scala.html

@@ -2,36 +2,36 @@
 @import context._
 @import gitbucket.core.view.helpers._
 @html.main("Create your account"){
-<div class="container body main-center">
+<div class="container body">
   <h3>Create your account</h3>
   <form action="@path/register" method="POST" validate="true">
     <div class="row">
       <div class="col-md-6">
         <fieldset>
           <label for="userName" class="strong">Username:</label>
-          <input type="text" name="userName" id="userName" value="" class="form-control" autofocus/>
+          <input type="text" name="userName" id="userName" value="" autofocus/>
           <span id="error-userName" class="error"></span>
         </fieldset>
         <fieldset>
           <label for="password" class="strong">
             Password:
           </label>
-          <input type="password" name="password" id="password" class="form-control" value=""/>
+          <input type="password" name="password" id="password" value=""/>
           <span id="error-password" class="error"></span>
         </fieldset>
         <fieldset>
           <label for="fullName" class="strong">Full Name:</label>
-          <input type="text" name="fullName" id="fullName" class="form-control" value=""/>
+          <input type="text" name="fullName" id="fullName" value=""/>
           <span id="error-fullName" class="error"></span>
         </fieldset>
         <fieldset>
           <label for="mailAddress" class="strong">Mail Address:</label>
-          <input type="text" name="mailAddress" id="mailAddress" class="form-control" value=""/>
+          <input type="text" name="mailAddress" id="mailAddress" value=""/>
           <span id="error-mailAddress" class="error"></span>
         </fieldset>
         <fieldset>
           <label for="url" class="strong">URL (optional):</label>
-          <input type="text" name="url" id="url" class="form-control" value=""/>
+          <input type="text" name="url" id="url" style="width: 400px;" value=""/>
           <span id="error-url" class="error"></span>
         </fieldset>
       </div>

src/main/twirl/gitbucket/core/account/repositories.scala.html

@@ -15,7 +15,7 @@
         <div class="repository-content">
           <div class="block-header">
             <a href="@url(repository)">@repository.name</a>
-            @if(repository.repository.isPrivate){
+            @if(repository.repository.`private`){
               <i class="octicon octicon-lock"></i>
             }
           </div>

src/main/twirl/gitbucket/core/account/ssh.scala.html

@@ -4,40 +4,45 @@
 @import gitbucket.core.view.helpers._
 @html.main("SSH Keys"){
 <div class="container body">
-  @menu("ssh", settings.ssh){
-    <div class="panel panel-default">
-      <div class="panel-heading strong">SSH Keys</div>
-      <div class="panel-body">
-        @if(sshKeys.isEmpty){
-          No keys
-        }
-        @sshKeys.zipWithIndex.map { case (key, i) =>
-          @if(i != 0){
-            <hr>
-          }
-          <strong style="line-height: 30px;">@key.title</strong> (@SshUtil.fingerPrint(key.publicKey).getOrElse("Key is invalid."))
-          <a href="@path/@account.userName/_ssh/delete/@key.sshKeyId" class="btn btn-sm btn-danger pull-right">Delete</a>
-        }
-      </div>
+  <div class="row">
+    <div class="col-md-3">
+      @menu("ssh", settings.ssh)
     </div>
-    <form method="POST" action="@path/@account.userName/_ssh" validate="true">
+    <div class="col-md-9">
       <div class="panel panel-default">
-        <div class="panel-heading strong">Add an SSH Key</div>
+        <div class="panel-heading strong">SSH Keys</div>
         <div class="panel-body">
-          <fieldset class="form-group">
-            <label for="title" class="strong">Title</label>
-            <div><span id="error-title" class="error"></span></div>
-            <input type="text" name="title" id="title" class="form-control"/>
-          </fieldset>
-          <fieldset class="form-group">
-            <label for="publicKey" class="strong">Key</label>
-            <div><span id="error-publicKey" class="error"></span></div>
-            <textarea name="publicKey" id="publicKey" class="form-control" style="height: 250px;"></textarea>
-          </fieldset>
-          <input type="submit" class="btn btn-success" value="Add"/>
+          @if(sshKeys.isEmpty){
+            No keys
+          }
+          @sshKeys.zipWithIndex.map { case (key, i) =>
+            @if(i != 0){
+              <hr style="margin-top: 10px;">
+            }
+            <strong>@key.title</strong> (@SshUtil.fingerPrint(key.publicKey).getOrElse("Key is invalid."))
+            <a href="@path/@account.userName/_ssh/delete/@key.sshKeyId" class="btn btn-sm btn-danger pull-right">Delete</a>
+          }
         </div>
       </div>
-    </form>
-  }
+      <form method="POST" action="@path/@account.userName/_ssh" validate="true">
+        <div class="panel panel-default">
+          <div class="panel-heading strong">Add an SSH Key</div>
+          <div class="panel-body">
+            <fieldset class="form-group">
+              <label for="title" class="strong">Title</label>
+              <div><span id="error-title" class="error"></span></div>
+              <input type="text" name="title" id="title" class="form-control"/>
+            </fieldset>
+            <fieldset class="form-group">
+              <label for="publicKey" class="strong">Key</label>
+              <div><span id="error-publicKey" class="error"></span></div>
+              <textarea name="publicKey" id="publicKey" class="form-control" style="height: 250px;"></textarea>
+            </fieldset>
+            <input type="submit" class="btn btn-success" value="Add"/>
+          </div>
+        </div>
+      </form>
+    </div>
+  </div>
 </div>
 }

src/main/twirl/gitbucket/core/admin/data.scala.html

@@ -1,56 +0,0 @@
-@(tableNames: Seq[String])(implicit context: gitbucket.core.controller.Context)
-@import context._
-@import gitbucket.core.view.helpers._
-@html.main("Data export / import"){
-  @admin.html.menu("data") {
-    <div class="panel panel-default">
-      <div class="panel-heading strong">Export</div>
-      <div class="panel-body">
-        <form class="form form-horizontal" action="@path/admin/export" method="POST">
-          @tableNames.map { tableName =>
-            <div class="checkbox">
-              <label>
-                <input type="checkbox" name="tableNames" id="@tableName" value="@tableName" checked/> @tableName
-              </label>
-            </div>
-          }
-          <input type="submit" class="btn btn-success pull-right" value="Export">
-          <div class="radio pull-right" style="margin-right: 10px;">
-            <label>
-              <input type="radio" name="type" value="sql">SQL
-            </label>
-          </div>
-          <div class="radio pull-right" style="margin-right: 10px;">
-            <label>
-              <input type="radio" name="type" value="xml" checked>XML
-            </label>
-          </div>
-        </form>
-      </div>
-    </div>
-
-    <div class="panel panel-default">
-      <div class="panel-heading strong">Import (only XML)</div>
-      <div class="panel-body">
-        <form class="form form-horizontal" action="@path/upload/import" method="POST" enctype="multipart/form-data" id="import-form">
-          <input type="file" name="file" id="file">
-          <input type="submit" class="btn btn-success pull-right" value="Import" id="import">
-        </form>
-      </div>
-    </div>
-  }
-}
-<script>
-$(function(){
-  $('#import-form').submit(function(){
-    if($('#file').val() == ''){
-      alert('Choose an import XML file.');
-      return false;
-    } else if(!$('#file').val().endsWith(".xml")){
-      alert('Import is available for only the XML file.');
-      return false;
-    }
-    return confirm('All existing data is deleted before importing.\nAre you sure?');
-  })
-})
-</script>

src/main/twirl/gitbucket/core/admin/menu.scala.html

@@ -1,33 +1,25 @@
 @(active: String)(body: Html)(implicit context: gitbucket.core.controller.Context)
 @import context._
 <div class="container body">
-  <div class="main-sidebar">
-    <ul class="nav nav-pills nav-stacked" id="system-admin-menu-container">
-      <li@if(active=="users"){ class="active"}>
-        <a href="@path/admin/users">User Management</a>
-      </li>
-      <li@if(active=="system"){ class="active"}>
-        <a href="@path/admin/system">System Settings</a>
-      </li>
-      <li@if(active=="plugins"){ class="active"}>
-        <a href="@path/admin/plugins">Plugins</a>
-      </li>
-      <li@if(active=="data"){ class="active"}>
-      <a href="@path/admin/data">Data export / import</a>
-      </li>
-      <li>
-        <a href="@path/console/login.jsp">H2 Console</a>
-      </li>
-      @gitbucket.core.plugin.PluginRegistry().getSystemSettingMenus.map { menu =>
-        @menu(context).map { link =>
-          <li@if(active==link.id){ class="active"}>
-            <a href="@path/@link.path">@link.label</a>
-          </li>
-        }
-      }
-   </ul>
-  </div>
-  <div class="main-content">
-    @body
+  <div class="row">
+    <div class="col-md-3">
+      <ul class="nav nav-tabs nav-stacked side-menu" id="system-admin-menu-container">
+        <li@if(active=="users"){ class="active"}>
+          <a href="@path/admin/users">User Management</a>
+        </li>
+        <li@if(active=="system"){ class="active"}>
+          <a href="@path/admin/system">System Settings</a>
+        </li>
+        <li@if(active=="plugins"){ class="active"}>
+          <a href="@path/admin/plugins">Plugins</a>
+        </li>
+        <li>
+          <a href="@path/console/login.jsp">H2 Console</a>
+        </li>
+     </ul>
+    </div>
+    <div class="col-md-9">
+      @body
+    </div>
   </div>
 </div>