project structure: split server into jdbc + web

23 files changed, 3471 insertions, 0 deletions

diff --git a/juick-server-jdbc/build.gradle b/juick-server-jdbc/build.gradle
new file mode 100644
index 00000000..fde15afe
--- /dev/null
+++ b/juick-server-jdbc/build.gradle
@@ -0,0 +1,76 @@
+apply plugin: 'java'
+apply plugin: 'war'
+
+sourceCompatibility = 1.8
+
+dependencies {
+    compile project(':juick-server-core')
+
+    compile "com.fasterxml.jackson.core:jackson-core:${rootProject.jacksonVersion}"
+    compile "com.fasterxml.jackson.core:jackson-databind:${rootProject.jacksonVersion}"
+    compile "com.fasterxml.jackson.core:jackson-annotations:${rootProject.jacksonVersion}"
+    compile "com.fasterxml.jackson.datatype:jackson-datatype-jdk8:${rootProject.jacksonVersion}"
+
+    providedCompile "ch.qos.logback:logback-classic:${rootProject.logbackVersion}"
+    providedCompile "ch.qos.logback:logback-core:${rootProject.logbackVersion}"
+    providedCompile "ch.qos.logback:logback-access:${rootProject.logbackVersion}"
+
+    providedCompile "org.slf4j:slf4j-api:${rootProject.slf4jVersion}"
+    providedCompile "org.slf4j:jcl-over-slf4j:${rootProject.slf4jVersion}"
+    providedCompile "org.slf4j:log4j-over-slf4j:${rootProject.slf4jVersion}"
+    providedCompile "org.slf4j:jul-to-slf4j:${rootProject.slf4jVersion}"
+
+    compile "org.apache.httpcomponents:httpclient:4.5.3"
+    providedCompile "org.apache.commons:commons-lang3:3.6"
+    providedCompile "org.apache.commons:commons-collections4:4.1"
+    providedCompile "org.apache.commons:commons-text:1.1"
+    providedCompile "commons-io:commons-io:2.5"
+    providedCompile "commons-codec:commons-codec:1.10"
+
+    compile 'com.github.ben-manes.caffeine:caffeine:2.5.2'
+
+    compile "org.springframework:spring-context:${rootProject.springFrameworkVersion}"
+    compile "org.springframework:spring-jdbc:${rootProject.springFrameworkVersion}"
+
+    compile "org.springframework.security:spring-security-web:${rootProject.springSecurityVersion}"
+    compile "org.springframework.security:spring-security-config:${rootProject.springSecurityVersion}"
+
+    providedCompile "org.apache.commons:commons-dbcp2:2.1.1"
+    compile "com.googlecode.log4jdbc:log4jdbc:1.2"
+    compile "javax.inject:javax.inject:1"
+
+    compile "rocks.xmpp:xmpp-core-client:0.7.4"
+    compile "rocks.xmpp:xmpp-extensions-client:0.7.4"
+
+    compile 'org.imgscalr:imgscalr-lib:4.2'
+
+    providedCompile "javax.servlet:javax.servlet-api:3.1.0"
+
+    providedRuntime "commons-fileupload:commons-fileupload:1.3.3"
+
+    testCompile "ch.vorburger.mariaDB4j:mariaDB4j:2.2.3"
+    testCompile "junit:junit:${rootProject.junitVersion}"
+    testCompile "org.hamcrest:hamcrest-all:${rootProject.hamcrestVersion}"
+    testCompile "org.mockito:mockito-core:${rootProject.mockitoVersion}"
+    testCompile "org.springframework:spring-test:${rootProject.springFrameworkVersion}"
+    testCompile "org.springframework.security:spring-security-test:${rootProject.springSecurityVersion}"
+
+    testRuntime "mysql:mysql-connector-java:5.1.40"
+}
+
+compileJava.options.encoding = 'UTF-8'
+
+configurations {
+    all*.exclude module: 'commons-logging'
+}
+
+configurations {
+    testArtifacts.extendsFrom testRuntime
+}
+task testJar(type: Jar) {
+    classifier "test"
+    from sourceSets.test.output
+}
+artifacts {
+    testArtifacts testJar
+}
diff --git a/juick-server-jdbc/src/main/java/com/juick/configuration/DataConfiguration.java b/juick-server-jdbc/src/main/java/com/juick/configuration/DataConfiguration.java
new file mode 100644
index 00000000..b3c8c6bd
--- /dev/null
+++ b/juick-server-jdbc/src/main/java/com/juick/configuration/DataConfiguration.java
@@ -0,0 +1,79 @@
+package com.juick.configuration;
+
+import com.juick.service.search.SearchService;
+import org.apache.commons.dbcp2.BasicDataSource;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.context.annotation.*;
+import org.springframework.core.env.Environment;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.datasource.DataSourceTransactionManager;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+import org.springframework.transaction.annotation.TransactionManagementConfigurer;
+
+import javax.annotation.Resource;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Created by aalexeev on 11/11/16.
+ */
+@Configuration
+@EnableTransactionManagement
+@PropertySource(value = {"classpath:juick.conf"})
+@ComponentScan(basePackages = {"com.juick.service"})
+public class DataConfiguration implements TransactionManagementConfigurer {
+    @Resource
+    private Environment env;
+
+    // NOTE: The close() method will be called automatically with default @Bean settings
+    // But Datasource interface has no close() method
+    @Bean
+    public BasicDataSource dataSource() {
+        BasicDataSource dataSource = new BasicDataSource();
+
+        dataSource.setDriverClassName(env.getProperty("datasource_driver", "com.mysql.jdbc.Driver"));
+        dataSource.setUrl(env.getProperty("datasource_url"));
+        dataSource.setUsername(env.getProperty("datasource_user", StringUtils.EMPTY));
+        dataSource.setPassword(env.getProperty("datasource_password", StringUtils.EMPTY));
+
+        dataSource.setValidationQuery("select 1");
+
+        return dataSource;
+    }
+
+    @Bean
+    public PlatformTransactionManager transactionManager() {
+        return new DataSourceTransactionManager(dataSource());
+    }
+
+    @Override
+    public PlatformTransactionManager annotationDrivenTransactionManager() {
+        return transactionManager();
+    }
+
+    @Bean
+    @DependsOn("dataSource")
+    public JdbcTemplate jdbcTemplate() {
+        return new JdbcTemplate(dataSource());
+    }
+
+    @Bean
+    public SearchService emptySearchService() {
+        return new SearchService() {
+            @Override
+            public void setMaxResult(int maxResult) {
+            }
+
+            @Override
+            public List<Integer> searchInAllMessages(String searchString, int messageIdBefore) {
+                return Collections.emptyList();
+            }
+
+            @Override
+            public List<Integer> searchByStringAndUser(String searchString, int userId, int messageIdBefore) {
+                return Collections.emptyList();
+            }
+        };
+    }
+}
diff --git a/juick-server-jdbc/src/main/java/com/juick/configuration/SearchConfiguration.java b/juick-server-jdbc/src/main/java/com/juick/configuration/SearchConfiguration.java
new file mode 100644
index 00000000..e6b446b6
--- /dev/null
+++ b/juick-server-jdbc/src/main/java/com/juick/configuration/SearchConfiguration.java
@@ -0,0 +1,43 @@
+package com.juick.configuration;
+
+import com.juick.service.search.SearchService;
+import com.juick.service.search.SphinxSearchServiceImpl;
+import org.apache.commons.dbcp2.BasicDataSource;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.DependsOn;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.core.env.Environment;
+
+import javax.annotation.Resource;
+
+/**
+ * Created by aalexeev on 11/18/16.
+ */
+@Configuration
+@PropertySource(value = {"classpath:juick.conf"})
+public class SearchConfiguration {
+    @Resource
+    private Environment env;
+
+    // NOTE: The close() method will be called automatically with default @Bean settings
+    // But Datasource interface has no close() method
+    @Bean
+    public BasicDataSource searchDataSource() {
+        BasicDataSource dataSource = new BasicDataSource();
+
+        dataSource.setDriverClassName(env.getProperty("sphinx_driver", "com.mysql.jdbc.Driver"));
+        dataSource.setUrl(env.getProperty("sphinx_url"));
+        dataSource.setUsername(env.getProperty("sphinx_user", StringUtils.EMPTY));
+        dataSource.setPassword(env.getProperty("sphinx_password", StringUtils.EMPTY));
+
+        return dataSource;
+    }
+
+    @Bean
+    @DependsOn("searchDataSource")
+    public SearchService searchService() {
+        return new SphinxSearchServiceImpl(searchDataSource());
+    }
+}
diff --git a/juick-server-jdbc/src/main/java/com/juick/configuration/UpdaterConfiguration.java b/juick-server-jdbc/src/main/java/com/juick/configuration/UpdaterConfiguration.java
new file mode 100644
index 00000000..b3c0424c
--- /dev/null
+++ b/juick-server-jdbc/src/main/java/com/juick/configuration/UpdaterConfiguration.java
@@ -0,0 +1,30 @@
+package com.juick.configuration;
+
+import com.juick.database.MySqlUpdater;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.DependsOn;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.transaction.PlatformTransactionManager;
+
+import javax.inject.Inject;
+
+/**
+ * Created by aalexeev on 12/13/16.
+ */
+@Configuration
+public class UpdaterConfiguration {
+    @Inject
+    JdbcTemplate jdbcTemplate;
+    @Inject
+    PlatformTransactionManager transactionManager;
+
+    @Bean
+    @DependsOn({"jdbcTemplate", "transactionManager"})
+    public MySqlUpdater updater() {
+        return new MySqlUpdater(
+                jdbcTemplate,
+                transactionManager,
+                "update.sql");
+    }
+}
diff --git a/juick-server-jdbc/src/main/java/com/juick/database/MySqlUpdater.java b/juick-server-jdbc/src/main/java/com/juick/database/MySqlUpdater.java
new file mode 100644
index 00000000..2027d9f1
--- /dev/null
+++ b/juick-server-jdbc/src/main/java/com/juick/database/MySqlUpdater.java
@@ -0,0 +1,135 @@
+package com.juick.database;
+
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.support.TransactionTemplate;
+import org.springframework.util.Assert;
+
+import javax.annotation.PostConstruct;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Supplier;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static org.springframework.transaction.TransactionDefinition.PROPAGATION_REQUIRED;
+
+/**
+ * Created by aalexeev on 12/13/16.
+ */
+public class MySqlUpdater {
+    private static final Pattern UPDATE_PATTERN = Pattern.compile(
+            "update\\s+(version|`version`)\\s+set\\s+(version|`version`)\\s+=\\s*(\\d+)",
+            Pattern.CASE_INSENSITIVE);
+
+    private final Logger logger = LoggerFactory.getLogger(getClass());
+
+    private final JdbcTemplate jdbcTemplate;
+    private final TransactionTemplate transactionTemplate;
+    private final String updateSqlResource;
+
+
+    public MySqlUpdater(JdbcTemplate jdbcTemplate, PlatformTransactionManager transactionManager, String updateSqlResource) {
+        Assert.notNull(jdbcTemplate, "JdbcTemplate must be initialized");
+        Assert.notNull(transactionManager, "PlatformTransactionManager must be initialized");
+        Assert.notNull(updateSqlResource, "sqlResource must be initialized");
+
+        this.jdbcTemplate = jdbcTemplate;
+        this.transactionTemplate = new TransactionTemplate(transactionManager);
+        this.updateSqlResource = updateSqlResource;
+    }
+
+    @PostConstruct
+    public void init() {
+        try (
+                InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream(updateSqlResource);
+        ) {
+            if (is != null) {
+                String content = IOUtils.toString(is, StandardCharsets.UTF_8);
+                if (StringUtils.isNotEmpty(content)) {
+                    String[] sqlArray = content.split(";");
+                    if (sqlArray.length > 0) {
+                        List<String> sqlList = new ArrayList<>(sqlArray.length);
+                        for (String sql : sqlArray)
+                            if (!sql.isEmpty()) {
+                                String sqlTrimmed = sql.trim();
+                                if (!sqlTrimmed.isEmpty())
+                                    sqlList.add(sqlTrimmed);
+                            }
+                        if (!sqlList.isEmpty())
+                            processingSql(sqlList);
+                    }
+                }
+            }
+        } catch (Exception e) {
+            logger.error("MySqlUpdater initialization exception", e);
+        }
+    }
+
+    private void processingSql(final List<String> sqls) {
+        long currentDbVersion = getSingleResult(this::getVersionRaw);
+        long actualVersion;
+
+        List<String> changesSql = new ArrayList<>();
+
+        for (String sql : sqls) {
+            changesSql.add(sql);
+
+            Matcher m = UPDATE_PATTERN.matcher(sql);
+            if (m.matches()) {
+                actualVersion = Long.valueOf(m.group(3));
+
+                if (actualVersion > currentDbVersion) {
+                    updateInTransaction(changesSql);
+                    currentDbVersion = actualVersion;
+                }
+                changesSql.clear();
+            }
+        }
+    }
+
+    private void updateInTransaction(final List<String> sqls) {
+        transactionTemplate.setReadOnly(false);
+        transactionTemplate.setPropagationBehavior(PROPAGATION_REQUIRED);
+        transactionTemplate.execute(status -> {
+            for (String sql : sqls)
+                jdbcTemplate.execute(sql);
+            return 0;
+        });
+    }
+
+    private <T> T getSingleResult(Supplier<T> supplier) {
+        transactionTemplate.setReadOnly(true);
+        transactionTemplate.setPropagationBehavior(PROPAGATION_REQUIRED);
+
+        return transactionTemplate.execute(status -> supplier.get());
+    }
+
+    private long getVersionRaw() {
+        int cnt = jdbcTemplate.query(
+                "SELECT count(*) FROM information_schema.tables WHERE table_schema = ? AND table_name = ?",
+                rs -> {
+                    int result = 0;
+                    if (rs.next())
+                        result = rs.getInt(1);
+                    return result;
+                },
+                "juick", "version");
+
+        long version = 0l;
+
+        if (cnt == 1) {
+            List<Long> list = jdbcTemplate.queryForList("select version from version", Long.class);
+            if (!list.isEmpty())
+                version = list.get(0);
+        }
+
+        return version;
+    }
+}
diff --git a/juick-server-jdbc/src/main/java/com/juick/service/BaseJdbcService.java b/juick-server-jdbc/src/main/java/com/juick/service/BaseJdbcService.java
new file mode 100644
index 00000000..e3784345
--- /dev/null
+++ b/juick-server-jdbc/src/main/java/com/juick/service/BaseJdbcService.java
@@ -0,0 +1,55 @@
+package com.juick.service;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.support.TransactionTemplate;
+import org.springframework.util.Assert;
+
+import javax.sql.DataSource;
+
+/**
+ * Created by aalexeev on 11/13/16.
+ */
+public abstract class BaseJdbcService {
+    protected final Logger logger = LoggerFactory.getLogger(getClass());
+
+    private final JdbcTemplate jdbcTemplate;
+    private final TransactionTemplate transactionTemplate;
+    private final NamedParameterJdbcTemplate namedParameterJdbcTemplate;
+
+
+    protected BaseJdbcService(JdbcTemplate jdbcTemplate, PlatformTransactionManager transactionManager) {
+        Assert.notNull(jdbcTemplate, "JdbcTemplate must be initialized");
+
+        this.jdbcTemplate = jdbcTemplate;
+        this.namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(jdbcTemplate);
+        this.transactionTemplate = (transactionManager == null) ?
+                null : new TransactionTemplate(transactionManager);
+
+    }
+
+    protected BaseJdbcService(DataSource dataSource, PlatformTransactionManager transactionManager) {
+        Assert.notNull(dataSource, "DataSource must be initialized");
+
+        this.jdbcTemplate = new JdbcTemplate(dataSource);
+        this.namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(jdbcTemplate);
+        this.transactionTemplate = (transactionManager == null) ?
+                null : new TransactionTemplate(transactionManager);
+
+    }
+
+    protected JdbcTemplate getJdbcTemplate() {
+        return jdbcTemplate;
+    }
+
+    protected NamedParameterJdbcTemplate getNamedParameterJdbcTemplate() {
+        return namedParameterJdbcTemplate;
+    }
+
+    protected TransactionTemplate getTransactionTemplate() {
+        return transactionTemplate;
+    }
+}
diff --git a/juick-server-jdbc/src/main/java/com/juick/service/CrosspostServiceImpl.java b/juick-server-jdbc/src/main/java/com/juick/service/CrosspostServiceImpl.java
new file mode 100644
index 00000000..965f2b51
--- /dev/null
+++ b/juick-server-jdbc/src/main/java/com/juick/service/CrosspostServiceImpl.java
@@ -0,0 +1,246 @@
+package com.juick.service;
+
+import com.juick.server.helpers.ApplicationStatus;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.tuple.Pair;
+import org.springframework.dao.EmptyResultDataAccessException;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.inject.Inject;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Created by aalexeev on 11/13/16.
+ */
+@Repository
+public class CrosspostServiceImpl extends BaseJdbcService implements CrosspostService {
+
+    @Inject
+    public CrosspostServiceImpl(JdbcTemplate jdbcTemplate) {
+        super(jdbcTemplate, null);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public Optional<Pair<String, String>> getTwitterTokens(final int uid) {
+        List<Optional<Pair<String, String>>> list = getJdbcTemplate().query(
+                "SELECT access_token,access_token_secret FROM twitter WHERE user_id = ? AND crosspost = 1",
+                (rs, num) -> Optional.of(Pair.of(rs.getString(1), rs.getString(2))),
+                uid);
+
+        return list.isEmpty() ?
+                Optional.empty() : list.get(0);
+    }
+
+    @Transactional
+    @Override
+    public boolean deleteTwitterToken(Integer uid) {
+        return getJdbcTemplate().update("DELETE FROM twitter WHERE user_id=?", uid) > 0
+                && getJdbcTemplate().update("DELETE FROM subscr_users WHERE user_id=? AND suser_id=1741", uid) > 0;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public Optional<String> getFacebookToken(final int uid) {
+        List<String> list = getJdbcTemplate().queryForList(
+                "SELECT access_token FROM facebook WHERE user_id = ? AND access_token IS NOT NULL AND crosspost = 1",
+                String.class,
+                uid);
+        return list.isEmpty() ?
+                Optional.empty() : Optional.of(list.get(0));
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public ApplicationStatus getFbCrossPostStatus(final int uid) {
+        List<ApplicationStatus> list = getJdbcTemplate().query(
+                "SELECT 1, crosspost FROM facebook WHERE user_id = ? LIMIT 1",
+                (rs, num) -> {
+                    ApplicationStatus status = new ApplicationStatus();
+
+                    status.setConnected(rs.getInt(1) > 0);
+                    status.setCrosspostEnabled(rs.getBoolean(2));
+
+                    return status;
+                },
+                uid);
+
+        return list.isEmpty() ?
+                new ApplicationStatus() : list.get(0);
+    }
+
+    @Transactional
+    @Override
+    public boolean enableFBCrosspost(Integer uid) {
+        return getJdbcTemplate().update("UPDATE facebook SET crosspost=1 WHERE user_id=?", uid) > 0
+                && getJdbcTemplate().update(
+                "INSERT INTO subscr_users(user_id,suser_id,jid,active) VALUES (?,5863,'juick@facebook.juick.com',1)",
+                uid) > 0;
+    }
+
+    @Transactional
+    @Override
+    public void disableFBCrosspost(Integer uid) {
+        getJdbcTemplate().update("UPDATE facebook SET crosspost=0 WHERE user_id=?", uid);
+        // TODO: stop using magic numbers for system users
+        getJdbcTemplate().update("DELETE FROM subscr_users WHERE user_id=? AND suser_id=5863", uid);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public String getTwitterName(final int uid) {
+        List<String> list = getJdbcTemplate().queryForList(
+                "SELECT uname FROM twitter WHERE user_id = ?",
+                String.class,
+                uid);
+
+        return list.isEmpty() ?
+                StringUtils.EMPTY : list.get(0);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public String getTelegramName(final int uid) {
+        List<String> list = getJdbcTemplate().queryForList(
+                "SELECT tg_name FROM telegram WHERE user_id = ?",
+                String.class,
+                uid);
+
+        return list.isEmpty() ?
+                StringUtils.EMPTY : list.get(0);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public Optional<Pair<String, String>> getVkTokens(final int uid) {
+        List<Optional<Pair<String, String>>> list = getJdbcTemplate().query(
+                "SELECT vk_id, access_token FROM vk WHERE user_id = ? AND crosspost = 1",
+                (rs, num) -> Optional.of(Pair.of(rs.getString(1), rs.getString(2))),
+                uid);
+
+        return list.isEmpty() ?
+                Optional.empty() : list.get(0);
+    }
+
+    @Transactional
+    @Override
+    public void deleteVKUser(Integer uid) {
+        getJdbcTemplate().update("DELETE FROM vk WHERE user_id=?", uid);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public int getUIDbyFBID(long fbID) {
+        try {
+            return getJdbcTemplate().queryForObject("SELECT user_id FROM facebook WHERE fb_id=? AND user_id IS NOT NULL",
+                    Integer.class, fbID);
+        } catch (EmptyResultDataAccessException e) {
+            return 0;
+        }
+    }
+
+    @Transactional
+    @Override
+    public boolean createFacebookUser(long fbID, String loginhash, String token, String fbName, String fbLink) {
+        return getJdbcTemplate().update("INSERT INTO facebook(fb_id,loginhash,access_token,fb_name,fb_link) VALUES (?,?,?,?,?)",
+                fbID, loginhash, token, fbName, fbLink) > 0;
+    }
+
+    @Transactional
+    @Override
+    public boolean updateFacebookUser(long fbID, String token, String fbName, String fbLink) {
+        return getJdbcTemplate().update("UPDATE facebook SET access_token=?,fb_name=?,fb_link=? WHERE fb_id=?",
+                token, fbName, fbLink, fbID) > 0;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public int getUIDbyVKID(long vkID) {
+        try {
+            return getJdbcTemplate().queryForObject("SELECT user_id FROM vk WHERE vk_id=? AND user_id IS NOT NULL", Integer.class, vkID);
+        } catch (EmptyResultDataAccessException e) {
+            return 0;
+        }
+    }
+
+    @Transactional
+    @Override
+    public boolean createVKUser(long vkID, String loginhash, String token, String vkName, String vkLink) {
+        return getJdbcTemplate().update("INSERT INTO vk(vk_id,loginhash,access_token,vk_name,vk_link) VALUES (?,?,?,?,?)",
+                vkID, loginhash, token, vkName, vkLink) > 0;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public String getFacebookNameByHash(String hash) {
+        try {
+            List<Pair<String, String>> fb = getJdbcTemplate().query("SELECT fb_name,fb_link FROM facebook WHERE loginhash=?",
+                    (rs, num) -> Pair.of(rs.getString(1), rs.getString(2)), hash);
+            if (fb.size() > 0) {
+                return "<a href=\"" + fb.get(0).getRight() + "\" rel=\"nofollow\">" + fb.get(0).getLeft() + "</a>";
+            }
+            return null;
+        } catch (EmptyResultDataAccessException e) {
+            return null;
+        }
+    }
+
+    @Transactional
+    @Override
+    public String getTelegramNameByHash(String hash) {
+        try {
+            String name = getJdbcTemplate().queryForObject("SELECT tg_name FROM telegram WHERE loginhash=?", String.class, hash);
+            return "<a href=\"https://telegram.me/" + name + "\" rel=\"nofollow\">" + name + "</a>";
+        } catch (EmptyResultDataAccessException e) {
+            return null;
+        }
+    }
+
+    @Transactional
+    @Override
+    public boolean setFacebookUser(String hash, int uid) {
+        return getJdbcTemplate().update("UPDATE facebook SET user_id=?,loginhash=NULL WHERE loginhash=?", uid, hash) > 0;
+    }
+
+    @Transactional
+    @Override
+    public String getVKNameByHash(String hash) {
+        List<Pair<String, String>> logins = getJdbcTemplate().query("SELECT vk_name,vk_link FROM vk WHERE loginhash=?",
+                (rs, num) -> Pair.of(rs.getString(1), rs.getString(2)), hash);
+        if (logins.size() > 0) {
+            return "<a href=\"http://vk.com/" + logins.get(0).getRight() + "\" rel=\"nofollow\">" + logins.get(0).getLeft() + "</a>";
+        }
+        return null;
+    }
+
+    @Transactional
+    @Override
+    public boolean setVKUser(String hash, int uid) {
+        return getJdbcTemplate().update("UPDATE vk SET user_id=?,loginhash=NULL WHERE loginhash=?", uid, hash) > 0;
+    }
+
+    @Transactional
+    @Override
+    public boolean setTelegramUser(String hash, int uid) {
+        return getJdbcTemplate().update("UPDATE telegram SET user_id=?,loginhash=NULL WHERE loginhash=?", uid, hash) > 0;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public String getJIDByHash(String hash) {
+        try {
+            return getJdbcTemplate().queryForObject("SELECT jid FROM jids WHERE loginhash=?", String.class, hash);
+        } catch (EmptyResultDataAccessException e) {
+            return null;
+        }
+    }
+
+    @Transactional
+    @Override
+    public boolean setJIDUser(String hash, int uid) {
+        return getJdbcTemplate().update("UPDATE jids SET user_id=?,loginhash=NULL WHERE loginhash=?", uid, hash) > 0;
+    }
+}
diff --git a/juick-server-jdbc/src/main/java/com/juick/service/EmailServiceImpl.java b/juick-server-jdbc/src/main/java/com/juick/service/EmailServiceImpl.java
new file mode 100644
index 00000000..b0bf9e20
--- /dev/null
+++ b/juick-server-jdbc/src/main/java/com/juick/service/EmailServiceImpl.java
@@ -0,0 +1,52 @@
+package com.juick.service;
+
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.dao.EmptyResultDataAccessException;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.inject.Inject;
+
+/**
+ * Created by vitalyster on 09.12.2016.
+ */
+@Repository
+@Transactional
+public class EmailServiceImpl extends BaseJdbcService implements EmailService {
+    @Inject
+    public EmailServiceImpl(JdbcTemplate jdbcTemplate) {
+        super(jdbcTemplate, null);
+    }
+
+    @Override
+    public boolean verifyAddressByCode(Integer userId, String code) {
+        try {
+            String address = getJdbcTemplate().queryForObject("SELECT account FROM auth WHERE user_id=? AND protocol='email' AND authcode=?",
+                    String.class, userId, code);
+            getJdbcTemplate().update("INSERT INTO emails(user_id,email) VALUES (?,?)", userId, address);
+            getJdbcTemplate().update("DELETE FROM auth WHERE user_id=? AND authcode=?", userId, code);
+        } catch (EmptyResultDataAccessException e) {
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public boolean addVerificationCode(Integer userId, String account, String code) {
+        return getJdbcTemplate().update("INSERT INTO auth(user_id,protocol,account,authcode) VALUES (?,'email',?,?)",
+                userId, account, code) > 0;
+    }
+
+    @Override
+    public boolean deleteEmail(Integer userId, String account) {
+        return getJdbcTemplate().update("DELETE FROM emails WHERE user_id=? AND email=?", userId, account) > 0;
+    }
+
+    @Override
+    public boolean setSubscriptionHour(Integer userId, String account, String hour) {
+        getJdbcTemplate().update("UPDATE emails SET subscr_hour=NULL WHERE user_id=?", userId);
+        return StringUtils.isNotEmpty(account) && getJdbcTemplate().update(
+                "UPDATE emails SET subscr_hour=? WHERE user_id=? AND email=?", hour, userId, account) > 0;
+    }
+}
diff --git a/juick-server-jdbc/src/main/java/com/juick/service/MessagesServiceImpl.java b/juick-server-jdbc/src/main/java/com/juick/service/MessagesServiceImpl.java
new file mode 100644
index 00000000..318b5805
--- /dev/null
+++ b/juick-server-jdbc/src/main/java/com/juick/service/MessagesServiceImpl.java
@@ -0,0 +1,814 @@
+package com.juick.service;
+
+import com.juick.Message;
+import com.juick.Tag;
+import com.juick.User;
+import com.juick.server.helpers.PrivacyOpts;
+import com.juick.server.helpers.ResponseReply;
+import com.juick.service.search.SearchService;
+import com.juick.util.MessageUtils;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.dao.IncorrectResultSizeDataAccessException;
+import org.springframework.jdbc.core.ConnectionCallback;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.RowMapper;
+import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
+import org.springframework.jdbc.core.namedparam.SqlParameterSource;
+import org.springframework.jdbc.support.GeneratedKeyHolder;
+import org.springframework.jdbc.support.KeyHolder;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.Assert;
+
+import javax.inject.Inject;
+import java.sql.*;
+import java.util.*;
+
+/**
+ * Created by aalexeev on 11/13/16.
+ */
+@Repository
+public class MessagesServiceImpl extends BaseJdbcService implements MessagesService {
+    private final UserService userService;
+    private final SearchService searchService;
+
+    @Inject
+    public MessagesServiceImpl(JdbcTemplate jdbcTemplate, UserService userService, SearchService searchService) {
+        super(jdbcTemplate, null);
+
+        Assert.notNull(userService, "UserService must be initialized");
+        this.userService = userService;
+
+        Assert.notNull(searchService, "SearchService must be initialized");
+        this.searchService = searchService;
+    }
+
+    private class MessageMapper implements RowMapper<Message> {
+        @Override
+        public Message mapRow(ResultSet rs, int rowNum) throws SQLException {
+            Message msg = new Message();
+            msg.setMid(rs.getInt(1));
+            msg.setRid(rs.getInt(2));
+            msg.setReplyto(rs.getInt(3));
+            User user = new User();
+            user.setUid(rs.getInt(4));
+            user.setName(rs.getString(5));
+            user.setBanned(rs.getBoolean(6));
+            msg.setUser(user);
+            msg.TimeAgo = rs.getInt(7);
+            msg.setDate(rs.getTimestamp(8));
+            msg.ReadOnly = rs.getBoolean(9);
+            msg.setPrivacy(rs.getInt(10));
+            msg.FriendsOnly = msg.getPrivacy() < 0;
+            msg.setReplies(rs.getInt(11));
+            msg.setAttachmentType(rs.getString(12));
+            if (rs.getDouble(13) != 0) {
+                msg.Place = new com.juick.Place();
+                msg.Place.lat = rs.getDouble(14);
+                msg.Place.lon = rs.getDouble(15);
+            }
+            msg.setLikes(rs.getInt(16));
+            msg.Hidden = rs.getBoolean(17);
+            String tagsStr = rs.getString(18);
+            msg.parseTags(tagsStr);
+            msg.setRepliesBy(rs.getString(19));
+            msg.setText(rs.getString(20));
+            msg.setReplyQuote(MessageUtils.formatQuote(rs.getString(21)));
+            return msg;
+        }
+    }
+
+    /**
+     * @see <a href="https://dev.mysql.com/doc/connector-j/5.1/en/connector-j-reference-type-conversions.html">Java, JDBC and MySQL Types</a>
+     */
+    @Transactional
+    @Override
+    public int createMessage(final int uid, final String txt, final String attachment, final Collection<com.juick.Tag> tags) {
+        KeyHolder holder = new GeneratedKeyHolder();
+        getJdbcTemplate().update(
+                con -> {
+                    PreparedStatement stmt = con.prepareStatement(
+                            "INSERT INTO messages(user_id, attach) VALUES (?, ?)",
+                            Statement.RETURN_GENERATED_KEYS);
+                    stmt.setInt(1, uid);
+                    if (attachment != null)
+                        stmt.setString(2, attachment);
+                    else
+                        stmt.setNull(2, Types.CHAR);
+
+                    return stmt;
+                },
+                holder);
+
+        int mid = holder.getKey().intValue();
+
+        if (mid > 0) {
+            String tagsNames = StringUtils.EMPTY;
+
+            if (CollectionUtils.isNotEmpty(tags)) {
+                StringBuilder tasNamesBuilder = new StringBuilder();
+                List<Object[]> params = new ArrayList<>(tags.size());
+
+                boolean next = false;
+
+                for (Tag tag : tags) {
+                    if (next) {
+                        tasNamesBuilder.append(" ");
+                    } else
+                        next = true;
+
+                    tasNamesBuilder.append(tag.getName());
+                    params.add(new Object[]{mid, tag.TID});
+                }
+                tagsNames = tasNamesBuilder.toString();
+
+                getJdbcTemplate().batchUpdate(
+                        "INSERT INTO messages_tags(message_id, tag_id) VALUES (?, ?)",
+                        params, new int[]{Types.INTEGER, Types.INTEGER});
+            }
+
+            getJdbcTemplate().update(
+                    "INSERT INTO messages_txt(message_id, tags, txt) VALUES (?, ?, ?)",
+                    new Object[]{mid, tagsNames, txt},
+                    new int[]{Types.INTEGER, Types.VARCHAR, Types.VARCHAR});
+        }
+
+        return mid;
+    }
+
+    /**
+     * @param mid
+     * @param rid
+     * @param uid
+     * @param txt
+     * @param attachment
+     * @return
+     * @see <a href="https://dev.mysql.com/doc/connector-j/5.1/en/connector-j-reference-type-conversions.html">Java, JDBC and MySQL Types</a>
+     */
+    @Transactional
+    @Override
+    public int createReply(final int mid, final int rid, final int uid, final String txt, final String attachment) {
+        int ridnew = getReplyIDIncrement(mid);
+
+        getJdbcTemplate().update(
+                "INSERT INTO replies(message_id, reply_id, user_id, replyto, attach, txt) VALUES (?, ?, ?, ?, ?, ?)",
+                new Object[]{mid, ridnew, uid, rid, attachment, txt},
+                new int[]{Types.INTEGER, Types.SMALLINT, Types.INTEGER, Types.SMALLINT, Types.CHAR, Types.VARCHAR});
+
+        if (ridnew > 0)
+            getJdbcTemplate().update(
+                    "UPDATE messages SET replies = replies + 1 WHERE message_id = ?",
+                    mid);
+        return ridnew;
+    }
+
+    @Override
+    public int getReplyIDIncrement(final int mid) {
+        return getJdbcTemplate().execute((ConnectionCallback<Integer>) conn -> {
+            conn.setAutoCommit(false);
+            final int replyNo;
+            try (PreparedStatement ps = conn.prepareStatement("START TRANSACTION")) {
+                ps.executeUpdate();
+            }
+            try (PreparedStatement ps = conn.prepareStatement("SELECT maxreplyid+1 FROM messages WHERE message_id=? FOR UPDATE")) {
+                ps.setInt(1, mid);
+                try (ResultSet resultSet = ps.executeQuery()) {
+                    if (resultSet.next()) {
+                        replyNo = resultSet.getInt(1);
+                    } else {
+                        throw new IncorrectResultSizeDataAccessException("while getting getReplyIDIncrement, mid=" + mid, 1, 0);
+                    }
+                }
+            }
+            try (PreparedStatement ps = conn.prepareStatement("UPDATE messages SET maxreplyid=? WHERE message_id=?")) {
+                ps.setInt(1, replyNo);
+                ps.setInt(2, mid);
+                if (ps.executeUpdate() != 1) {
+                    throw new IncorrectResultSizeDataAccessException("Cannot find a message to update: " + mid, 1, 0);
+                }
+            }
+            conn.commit();
+            return replyNo;
+        });
+
+    }
+
+    @Transactional
+    @Override
+    public boolean recommendMessage(final int mid, final int vuid) {
+        boolean res = getJdbcTemplate().update(
+                "INSERT IGNORE INTO favorites(user_id, message_id, ts) VALUES (?, ?, NOW())",
+                vuid, mid) == 1;
+
+        if (res)
+            getJdbcTemplate().update(
+                    "UPDATE messages SET likes = likes + 1 WHERE message_id = ?",
+                    mid);
+        return res;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public boolean canViewThread(final int mid, final int uid) {
+        List<PrivacyOpts> list = getJdbcTemplate().query(
+                "SELECT user_id, privacy FROM messages WHERE message_id = ?",
+                (rs, rowNum) -> {
+                    PrivacyOpts res = new PrivacyOpts();
+
+                    res.setUid(rs.getInt(1));
+                    res.setPrivacy(rs.getInt(2));
+
+                    return res;
+                },
+                mid);
+
+        PrivacyOpts privacyOpts = list.isEmpty() ? null : list.get(0);
+
+        return privacyOpts == null ||
+                privacyOpts.getPrivacy() >= 0 ||
+                uid == privacyOpts.getUid() ||
+                ((privacyOpts.getPrivacy() == -1 || privacyOpts.getPrivacy() == -2) &&
+                        uid > 0 && userService.isInWL(privacyOpts.getUid(), uid));
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public boolean isReadOnly(final int mid) {
+        List<Integer> list = getJdbcTemplate().queryForList(
+                "SELECT readonly FROM messages WHERE message_id = ?",
+                new Object[]{mid},
+                Integer.class);
+
+        return !list.isEmpty() && list.get(0) == 1;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public boolean isSubscribed(final int uid, final int mid) {
+        List<Integer> list = getJdbcTemplate().queryForList(
+                "SELECT 1 FROM subscr_messages WHERE suser_id = ? AND message_id = ?",
+                new Object[]{uid, mid},
+                Integer.class);
+
+        return !list.isEmpty() && list.get(0) == 1;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public int getMessagePrivacy(final int mid) {
+        List<Integer> list = getJdbcTemplate().queryForList(
+                "SELECT privacy FROM messages WHERE message_id = ?",
+                new Object[]{mid},
+                Integer.class);
+
+        return list.isEmpty() ? -4 : list.get(0);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public com.juick.Message getMessage(final int mid) {
+        List<com.juick.Message> list = getJdbcTemplate().query(
+                "SELECT messages.message_id, 0 as rid, 0 as replyto, "
+                        + "messages.user_id, users.nick, users.banned as banned, "
+                        + "TIMESTAMPDIFF(MINUTE, messages.ts, NOW()),"
+                        + "messages.ts,"
+                        + "messages.readonly, messages.privacy, messages.replies,"
+                        + "messages.attach, messages.place_id, messages.lat,"
+                        + "messages.lon, messages.likes, messages.hidden,"
+                        + "txt.tags, txt.repliesby, txt.txt, '' as q FROM messages "
+                        + "INNER JOIN users ON messages.user_id = users.id "
+                        + "INNER JOIN messages_txt AS txt "
+                        + "ON messages.message_id = txt.message_id "
+                        + "WHERE messages.message_id = ?",
+                new MessageMapper(),
+                mid);
+
+        return list.isEmpty() ? null : list.get(0);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public com.juick.Message getReply(final int mid, final int rid) {
+        List<com.juick.Message> list = getJdbcTemplate().query(
+                "SELECT replies.user_id, users.nick,"
+                        + "replies.replyto, replies.ts,"
+                        + "replies.attach, replies.txt, IFNULL(q.txt,t.txt) as quote "
+                        + "FROM replies INNER JOIN users ON replies.user_id = users.id "
+                        + "LEFT JOIN replies q ON replies.message_id = q.message_id and replies.replyto = q.reply_id "
+                        + "LEFT JOIN messages_txt t ON replies.message_id = t.message_id "
+                        + "WHERE replies.message_id = ? AND replies.reply_id = ?",
+                (rs, num) -> {
+                    Message msg = new Message();
+
+                    msg.setMid(mid);
+                    msg.setRid(rid);
+                    msg.setUser(new User());
+                    msg.getUser().setUid(rs.getInt(1));
+                    msg.getUser().setName(rs.getString(2));
+                    msg.setReplyto(rs.getInt(3));
+                    msg.setDate(rs.getTimestamp(4));
+                    msg.setAttachmentType(rs.getString(5));
+                    msg.setText(rs.getString(6));
+                    String quote = rs.getString(7);
+
+                    if (!StringUtils.isEmpty(quote)) {
+                        msg.setReplyQuote(MessageUtils.formatQuote(quote));
+                    }
+
+                    return msg;
+                },
+                mid, rid);
+
+        return list.isEmpty() ? null : list.get(0);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public User getMessageAuthor(final int mid) {
+        List<User> list = getJdbcTemplate().query(
+                "SELECT messages.user_id, users.nick "
+                        + "FROM messages INNER JOIN users ON messages.user_id = users.id WHERE messages.message_id = ?",
+                new Object[]{mid},
+                (rs, num) -> {
+                    User res = new com.juick.User();
+                    res.setUid(rs.getInt(1));
+                    res.setName(rs.getString(2));
+                    return res;
+                });
+
+        return list.isEmpty() ?
+                null : list.get(0);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<String> getMessageRecommendations(final int mid) {
+        return getJdbcTemplate().queryForList(
+                "SELECT users.nick FROM favorites INNER JOIN users " +
+                        "ON (favorites.message_id = ? AND favorites.user_id = users.id)",
+                new Object[]{mid},
+                String.class);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Integer> getAll(final int visitorUid, final int before) {
+        SqlParameterSource sqlParameterSource = new MapSqlParameterSource()
+                .addValue("before", before)
+                .addValue("visitorUid", visitorUid);
+
+        return getNamedParameterJdbcTemplate().queryForList(
+                "SELECT m.message_id FROM messages m WHERE " +
+                        (before > 0 ?
+                                " m.message_id < :before AND " : StringUtils.EMPTY) +
+                        " m.hidden = 0 AND (m.privacy > 0" +
+                        (visitorUid > 1 ?
+                                " OR m.user_id = :visitorUid) AND NOT EXISTS (" +
+                                        " SELECT 1 FROM bl_users b WHERE b.user_id = :visitorUid AND b.bl_user_id = m.user_id)" :
+                                ")") +
+                        " AND NOT EXISTS (SELECT 1 from users u WHERE u.banned = 1 and u.id = m.user_id) ORDER BY m.message_id DESC LIMIT 20",
+                sqlParameterSource,
+                Integer.class);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Integer> getTag(final int tid, final int visitorUid, final int before, final int cnt) {
+        SqlParameterSource sqlParameterSource = new MapSqlParameterSource()
+                .addValue("tid", tid)
+                .addValue("cnt", cnt)
+                .addValue("before", before)
+                .addValue("visitorUid", visitorUid);
+
+        return getNamedParameterJdbcTemplate().queryForList(
+                "SELECT message_id FROM (tags INNER JOIN messages_tags " +
+                        "ON ((tags.synonym_id = :tid OR tags.tag_id = :tid) AND tags.tag_id = messages_tags.tag_id)) " +
+                        "INNER JOIN messages USING(message_id) WHERE " +
+                        (before > 0 ?
+                                " messages.message_id < :before AND " : StringUtils.EMPTY) +
+                        "(messages.privacy > 0 OR messages.user_id = :visitorUid) ORDER BY message_id DESC LIMIT :cnt",
+                sqlParameterSource,
+                Integer.class);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Integer> getTags(final String tids, final int visitorUid, final int before, final int cnt) {
+        SqlParameterSource sqlParameterSource = new MapSqlParameterSource()
+                .addValue("cnt", cnt)
+                .addValue("before", before)
+                .addValue("visitorUid", visitorUid);
+
+        return getNamedParameterJdbcTemplate().queryForList(
+                "SELECT messages.message_id FROM messages_tags " +
+                        "INNER JOIN messages USING(message_id) WHERE messages_tags.tag_id IN (" + tids + ") " +
+                        (before > 0 ?
+                                " AND messages.message_id < :before " : StringUtils.EMPTY) +
+                        " AND (messages.privacy > 0 OR messages.user_id = :visitorUid) " +
+                        "ORDER BY messages.message_id DESC LIMIT :cnt",
+                sqlParameterSource,
+                Integer.class);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Integer> getPlace(final int placeId, final int visitorUid, final int before) {
+        SqlParameterSource sqlParameterSource = new MapSqlParameterSource()
+                .addValue("placeId", placeId)
+                .addValue("before", before)
+                .addValue("visitorUid", visitorUid);
+
+        return getNamedParameterJdbcTemplate().queryForList(
+                "SELECT message_id FROM messages WHERE place_id = :placeId " +
+                        (before > 0 ?
+                                " AND message_id < :before " : StringUtils.EMPTY) +
+                        " AND (privacy > 0 OR user_id = :visitorUid) ORDER BY message_id DESC LIMIT 20",
+                sqlParameterSource,
+                Integer.class);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Integer> getMyFeed(final int uid, final int before) {
+        SqlParameterSource sqlParameterSource = new MapSqlParameterSource()
+                .addValue("uid", uid)
+                .addValue("before", before);
+
+        List<Integer> mids = getNamedParameterJdbcTemplate().queryForList(
+                "(SELECT message_id FROM messages " +
+                        " INNER JOIN subscr_users ON (subscr_users.suser_id = :uid AND subscr_users.user_id = messages.user_id) " +
+                        " WHERE " +
+                        (before > 0 ?
+                                " message_id < :before AND " : StringUtils.EMPTY) +
+                        " (privacy >= 0 OR (privacy >= -2 AND privacy <= -1" +
+                        " AND EXISTS (SELECT 1 FROM wl_users w WHERE w.wl_user_id = :uid and w.user_id = messages.user_id)))) " +
+                        " UNION " +
+                        " (SELECT message_id FROM messages WHERE user_id=:uid " +
+                        (before > 0 ?
+                                " AND message_id < :before " : StringUtils.EMPTY) +
+                        ") ORDER BY message_id DESC LIMIT 20",
+                sqlParameterSource,
+                Integer.class);
+
+        return mids;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Integer> getPrivate(final int uid, final int before) {
+        SqlParameterSource sqlParameterSource = new MapSqlParameterSource()
+                .addValue("uid", uid)
+                .addValue("before", before);
+
+        return getNamedParameterJdbcTemplate().queryForList
+                ("SELECT message_id FROM messages WHERE user_id = :uid AND privacy < 0" +
+                                (before > 0 ?
+                                        " AND message_id < :before " : StringUtils.EMPTY) +
+                                "ORDER BY message_id DESC LIMIT 20",
+                        sqlParameterSource,
+                        Integer.class);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Integer> getDiscussions(final int uid, final int before) {
+        SqlParameterSource sqlParameterSource = new MapSqlParameterSource()
+                .addValue("uid", uid)
+                .addValue("before", before);
+
+        return getNamedParameterJdbcTemplate().queryForList(
+                "SELECT message_id FROM subscr_messages WHERE suser_id = :uid" +
+                        (before > 0 ?
+                                " AND message_id < :before " : " ") +
+                        "ORDER BY message_id DESC LIMIT 20",
+                sqlParameterSource,
+                Integer.class);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Integer> getRecommended(final int uid, final int before) {
+        SqlParameterSource sqlParameterSource = new MapSqlParameterSource()
+                .addValue("uid", uid)
+                .addValue("before", before);
+
+        return getNamedParameterJdbcTemplate().queryForList(
+                "SELECT f.message_id FROM favorites f WHERE " +
+                        "EXISTS (SELECT 1 FROM subscr_users s WHERE s.suser_id = :uid and f.user_id = s.user_id)" +
+                        (before > 0 ?
+                                " AND f.message_id < :before " : StringUtils.EMPTY) +
+                        "ORDER BY f.message_id DESC LIMIT 20",
+                sqlParameterSource,
+                Integer.class);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Integer> getPopular(final int visitorUid, final int before) {
+        SqlParameterSource sqlParameterSource = new MapSqlParameterSource()
+                .addValue("vid", visitorUid)
+                .addValue("before", before);
+
+        return getNamedParameterJdbcTemplate().queryForList(
+                "SELECT m.message_id FROM messages m WHERE m.privacy > 0 " +
+                        (before > 0 ?
+                                " AND m.message_id < :before " : StringUtils.EMPTY) +
+                        " AND m.popular > 0 AND NOT EXISTS (SELECT 1 FROM bl_users b WHERE b.user_id = :vid and b.bl_user_id = m.user_id) " +
+                        " ORDER BY m.message_id DESC LIMIT 20",
+                sqlParameterSource,
+                Integer.class);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Integer> getPhotos(final int visitorUid, final int before) {
+        SqlParameterSource sqlParameterSource = new MapSqlParameterSource()
+                .addValue("vid", visitorUid)
+                .addValue("before", before);
+
+        return getNamedParameterJdbcTemplate().queryForList(
+                "SELECT m.message_id FROM messages m WHERE (m.privacy > 0 OR m.user_id = :vid) " +
+                        (before > 0 ?
+                                " AND m.message_id < :before " : StringUtils.EMPTY) +
+                        " AND m.attach IS NOT NULL " +
+                        " AND NOT EXISTS (SELECT 1 from users u WHERE u.banned = 1 and u.id = m.user_id) " +
+                        " AND NOT EXISTS (SELECT 1 FROM bl_users b WHERE b.user_id = :vid and b.bl_user_id = m.user_id) " +
+                        " ORDER BY m.message_id DESC LIMIT 20",
+                sqlParameterSource,
+                Integer.class);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Integer> getSearch(final String search, final int before) {
+        List<Integer> mids = searchService.searchInAllMessages(search, before);
+
+        if (!mids.isEmpty())
+            return getNamedParameterJdbcTemplate().queryForList(
+                    "SELECT message_id FROM messages WHERE message_id IN (:ids) AND privacy > 0 ORDER BY message_id DESC LIMIT 20",
+                    new MapSqlParameterSource("ids", mids),
+                    Integer.class);
+        return mids;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Integer> getUserBlog(final int uid, final int privacy, final int before) {
+        SqlParameterSource sqlParameterSource = new MapSqlParameterSource()
+                .addValue("uid", uid)
+                .addValue("privacy", privacy)
+                .addValue("before", before);
+
+        return getNamedParameterJdbcTemplate().queryForList(
+                "SELECT message_id FROM messages WHERE user_id = :uid" +
+                        (before > 0 ?
+                                " AND message_id < :before" : StringUtils.EMPTY) +
+                        " AND privacy >= :privacy ORDER BY message_id DESC LIMIT 20",
+                sqlParameterSource,
+                Integer.class);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Integer> getUserTag(final int uid, final int tid, final int privacy, final int before) {
+        SqlParameterSource sqlParameterSource = new MapSqlParameterSource()
+                .addValue("uid", uid)
+                .addValue("tid", tid)
+                .addValue("privacy", privacy)
+                .addValue("before", before);
+
+        return getNamedParameterJdbcTemplate().queryForList(
+                "SELECT messages.message_id FROM messages_tags INNER JOIN messages " +
+                        " USING (message_id) WHERE messages.user_id = :uid AND messages_tags.tag_id = :tid " +
+                        (before > 0 ?
+                                " AND messages.message_id < :before " : StringUtils.EMPTY) +
+                        " AND messages.privacy >= :privacy ORDER BY messages.message_id DESC LIMIT 20",
+                sqlParameterSource,
+                Integer.class);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Integer> getUserBlogAtDay(final int uid, final int privacy, final int daysback) {
+        SqlParameterSource sqlParameterSource = new MapSqlParameterSource()
+                .addValue("uid", uid)
+                .addValue("privacy", privacy)
+                .addValue("daysback", daysback);
+
+        return getNamedParameterJdbcTemplate().queryForList(
+                "SELECT message_id FROM messages WHERE user_id = :uid" +
+                        (daysback > 0 ?
+                                " AND ts >= date(NOW() - INTERVAL :daysback day)" +
+                                " AND ts < date(NOW() - INTERVAL :daysback day + INTERVAL 1 day)" : StringUtils.EMPTY) +
+                        " AND privacy >= :privacy ORDER BY message_id DESC LIMIT 20",
+                sqlParameterSource,
+                Integer.class);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Integer> getUserBlogWithRecommendations(final int uid, final int privacy, final int before) {
+        SqlParameterSource sqlParameterSource = new MapSqlParameterSource()
+                .addValue("uid", uid)
+                .addValue("privacy", privacy)
+                .addValue("before", before);
+
+        return getNamedParameterJdbcTemplate().queryForList(
+                "SELECT message_id FROM " +
+                    "(SELECT message_id FROM favorites " +
+                            " WHERE user_id = :uid " +
+                            (before > 0 ?
+                                    " AND message_id < :before " : StringUtils.EMPTY) +
+                            " ORDER BY message_id DESC LIMIT 20) as r" +
+                    " UNION ALL " +
+                "SELECT message_id FROM " +
+                    "(SELECT message_id FROM messages WHERE user_id = :uid" +
+                            (before > 0 ?
+                                    " AND message_id < :before" : StringUtils.EMPTY) +
+                            " AND privacy >= :privacy ORDER BY message_id DESC LIMIT 20) as m " +
+                "ORDER BY message_id DESC LIMIT 20",
+                sqlParameterSource,
+                Integer.class);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Integer> getUserRecommendations(final int uid, final int before) {
+        SqlParameterSource sqlParameterSource = new MapSqlParameterSource()
+                .addValue("uid", uid)
+                .addValue("before", before);
+
+        return getNamedParameterJdbcTemplate().queryForList(
+                "SELECT message_id FROM favorites " +
+                        " WHERE user_id = :uid " +
+                        (before > 0 ?
+                                " AND message_id < :before " : StringUtils.EMPTY) +
+                        " ORDER BY message_id DESC LIMIT 20",
+                sqlParameterSource,
+                Integer.class);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Integer> getUserPhotos(final int uid, final int privacy, final int before) {
+        SqlParameterSource sqlParameterSource = new MapSqlParameterSource()
+                .addValue("uid", uid)
+                .addValue("privacy", privacy)
+                .addValue("before", before);
+
+        return getNamedParameterJdbcTemplate().queryForList(
+                "SELECT message_id FROM messages WHERE user_id = :uid " +
+                        (before > 0 ?
+                                " AND message_id < :before " : StringUtils.EMPTY) +
+                        " AND privacy >= :privacy AND attach IS NOT NULL ORDER BY message_id DESC LIMIT 20",
+                sqlParameterSource,
+                Integer.class);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Integer> getUserSearch(final int UID, final String search, final int privacy, final int before) {
+        List<Integer> mids = searchService.searchByStringAndUser(search, UID, before);
+
+        if (!mids.isEmpty()) {
+            return getNamedParameterJdbcTemplate().queryForList(
+                    "SELECT message_id FROM messages WHERE message_id IN (:ids) AND privacy >= :privacy ORDER BY message_id DESC",
+                    new MapSqlParameterSource("ids", mids)
+                            .addValue("privacy", privacy),
+                    Integer.class);
+        }
+        return mids;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<com.juick.Message> getMessages(final Collection<Integer> mids) {
+        if (CollectionUtils.isNotEmpty(mids)) {
+            return getNamedParameterJdbcTemplate().query(
+                    "SELECT messages.message_id, 0 as rid, 0 as replyto, "
+                            + "messages.user_id,users.nick, 0 as banned, "
+                            + "TIMESTAMPDIFF(MINUTE,messages.ts,NOW()),"
+                            + "messages.ts,"
+                            + "messages.readonly,messages.privacy,messages.replies,"
+                            + "messages.attach,messages.place_id,messages.lat,"
+                            + "messages.lon,messages.likes,messages.hidden,"
+                            + "messages_txt.tags,messages_txt.repliesby, messages_txt.txt, '' as q "
+                            + "FROM (messages INNER JOIN messages_txt "
+                            + "ON messages.message_id=messages_txt.message_id) "
+                            + "INNER JOIN users ON messages.user_id=users.id "
+                            + "WHERE messages.message_id IN (:ids) ORDER BY messages.message_id DESC",
+                    new MapSqlParameterSource("ids", mids),
+                    new MessageMapper());
+        }
+        return Collections.emptyList();
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<com.juick.Message> getReplies(final int mid) {
+        return getNamedParameterJdbcTemplate().query(
+                "SELECT replies.message_id as mid, replies.reply_id, replies.replyto, " +
+                        "replies.user_id, users.nick, users.banned, " +
+                        "TIMESTAMPDIFF(MINUTE, replies.ts, NOW()), replies.ts, " +
+                        "0 as readonly, 0 as privacy, 0 as replies, " +
+                        "replies.attach, 0 as place_id, 0 as lat, " +
+                        "0 as lon, 0 as likes, 0 as hidden, " +
+                        "NULL as tags, NULL as repliesby, replies.txt, " +
+                        "IFNULL(qw.txt, t.txt) as q " +
+                        "FROM replies INNER JOIN users " +
+                        "ON replies.user_id = users.id " +
+                        "LEFT JOIN replies qw ON replies.message_id = qw.message_id and replies.replyto = qw.reply_id " +
+                        "LEFT JOIN messages_txt t on replies.message_id = t.message_id " +
+                        "WHERE replies.message_id = :mid ORDER BY replies.reply_id ASC",
+                new MapSqlParameterSource("mid", mid),
+                new MessageMapper());
+    }
+
+    @Transactional
+    @Override
+    public boolean setMessagePopular(final int mid, final int popular) {
+        int ret;
+        MapSqlParameterSource sqlParameterSource = new MapSqlParameterSource()
+                .addValue("mid", mid)
+                .addValue("popular", popular);
+
+        switch (popular) {
+            case -2:
+                ret = getNamedParameterJdbcTemplate().update(
+                        "UPDATE messages SET hidden = 1 WHERE message_id = :mid",
+                        sqlParameterSource);
+                break;
+            case -1:
+                sqlParameterSource.addValue("popular", 0);
+            default:
+                ret = getNamedParameterJdbcTemplate().update(
+                        "UPDATE messages SET popular = :popular WHERE message_id = :mid",
+                        sqlParameterSource);
+                break;
+        }
+
+        if (popular == -1)
+            ret = getNamedParameterJdbcTemplate().update(
+                    "INSERT INTO top_ignore_messages VALUES (:mid)",
+                    sqlParameterSource);
+
+        return ret > 0;
+    }
+
+    @Transactional
+    @Override
+    public boolean setMessagePrivacy(final int mid) {
+        return getJdbcTemplate().update("UPDATE messages SET privacy=1 WHERE message_id=?", mid) > 0;
+    }
+
+    @Transactional
+    @Override
+    public boolean deleteMessage(final int uid, final int mid) {
+        SqlParameterSource sqlParameterSource = new MapSqlParameterSource()
+                .addValue("mid", mid)
+                .addValue("uid", uid);
+
+        if (getNamedParameterJdbcTemplate().update(
+                "DELETE FROM messages WHERE message_id = :mid AND user_id = :uid", sqlParameterSource) > 0) {
+
+            getNamedParameterJdbcTemplate().update("DELETE FROM messages_txt WHERE message_id = :mid", sqlParameterSource);
+            getNamedParameterJdbcTemplate().update("DELETE FROM replies WHERE message_id = :mid", sqlParameterSource);
+            getNamedParameterJdbcTemplate().update("DELETE FROM subscr_messages WHERE message_id = :mid", sqlParameterSource);
+            getNamedParameterJdbcTemplate().update("DELETE FROM messages_tags WHERE message_id = :mid", sqlParameterSource);
+
+            return true;
+        }
+        return false;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Integer> getLastMessages(int hours) {
+        return getJdbcTemplate().queryForList("SELECT message_id FROM messages WHERE messages.ts>TIMESTAMPADD(HOUR,?,NOW())",
+                Integer.class, -hours);
+
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<ResponseReply> getLastReplies(int hours) {
+        return getJdbcTemplate().query("SELECT users2.nick,replies.message_id,replies.reply_id," +
+                "users.nick,replies.txt," +
+                "replies.ts,replies.attach,replies.ts+0 " +
+                "FROM ((replies INNER JOIN users ON replies.user_id=users.id) " +
+                "INNER JOIN messages ON replies.message_id=messages.message_id) " +
+                "INNER JOIN users AS users2 ON messages.user_id=users2.id " +
+                "WHERE replies.ts>TIMESTAMPADD(HOUR,?,NOW()) AND messages.privacy>0", (rs, rowNum) -> {
+            ResponseReply reply = new ResponseReply();
+            reply.setMuname(rs.getString(1));
+            reply.setMid(rs.getInt(2));
+            reply.setRid(rs.getInt(3));
+            reply.setUname(rs.getString(4));
+            reply.setDescription(rs.getString(5));
+            reply.setPubDate(rs.getTimestamp(6));
+            reply.setAttachmentType(rs.getString(7));
+            return reply;
+        }, -hours);
+    }
+}
diff --git a/juick-server-jdbc/src/main/java/com/juick/service/PMQueriesServiceImpl.java b/juick-server-jdbc/src/main/java/com/juick/service/PMQueriesServiceImpl.java
new file mode 100644
index 00000000..e6a8617d
--- /dev/null
+++ b/juick-server-jdbc/src/main/java/com/juick/service/PMQueriesServiceImpl.java
@@ -0,0 +1,160 @@
+package com.juick.service;
+
+import com.juick.User;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
+import org.springframework.jdbc.core.namedparam.SqlParameterSource;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Created by aalexeev on 11/13/16.
+ */
+@Repository
+public class PMQueriesServiceImpl extends BaseJdbcService implements PMQueriesService {
+
+    @Inject
+    public PMQueriesServiceImpl(JdbcTemplate jdbcTemplate) {
+        super(jdbcTemplate, null);
+    }
+
+    @Transactional
+    @Override
+    public boolean createPM(final int uidFrom, final int uid_to, final String body) {
+        boolean ret = getJdbcTemplate().update(
+                "INSERT INTO pm(user_id, user_id_to, txt) VALUES (?, ?, ?)",
+                uidFrom, uid_to, body) > 0;
+
+        if (ret) {
+            getJdbcTemplate().update(
+                    "INSERT INTO pm_streams(user_id, user_id_to, lastmessage, unread) VALUES (?, ?, NOW(), 1) "
+                            + "ON DUPLICATE KEY UPDATE lastmessage = NOW(), unread = unread + 1",
+                    uidFrom, uid_to);
+        }
+        return ret;
+    }
+
+    @Transactional
+    @Override
+    public boolean addPMinRoster(final int uid, final String jid) {
+        return getJdbcTemplate().update(
+                "INSERT INTO pm_inroster(user_id, jid) VALUES (?, ?)", uid, jid) > 0;
+    }
+
+    @Transactional
+    @Override
+    public boolean removePMinRoster(final int uid, final String jid) {
+        return getJdbcTemplate().update(
+                "DELETE FROM pm_inroster WHERE user_id = ? AND jid = ?", uid, jid) > 0;
+    }
+
+    @Transactional
+    @Override
+    public boolean havePMinRoster(final int uid, final String jid) {
+        List<Integer> res = getJdbcTemplate().queryForList(
+                "SELECT 1 FROM pm_inroster WHERE user_id = ? AND jid = ?",
+                Integer.class,
+                uid, jid);
+        return res.size() > 0;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public String getLastView(final int uidFrom, final int uidTo) {
+        List<String> list = getJdbcTemplate().queryForList(
+                "SELECT lastview FROM pm_streams WHERE user_id = ? AND user_id_to = ?",
+                String.class,
+                uidFrom, uidTo);
+
+        return list.isEmpty() ?
+                null : list.get(0);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<User> getPMLastConversationsUsers(final int uid, final int cnt) {
+        return getJdbcTemplate().query(
+                "SELECT pm_streams.user_id, users.nick, pm_streams.unread FROM pm_streams "
+                        + "INNER JOIN users ON users.id = pm_streams.user_id "
+                        + "WHERE pm_streams.user_id_to=? "
+                        + "ORDER BY pm_streams.unread DESC, pm_streams.lastmessage DESC LIMIT ?",
+                (rs, rowNum) -> {
+                    com.juick.User u = new com.juick.User();
+                    u.setUid(rs.getInt(1));
+                    u.setName(rs.getString(2));
+                    u.setUnreadCount(rs.getInt(3));
+                    return u;
+                },
+                uid, cnt);
+    }
+
+    @Transactional
+    @Override
+    public List<com.juick.Message> getPMMessages(final int uid, final int uidTo) {
+        SqlParameterSource sqlParameterSource = new MapSqlParameterSource()
+                .addValue("uid", uid)
+                .addValue("uidTo", uidTo);
+
+        List<com.juick.Message> msgs = getNamedParameterJdbcTemplate().query(
+                "SELECT user_id, txt,ts FROM pm WHERE (user_id = :uid AND user_id_to = :uidTo) "
+                        + "OR (user_id_to = :uid AND user_id = :uidTo) ORDER BY ts DESC LIMIT 20",
+                sqlParameterSource,
+                (rs, rowNum) -> {
+                    com.juick.Message msg = new com.juick.Message();
+                    int uuid = rs.getInt(1);
+                    msg.setUser(new User());
+                    msg.getUser().setUid(uuid);
+                    msg.setText(rs.getString(2));
+                    msg.setDate(rs.getTimestamp(3));
+                    return msg;
+                });
+
+        getNamedParameterJdbcTemplate().update(
+                "UPDATE pm_streams SET lastview = NOW(), unread = 0 WHERE user_id_to = :uid AND user_id = :uidTo",
+                sqlParameterSource);
+
+        return msgs;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<com.juick.Message> getLastPMInbox(final int uid) {
+        return getJdbcTemplate().query(
+                "SELECT pm.user_id,users.nick,pm.txt,TIMESTAMPDIFF(MINUTE,pm.ts,NOW()),pm.ts " +
+                        "FROM pm INNER JOIN users ON pm.user_id=users.id WHERE pm.user_id_to=? ORDER BY pm.ts DESC LIMIT 20",
+                (rs, num) -> {
+                    com.juick.Message msg = new com.juick.Message();
+                    msg.setUser(new User());
+                    msg.getUser().setUid(rs.getInt(1));
+                    msg.getUser().setName(rs.getString(2));
+                    msg.setText(rs.getString(3));
+                    msg.TimeAgo = rs.getInt(4);
+                    msg.setDate(rs.getTimestamp(5));
+                    return msg;
+                },
+                uid);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<com.juick.Message> getLastPMSent(final int uid) {
+        return getJdbcTemplate().query(
+                "SELECT pm.user_id_to,users.nick,pm.txt,TIMESTAMPDIFF(MINUTE,pm.ts,NOW())," +
+                        "pm.ts FROM pm INNER JOIN users ON pm.user_id_to=users.id " +
+                        "WHERE pm.user_id=? ORDER BY pm.ts DESC LIMIT 20",
+                (rs, num) -> {
+                    com.juick.Message msg = new com.juick.Message();
+                    msg.setUser(new User());
+                    msg.getUser().setUid(rs.getInt(1));
+                    msg.getUser().setName(rs.getString(2));
+                    msg.setText(rs.getString(3));
+                    msg.TimeAgo = rs.getInt(4);
+                    msg.setDate(rs.getTimestamp(5));
+                    return msg;
+                },
+                uid);
+    }
+}
diff --git a/juick-server-jdbc/src/main/java/com/juick/service/PrivacyQueriesServiceImpl.java b/juick-server-jdbc/src/main/java/com/juick/service/PrivacyQueriesServiceImpl.java
new file mode 100644
index 00000000..4f19c70f
--- /dev/null
+++ b/juick-server-jdbc/src/main/java/com/juick/service/PrivacyQueriesServiceImpl.java
@@ -0,0 +1,54 @@
+package com.juick.service;
+
+import com.juick.Tag;
+import com.juick.User;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.inject.Inject;
+
+/**
+ * Created by aalexeev on 11/13/16.
+ */
+@Repository
+@Transactional
+public class PrivacyQueriesServiceImpl extends BaseJdbcService implements PrivacyQueriesService {
+
+    @Inject
+    public PrivacyQueriesServiceImpl(JdbcTemplate jdbcTemplate) {
+        super(jdbcTemplate, null);
+    }
+
+    @Override
+    public PrivacyResult blacklistUser(final User user, final User target) {
+        int result = getJdbcTemplate().update(
+                "DELETE FROM bl_users WHERE user_id = ? AND bl_user_id = ?",
+                user.getUid(), target.getUid());
+
+        if (result > 0)
+            return PrivacyResult.Removed;
+
+        getJdbcTemplate().update(
+                "INSERT INTO bl_users(user_id, bl_user_id) VALUES (?, ?)",
+                user.getUid(), target.getUid());
+
+        return PrivacyResult.Added;
+    }
+
+    @Override
+    public PrivacyResult blacklistTag(final User user, final Tag tag) {
+        int result = getJdbcTemplate().update(
+                "DELETE FROM bl_tags WHERE user_id = ? AND tag_id = ?",
+                user.getUid(), tag.TID);
+
+        if (result > 0)
+            return PrivacyResult.Removed;
+
+        getJdbcTemplate().update(
+                "INSERT INTO bl_tags(user_id, tag_id) VALUES (?, ?)",
+                user.getUid(), tag.TID);
+
+        return PrivacyResult.Added;
+    }
+}
diff --git a/juick-server-jdbc/src/main/java/com/juick/service/PushQueriesServiceImpl.java b/juick-server-jdbc/src/main/java/com/juick/service/PushQueriesServiceImpl.java
new file mode 100644
index 00000000..73f98abf
--- /dev/null
+++ b/juick-server-jdbc/src/main/java/com/juick/service/PushQueriesServiceImpl.java
@@ -0,0 +1,126 @@
+package com.juick.service;
+
+import org.apache.commons.collections4.CollectionUtils;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.inject.Inject;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Created by aalexeev on 11/13/16.
+ */
+@Repository
+public class PushQueriesServiceImpl extends BaseJdbcService implements PushQueriesService {
+
+    @Inject
+    public PushQueriesServiceImpl(JdbcTemplate jdbcTemplate) {
+        super(jdbcTemplate, null);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<String> getGCMRegID(final int uid) {
+        return getJdbcTemplate().queryForList(
+                "SELECT regid FROM android WHERE user_id=?",
+                String.class,
+                uid);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<String> getGCMTokens(final Collection<Integer> uids) {
+        if (CollectionUtils.isEmpty(uids))
+            return Collections.emptyList();
+
+        return getNamedParameterJdbcTemplate().queryForList(
+                "SELECT regid FROM android INNER JOIN users ON (users.id = android.user_id) WHERE users.id IN (:ids)",
+                new MapSqlParameterSource("ids", uids),
+                String.class);
+    }
+
+    @Transactional
+    @Override
+    public boolean addGCMToken(Integer uid, String token) {
+        return getJdbcTemplate().update("INSERT IGNORE INTO android(user_id,regid) VALUES (?, ?)",
+                uid, token) > 0;
+    }
+
+    @Transactional
+    @Override
+    public boolean deleteGCMToken(String token) {
+        return getJdbcTemplate().update("DELETE FROM android WHERE regid=?", token) > 0;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<String> getMPNSURL(final int uid) {
+        return getJdbcTemplate().queryForList(
+                "SELECT url FROM winphone WHERE user_id=?",
+                String.class,
+                uid);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<String> getMPNSTokens(final Collection<Integer> uids) {
+        if (CollectionUtils.isEmpty(uids))
+            return Collections.emptyList();
+
+        return getNamedParameterJdbcTemplate().queryForList(
+                "SELECT url FROM winphone INNER JOIN users ON (users.id=winphone.user_id) WHERE users.id IN (:ids)",
+                new MapSqlParameterSource("ids", uids),
+                String.class);
+    }
+
+    @Transactional
+    @Override
+    public boolean addMPNSToken(Integer uid, String token) {
+        return getJdbcTemplate().update("INSERT IGNORE INTO winphone(user_id,url) VALUES (?, ?)",
+                uid, token) > 0;
+    }
+
+    @Transactional
+    @Override
+    public boolean deleteMPNSToken(String token) {
+        return getJdbcTemplate().update("DELETE FROM winphone WHERE url=?", token) > 0;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<String> getAPNSToken(final int uid) {
+        return getJdbcTemplate().queryForList(
+                "SELECT token from ios WHERE user_id=?",
+                String.class,
+                uid);
+    }
+
+    @Transactional
+    @Override
+    public boolean deleteAPNSToken(String token) {
+        return getJdbcTemplate().update("DELETE FROM ios WHERE token=?", token) > 0;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<String> getAPNSTokens(final Collection<Integer> uids) {
+        if (CollectionUtils.isEmpty(uids))
+            return Collections.emptyList();
+
+        return getNamedParameterJdbcTemplate().queryForList(
+                "SELECT token FROM ios INNER JOIN users ON (users.id = ios.user_id) WHERE users.id IN (:ids)",
+                new MapSqlParameterSource("ids", uids),
+                String.class);
+    }
+
+    @Transactional
+    @Override
+    public boolean addAPNSToken(Integer uid, String token) {
+        return getJdbcTemplate().update("INSERT IGNORE INTO ios(user_id,token) VALUES (?, ?)",
+                uid, token) > 0;
+    }
+}
diff --git a/juick-server-jdbc/src/main/java/com/juick/service/ShowQueriesServiceImpl.java b/juick-server-jdbc/src/main/java/com/juick/service/ShowQueriesServiceImpl.java
new file mode 100644
index 00000000..2362e948
--- /dev/null
+++ b/juick-server-jdbc/src/main/java/com/juick/service/ShowQueriesServiceImpl.java
@@ -0,0 +1,52 @@
+package com.juick.service;
+
+import com.juick.User;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.inject.Inject;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Created by aalexeev on 11/13/16.
+ */
+@Repository
+@Transactional(readOnly = true)
+public class ShowQueriesServiceImpl extends BaseJdbcService implements ShowQueriesService {
+
+    @Inject
+    public ShowQueriesServiceImpl(JdbcTemplate jdbcTemplate) {
+        super(jdbcTemplate, null);
+    }
+
+    @Override
+    public List<String> getRecommendedUsers(final User forUser) {
+        if (forUser == null)
+            return Collections.emptyList();
+
+        return getNamedParameterJdbcTemplate().queryForList(
+                "SELECT u.nick FROM subscr_users su1 INNER JOIN users u " +
+                        "ON su1.user_id = u.id " +
+                        "WHERE NOT EXISTS (SELECT 1 FROM subscr_users su2 WHERE su2.suser_id = :uid and su1.user_id = su2.user_id) " +
+                        "AND EXISTS (SELECT 1 FROM subscr_users su3 WHERE su3.suser_id = :uid and su3.user_id = su1.suser_id ) " +
+                        "AND NOT EXISTS (SELECT 1 FROM bl_users b WHERE b.user_id = :uid and su1.user_id = b.bl_user_id) " +
+                        "AND su1.user_id != :uid AND u.lastmessage > UNIX_TIMESTAMP() - 259200 " +
+                        "GROUP BY su1.user_id ORDER BY count(*) DESC LIMIT 10",
+                new MapSqlParameterSource("uid", forUser.getUid()),
+                String.class);
+    }
+
+    @Override
+    public List<String> getTopUsers() {
+        return getJdbcTemplate().queryForList(
+                "SELECT users.nick,COUNT(subscr_users.suser_id) AS cnt " +
+                        "FROM (subscr_users INNER JOIN users ON subscr_users.user_id=users.id) " +
+                        "INNER JOIN useroptions ON users.id=useroptions.user_id " +
+                        "WHERE useroptions.privacy_view>0 AND users.lastmessage > UNIX_TIMESTAMP() - 259200 " +
+                        "AND users.id!=2 GROUP BY subscr_users.user_id ORDER BY cnt DESC LIMIT 10",
+                String.class);
+    }
+}
diff --git a/juick-server-jdbc/src/main/java/com/juick/service/SubscriptionServiceImpl.java b/juick-server-jdbc/src/main/java/com/juick/service/SubscriptionServiceImpl.java
new file mode 100644
index 00000000..d1eef338
--- /dev/null
+++ b/juick-server-jdbc/src/main/java/com/juick/service/SubscriptionServiceImpl.java
@@ -0,0 +1,219 @@
+package com.juick.service;
+
+import com.juick.Tag;
+import com.juick.User;
+import com.juick.server.helpers.NotifyOpts;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.Assert;
+
+import javax.inject.Inject;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * Created by aalexeev on 11/13/16.
+ */
+@Repository
+public class SubscriptionServiceImpl extends BaseJdbcService implements SubscriptionService {
+    private final UserService userService;
+    private final MessagesService messagesService;
+    private final TagService tagService;
+
+    @Inject
+    public SubscriptionServiceImpl(JdbcTemplate jdbcTemplate, UserService userService,
+                                   MessagesService messagesService, TagService tagService) {
+        super(jdbcTemplate, null);
+
+        Assert.notNull(userService, "UserService must be initialized");
+        this.userService = userService;
+
+        Assert.notNull(messagesService,"MessagesService must be initialized");
+        this.messagesService = messagesService;
+
+        Assert.notNull(tagService, "TagService must be initialized");
+        this.tagService = tagService;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<String> getJIDSubscribedToUser(final int uid, final boolean friendsonly) {
+        return getNamedParameterJdbcTemplate().queryForList(
+                "SELECT jids.jid FROM subscr_users INNER JOIN jids " +
+                        "ON (subscr_users.user_id = :uid AND subscr_users.suser_id = jids.user_id) WHERE jids.active = 1 " +
+                        (friendsonly ?
+                                " AND EXISTS (SELECT 1 FROM wl_users w WHERE w.user_id = :uid and jids.user_id = w.wl_user_id)" : StringUtils.EMPTY),
+                new MapSqlParameterSource("uid", uid),
+                String.class);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<User> getSubscribedUsers(final int uid, final int mid) {
+        User author = messagesService.getMessageAuthor(mid);
+
+        List<User> userids = userService.getUserReaders(uid);
+        List<Integer> tags = tagService.getMessageTagsIDs(mid);
+        List<String> tagsStr = tagService.getMessageTags(mid).stream().map(t -> t.getTag().getName()).collect(Collectors.toList());
+
+        Set<Integer> set = new HashSet<>();
+        set.addAll(
+                userids.stream()
+                        .map(User::getUid).filter(u -> Collections.disjoint(tagService.getUserBLTags(u), tagsStr))
+                        .collect(Collectors.toList()));
+
+
+        if (!tags.isEmpty()) {
+            List<Integer> tagUsers = getNamedParameterJdbcTemplate().queryForList(
+                    "SELECT st.suser_id FROM subscr_tags st " +
+                            "WHERE st.tag_id IN (:ids) AND st.suser_id != :uid " +
+                            " AND NOT EXISTS (SELECT 1 FROM bl_users bu WHERE bu.bl_user_id = :authorUid and st.suser_id = bu.user_id)" +
+                            " AND NOT EXISTS (SELECT 1 FROM bl_tags bt WHERE bt.tag_id IN (:ids) and st.suser_id = bt.user_id)",
+                    new MapSqlParameterSource()
+                            .addValue("ids", tags)
+                            .addValue("uid", uid)
+                            .addValue("authorUid", author.getUid()),
+                    Integer.class);
+            set.addAll(tagUsers);
+        }
+        return userService.getUsersByID(set);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<User> getUsersSubscribedToComments(final int mid, final int ignore_uid) {
+        List<Integer> userids = getJdbcTemplate().queryForList(
+                "SELECT suser_id FROM subscr_messages WHERE message_id=? AND suser_id!=?",
+                Integer.class,
+                mid, ignore_uid);
+
+        if (!userids.isEmpty())
+            return userService.getUsersByID(userids);
+
+        return Collections.emptyList();
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<User> getUsersSubscribedToUserRecommendations(final int uid, final int mid, final int muid) {
+        List<Integer> tags = tagService.getMessageTagsIDs(mid);
+
+        String query = "SELECT s.suser_id FROM subscr_users s WHERE s.user_id = :uid " +
+                " AND NOT EXISTS (SELECT 1 FROM bl_users b WHERE b.bl_user_id = :muid and b.user_id = s.user_id) " +
+                " AND NOT EXISTS (SELECT 1 FROM subscr_users s1 WHERE s1.user_id = :muid AND s.user_id = s1.suser_id) " +
+                " AND NOT EXISTS (SELECT 1 FROM subscr_messages sm WHERE sm.message_id = :mid AND s.user_id = sm.suser_id) " +
+                " AND NOT EXISTS (SELECT 1 FROM favorites WHERE favorites.message_id = :mid AND favorites.user_id = s.user_id) " +
+                " AND s.user_id NOT IN (SELECT s2.suser_id FROM subscr_users s2 " +
+                "  INNER JOIN favorites f ON (f.message_id = :mid AND s2.user_id = f.user_id AND f.user_id != :uid))";
+
+        MapSqlParameterSource sqlParameterSource = new MapSqlParameterSource()
+                .addValue("uid", uid)
+                .addValue("muid", muid)
+                .addValue("mid", mid);
+
+        if (!tags.isEmpty()) {
+            sqlParameterSource.addValue("ids", tags);
+            query += " AND NOT EXISTS (SELECT 1 FROM subscr_tags st WHERE st.tag_id IN (:ids) AND s.user_id = st.suser_id) " +
+                    " AND NOT EXISTS (SELECT 1 FROM bl_tags b WHERE b.tag_id IN (:ids) AND s.user_id = b.user_id)";
+        }
+
+        List<Integer> userids = getNamedParameterJdbcTemplate().queryForList(
+                query, sqlParameterSource, Integer.class);
+
+        return userService.getUsersByID(userids);
+    }
+
+    @Transactional
+    @Override
+    public boolean subscribeMessage(final int mid, final int vuid) {
+        return getJdbcTemplate().update(
+                "INSERT IGNORE INTO subscr_messages(suser_id, message_id) VALUES (?, ?)", vuid, mid) == 1;
+    }
+
+    @Transactional
+    @Override
+    public boolean unSubscribeMessage(final int mid, final int vuid) {
+        return getJdbcTemplate().update(
+                "DELETE FROM subscr_messages WHERE message_id=? AND suser_id=?", mid, vuid) > 0;
+    }
+
+    @Transactional
+    @Override
+    public boolean subscribeUser(final User user, final User toUser) {
+        return getJdbcTemplate().update(
+                "INSERT IGNORE INTO subscr_users(user_id,suser_id) VALUES (?,?)", toUser.getUid(), user.getUid()) == 1;
+    }
+
+    @Transactional
+    @Override
+    public boolean unSubscribeUser(final User user, final User fromUser) {
+        return getJdbcTemplate().update(
+                "DELETE FROM subscr_users WHERE suser_id=? AND user_id=?", user.getUid(), fromUser.getUid()) > 0;
+    }
+
+    @Transactional
+    @Override
+    public boolean subscribeTag(final User user, final Tag toTag) {
+        return getJdbcTemplate().update(
+                "INSERT IGNORE INTO subscr_tags(tag_id,suser_id) VALUES (?,?)", toTag.TID, user.getUid()) == 1;
+    }
+
+    @Transactional
+    @Override
+    public boolean unSubscribeTag(final User user, final Tag toTag) {
+        return getJdbcTemplate().update(
+                "DELETE FROM subscr_tags WHERE tag_id=? AND suser_id=?", toTag.TID, user.getUid()) > 0;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<String> getSubscribedTags(User user) {
+        return getJdbcTemplate().queryForList("SELECT tags.name FROM subscr_tags INNER JOIN tags USING(tag_id) " +
+                "WHERE subscr_tags.suser_id=? ORDER BY tags.name", String.class, user.getUid());
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public NotifyOpts getNotifyOptions(final User user) {
+        List<NotifyOpts> list = getJdbcTemplate().query(
+                "SELECT jnotify,subscr_notify,recommendations FROM useroptions WHERE user_id=?",
+                (rs, num) -> {
+                    NotifyOpts options = new NotifyOpts();
+                    options.setRepliesEnabled(rs.getInt(1) > 0);
+                    options.setSubscriptionsEnabled(rs.getInt(2) > 0);
+                    options.setRecommendationsEnabled(rs.getInt(3) > 0);
+                    return options;
+                },
+                user.getUid());
+
+        return list.isEmpty() ?
+                new NotifyOpts() : list.get(0);
+    }
+
+    @Transactional
+    @Override
+    public boolean setNotifyOptions(final User user, final NotifyOpts options) {
+        int jnotify = getJdbcTemplate().update(
+                "UPDATE useroptions SET jnotify=? WHERE user_id=?",
+                options.isRepliesEnabled() ? 1 : 0,
+                user.getUid());
+
+        int subscr_notify = getJdbcTemplate().update(
+                "UPDATE useroptions SET subscr_notify=? WHERE user_id=?",
+                options.isSubscriptionsEnabled() ? 1 : 0,
+                user.getUid());
+
+        int recommendations = getJdbcTemplate().update(
+                "UPDATE useroptions SET recommendations=? WHERE user_id=?",
+                options.isRecommendationsEnabled() ? 1 : 0,
+                user.getUid());
+
+        return jnotify > 0 && subscr_notify > 0 && recommendations > 0;
+    }
+}
diff --git a/juick-server-jdbc/src/main/java/com/juick/service/TagServiceImpl.java b/juick-server-jdbc/src/main/java/com/juick/service/TagServiceImpl.java
new file mode 100644
index 00000000..b5bd0ae8
--- /dev/null
+++ b/juick-server-jdbc/src/main/java/com/juick/service/TagServiceImpl.java
@@ -0,0 +1,260 @@
+package com.juick.service;
+
+import com.juick.Tag;
+import com.juick.server.helpers.TagStats;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.RowMapper;
+import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
+import org.springframework.jdbc.support.GeneratedKeyHolder;
+import org.springframework.jdbc.support.KeyHolder;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.Assert;
+
+import javax.inject.Inject;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+/**
+ * Created by aalexeev on 11/13/16.
+ */
+@Repository
+public class TagServiceImpl extends BaseJdbcService implements TagService {
+    private static final Pattern TAGS_PATTERN1 = Pattern.compile("^(?:(?:\\*[^ \\r\\n\\t]+)|\\s)+$");
+    private static final Pattern TAGS_PATTERN2 = Pattern.compile("^\\*([^ \\r\\n\\t]+)\\s+([\\s\\S]+)");
+    private static final Pattern TAG_PATTERN = Pattern.compile("\\*([^ \\r\\n\\t]+)");
+
+    private final MessagesService messagesService;
+
+    @Inject
+    public TagServiceImpl(JdbcTemplate jdbcTemplate, MessagesService messagesService) {
+        super(jdbcTemplate, null);
+        Assert.notNull(messagesService, "MessagesService must be initialized");
+        this.messagesService = messagesService;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public com.juick.Tag getTag(final int tid) {
+        List<Tag> list = getJdbcTemplate().query(
+                "SELECT synonym_id,name FROM tags WHERE tag_id=?",
+                (rs, num) -> {
+                    Tag ret = new Tag(rs.getString(2));
+                    ret.TID = tid;
+                    ret.SynonymID = rs.getInt(1);
+                    return ret;
+                },
+                tid);
+
+        return list.isEmpty() ?
+                null : list.get(0);
+    }
+
+    @Transactional
+    @Override
+    public com.juick.Tag getTag(final String tag, final boolean autoCreate) {
+        if (StringUtils.isBlank(tag))
+            return null;
+
+        List<Tag> list = getJdbcTemplate().query(
+                "SELECT tag_id, synonym_id, name FROM tags WHERE name = ?",
+                (rs, rowNum) -> {
+                    Tag ret1 = new Tag(rs.getString(3));
+                    ret1.TID = rs.getInt(1);
+                    ret1.SynonymID = rs.getInt(2);
+                    return ret1;
+                },
+                tag);
+
+        Tag ret = list.isEmpty() ?
+                null : list.get(0);
+
+        if (ret == null && autoCreate) {
+            ret = new com.juick.Tag(tag);
+            ret.TID = createTag(tag);
+        }
+
+        return ret;
+    }
+
+    @Override
+    public List<Tag> getTags(final String[] tags, final boolean autoCreate) {
+        if (ArrayUtils.isEmpty(tags))
+            return Collections.emptyList();
+
+        List<Tag> ret = new ArrayList<>();
+
+        for (String tag : tags) {
+            if (!tag.isEmpty()) {
+                Tag t = getTag(tag, autoCreate);
+
+                if (t != null)
+                    ret.add(t);
+            }
+        }
+
+        return ret.stream().distinct().collect(Collectors.toList());
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public boolean getTagNoIndex(final int tagId) {
+        List<Integer> list = getJdbcTemplate().queryForList(
+                "SELECT noindex FROM tags WHERE tag_id=?", Integer.class, tagId);
+
+        return !list.isEmpty() && list.get(0) == 1;
+    }
+
+    @Transactional
+    @Override
+    public int createTag(final String name) {
+        KeyHolder holder = new GeneratedKeyHolder();
+        getJdbcTemplate().update(
+                con -> {
+                    PreparedStatement stmt = con.prepareStatement(
+                            "INSERT INTO tags(name) VALUES (?)",
+                            Statement.RETURN_GENERATED_KEYS);
+                    stmt.setString(1, name);
+                    return stmt;
+                },
+                holder);
+
+        return holder.getKey().intValue();
+    }
+
+    private class TagStatsMapper implements RowMapper<TagStats> {
+
+        @Override
+        public TagStats mapRow(ResultSet rs, int rowNum) throws SQLException {
+            Tag t = new Tag(rs.getString(1));
+            TagStats s = new TagStats();
+            s.setTag(t);
+            s.setUsageCount(rs.getInt(2));
+            return s;
+        }
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<TagStats> getUserTagStats(final int uid) {
+        return getJdbcTemplate().query(
+                "SELECT tags.name,COUNT(messages.message_id) " +
+                        "FROM (messages INNER JOIN messages_tags ON (messages.user_id=? " +
+                        "AND messages.message_id=messages_tags.message_id)) " +
+                        "INNER JOIN tags ON messages_tags.tag_id=tags.tag_id GROUP BY tags.tag_id ORDER BY tags.name ASC",
+                new TagStatsMapper(),
+                uid);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<String> getUserBLTags(final int uid) {
+        return getJdbcTemplate().queryForList(
+                "SELECT tags.name FROM tags INNER JOIN bl_tags " +
+                        "ON (bl_tags.user_id = ? AND bl_tags.tag_id = tags.tag_id) ORDER BY tags.name",
+                String.class, uid);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<String> getPopularTags() {
+        return getJdbcTemplate().queryForList(
+                "SELECT name FROM tags WHERE top=1 ORDER BY name ASC", String.class)
+                .stream()
+                .collect(Collectors.toList());
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<TagStats> getTagStats() {
+        return getJdbcTemplate().query(
+                "SELECT tags.name,COUNT(DISTINCT messages.user_id) AS cnt " +
+                        "FROM (messages INNER JOIN messages_tags ON (messages.ts>TIMESTAMPADD(DAY,-3,NOW()) " +
+                        "AND messages.message_id=messages_tags.message_id)) " +
+                        "INNER JOIN tags ON messages_tags.tag_id=tags.tag_id " +
+                        "WHERE tags.tag_id NOT IN (SELECT tag_id FROM tags_ignore) " +
+                        "GROUP BY tags.tag_id ORDER BY cnt DESC LIMIT 20", new TagStatsMapper());
+    }
+
+    @Transactional
+    @Override
+    public List<Tag> updateTags(final int mid, final Collection<Tag> newTags) {
+        List<Tag> currentTags = getMessageTags(mid).stream()
+                .map(TagStats::getTag).collect(Collectors.toList());
+
+        if (CollectionUtils.isEmpty(newTags))
+            return currentTags;
+
+        List<Integer> idsForDelete = newTags.stream()
+                .filter(currentTags::contains)
+                .map(tag -> tag.TID)
+                .collect(Collectors.toList());
+
+        if (!idsForDelete.isEmpty())
+            getNamedParameterJdbcTemplate().update(
+                    "DELETE FROM messages_tags WHERE message_id = :mid AND tag_id in (:ids)",
+                    new MapSqlParameterSource().addValue("ids", idsForDelete).addValue("mid", mid));
+
+        newTags.stream().filter(t -> !currentTags.contains(t))
+                .forEach(t -> getJdbcTemplate().update("INSERT INTO messages_tags(message_id,tag_id) VALUES (?,?)", mid, t.TID));
+
+        return getMessageTags(mid).stream()
+                .map(TagStats::getTag).collect(Collectors.toList());
+    }
+
+    @Override
+    public List<Tag> fromString(final String txt, final boolean tagsOnly) {
+        Pattern tagsPattern = tagsOnly ? TAGS_PATTERN1 : TAGS_PATTERN2;
+
+        if (tagsPattern.matcher(txt).matches()) {
+            Matcher tagMatcher = TAG_PATTERN.matcher(txt);
+
+            List<Tag> tags = new ArrayList<>();
+
+            // TODO: process readonly, private, friends, public
+            while (tagMatcher.find()) {
+                for (int i = 1; i <= tagMatcher.groupCount(); i++)
+                    tags.add(getTag(tagMatcher.group(i), true));
+            }
+            return tags;
+        }
+        return Collections.emptyList();
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<TagStats> getMessageTags(final int mid) {
+        return getJdbcTemplate().query(
+                "SELECT tags.tag_id,synonym_id,name,stat_messages FROM tags " +
+                        "INNER JOIN messages_tags ON (messages_tags.message_id = ? AND messages_tags.tag_id = tags.tag_id)",
+                (rs, num) -> {
+                    com.juick.Tag t = new com.juick.Tag(rs.getString(3));
+                    t.TID = rs.getInt(1);
+                    t.SynonymID = rs.getInt(2);
+                    TagStats s = new TagStats();
+                    s.setTag(t);
+                    s.setUsageCount(rs.getInt(4));
+                    return s;
+                }, mid);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Integer> getMessageTagsIDs(final int mid) {
+        return getJdbcTemplate().queryForList(
+                "SELECT tag_id FROM messages_tags WHERE message_id = ?",
+                Integer.class, mid);
+    }
+}
diff --git a/juick-server-jdbc/src/main/java/com/juick/service/TelegramServiceImpl.java b/juick-server-jdbc/src/main/java/com/juick/service/TelegramServiceImpl.java
new file mode 100644
index 00000000..a698e2e8
--- /dev/null
+++ b/juick-server-jdbc/src/main/java/com/juick/service/TelegramServiceImpl.java
@@ -0,0 +1,73 @@
+package com.juick.service;
+
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.inject.Inject;
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * Created by vt on 24/11/2016.
+ */
+@Repository
+public class TelegramServiceImpl extends BaseJdbcService implements TelegramService {
+
+    @Inject
+    public TelegramServiceImpl(JdbcTemplate jdbc) {
+        super(jdbc, null);
+    }
+
+    @Transactional
+    @Override
+    public boolean addChat(final Long id) {
+        return getJdbcTemplate().update("INSERT IGNORE INTO telegram_chats(chat_id) VALUES(?)", id) > 0;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Long> getChats() {
+        return getJdbcTemplate().queryForList("SELECT chat_id FROM telegram_chats", Long.class);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public int getUser(final long tgId) {
+        List<Integer> list = getJdbcTemplate().queryForList(
+                "SELECT id FROM users INNER JOIN telegram " +
+                        "ON telegram.user_id = users.id WHERE telegram.tg_id=?", Integer.class, tgId);
+
+        return list.isEmpty() ? 0 : list.get(0);
+    }
+
+    @Transactional
+    @Override
+    public boolean createTelegramUser(final long tgID, final String tgName) {
+        return getJdbcTemplate().update(
+                "INSERT INTO telegram(tg_id, tg_name, loginhash) VALUES(?,?,?)",
+                tgID, tgName, UUID.randomUUID().toString()) > 0;
+    }
+
+    @Transactional
+    @Override
+    public boolean deleteTelegramUser(Integer uid) {
+        return getJdbcTemplate().update("DELETE FROM telegram WHERE user_id=?", uid) > 0;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Long> getSubscribers(final int uid) {
+        return getJdbcTemplate().queryForList("" +
+                "SELECT tg_id FROM telegram INNER JOIN subscr_users " +
+                "ON (subscr_users.user_id=? AND telegram.user_id=subscr_users.suser_id)", Long.class, uid);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Long> getSubscribersToComments(final int mid, final int ignore_uid) {
+        return getJdbcTemplate().queryForList(
+                "SELECT tg_id FROM telegram INNER JOIN subscr_messages " +
+                        "ON (telegram.user_id=subscr_messages.suser_id) WHERE message_id=? AND suser_id!=?", Long.class, mid, ignore_uid);
+    }
+}
diff --git a/juick-server-jdbc/src/main/java/com/juick/service/UserServiceImpl.java b/juick-server-jdbc/src/main/java/com/juick/service/UserServiceImpl.java
new file mode 100644
index 00000000..4013be59
--- /dev/null
+++ b/juick-server-jdbc/src/main/java/com/juick/service/UserServiceImpl.java
@@ -0,0 +1,704 @@
+package com.juick.service;
+
+import com.juick.User;
+import com.juick.server.helpers.AnonymousUser;
+import com.juick.server.helpers.Auth;
+import com.juick.server.helpers.EmailOpts;
+import com.juick.server.helpers.UserInfo;
+import com.juick.server.util.HashUtils;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.dao.DuplicateKeyException;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.RowMapper;
+import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
+import org.springframework.jdbc.support.GeneratedKeyHolder;
+import org.springframework.jdbc.support.KeyHolder;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.inject.Inject;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.*;
+
+/**
+ * Created by aalexeev on 11/13/16.
+ */
+@Repository
+public class UserServiceImpl extends BaseJdbcService implements UserService {
+
+    private class UserMapper implements RowMapper<User> {
+        @Override
+        public User mapRow(ResultSet rs, int rowNum) throws SQLException {
+            User user = new User();
+
+            user.setUid(rs.getInt(1));
+            user.setName(rs.getString(2));
+            user.setBanned(rs.getBoolean(3));
+            user.setLang(rs.getString(4));
+
+            return user;
+        }
+    }
+
+    @Inject
+    public UserServiceImpl(JdbcTemplate jdbcTemplate) {
+        super(jdbcTemplate, null);
+    }
+
+    @Transactional
+    @Override
+    public String getSignUpHashByJID(final String jid) {
+        List<String> list = getJdbcTemplate().queryForList(
+                "SELECT loginhash FROM jids WHERE jid = ? AND user_id IS NULL", String.class, jid);
+
+        if (list.isEmpty()) {
+            String hash = UUID.randomUUID().toString();
+            getJdbcTemplate().update("INSERT INTO jids(jid, loginhash) VALUES (?, ?)", jid, hash);
+            return hash;
+        }
+        return list.get(0);
+    }
+
+    @Transactional
+    @Override
+    public String getSignUpHashByTelegramID(final Long telegramId, final String username) {
+        List<String> list = getJdbcTemplate().queryForList(
+                "SELECT loginhash FROM telegram WHERE tg_id = ? AND user_id IS NULL",
+                String.class,
+                telegramId);
+
+        if (list.isEmpty()) {
+            String hash = UUID.randomUUID().toString();
+            getJdbcTemplate().update(
+                    "INSERT INTO telegram(tg_id, loginhash, tg_name) VALUES (?, ?, ?)", telegramId, hash, username);
+            return hash;
+        }
+        return list.get(0);
+    }
+
+    @Transactional
+    @Override
+    public int createUser(final String username, final String password) {
+        KeyHolder holder = new GeneratedKeyHolder();
+        try {
+            getJdbcTemplate().update(
+                    con -> {
+                        PreparedStatement stmt = con.prepareStatement(
+                                "INSERT INTO users(nick,passw) VALUES (?,?)",
+                                Statement.RETURN_GENERATED_KEYS);
+                        stmt.setString(1, username);
+                        stmt.setString(2, password);
+                        return stmt;
+                    },
+                    holder);
+        } catch (DuplicateKeyException e) {
+            return -1;
+        }
+
+        int uid = holder.getKey().intValue();
+
+        getJdbcTemplate().update("INSERT INTO useroptions(user_id) VALUES (?)", uid);
+        getJdbcTemplate().update("INSERT INTO subscr_users(user_id, suser_id) VALUES (2, ?)", uid);
+
+        return uid;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public Optional<User> getUserByUID(final int uid) {
+        List<User> list = getJdbcTemplate().query(
+                "SELECT id, nick, banned, lang FROM users WHERE id = ?", new UserMapper(), uid);
+
+        return list.isEmpty() ? Optional.empty() : Optional.of(list.get(0));
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public User getUserByName(final String username) {
+        if (StringUtils.isNotBlank(username)) {
+            List<User> list = getJdbcTemplate().query(
+                    "SELECT id, nick, banned, lang FROM users WHERE nick = ?", new UserMapper(), username);
+
+            if (!list.isEmpty())
+                return list.get(0);
+        }
+        // TODO: @NonNullable ?
+        return AnonymousUser.INSTANCE;
+    }
+
+    @Override
+    // No need marks with @Transactional annotation
+    public User getFullyUserByName(final String username) {
+        if (StringUtils.isNotBlank(username)) {
+            List<User> list = getFullyUsersByNames(Collections.singletonList(username));
+            if (!list.isEmpty())
+                return list.get(0);
+        }
+        return null;
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public User getUserByEmail(String email) {
+        if (StringUtils.isNotBlank(email)) {
+            List<User> list = getJdbcTemplate().query(
+                    "SELECT id, nick, banned, lang FROM users WHERE id = (SELECT user_id FROM emails WHERE email = ?)",
+                    new UserMapper(),
+                    email);
+
+            if (!list.isEmpty())
+                return list.get(0);
+        }
+        return AnonymousUser.INSTANCE;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<User> getFullyUsersByNames(final Collection<String> usernames) {
+        if (CollectionUtils.isEmpty(usernames))
+            return Collections.emptyList();
+
+        return getNamedParameterJdbcTemplate().query(
+                "SELECT id, nick, passw, lang, banned FROM users WHERE nick in (:names)",
+                new MapSqlParameterSource("names", usernames),
+                (rs, rowNum) -> {
+                    User user = new User();
+
+                    user.setUid(rs.getInt(1));
+                    user.setName(rs.getString(2));
+                    user.setCredentials(rs.getString(3));
+                    user.setLang(rs.getString(4));
+                    user.setBanned(rs.getBoolean(5));
+
+                    return user;
+                });
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public User getUserByJID(final String jid) {
+        User result = null;
+
+        if (StringUtils.isNotBlank(jid)) {
+            List<User> list = getJdbcTemplate().query(
+                    "SELECT id, nick, banned, lang FROM users WHERE id = (SELECT user_id FROM jids WHERE jid = ?)",
+                    new UserMapper(),
+                    jid);
+
+            if (!list.isEmpty())
+                result = list.get(0);
+        }
+        return result;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<User> getUsersByName(final Collection<String> unames) {
+        if (CollectionUtils.isEmpty(unames))
+            return Collections.emptyList();
+
+        return getNamedParameterJdbcTemplate().query(
+                "SELECT id, nick, banned, lang FROM users WHERE nick IN (:unames)",
+                new MapSqlParameterSource("unames", unames),
+                new UserMapper());
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<User> getUsersByID(final Collection<Integer> uids) {
+        if (CollectionUtils.isEmpty(uids))
+            return Collections.emptyList();
+
+        return getNamedParameterJdbcTemplate().query(
+                "SELECT id, nick, banned, lang FROM users WHERE id IN (:ids)",
+                new MapSqlParameterSource("ids", uids),
+                new UserMapper());
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<com.juick.User> getUsersByJID(final Collection<String> jids) {
+        if (CollectionUtils.isEmpty(jids))
+            return Collections.emptyList();
+
+        return getNamedParameterJdbcTemplate().query(
+                "SELECT users.id, users.nick, jids.jid FROM users " +
+                        " INNER JOIN jids ON jids.user_id = users.id " +
+                        " WHERE jids.jid IN (:jids)",
+                new MapSqlParameterSource("jids", jids),
+                (rs, rowNum) -> {
+                    com.juick.User user = new com.juick.User();
+                    user.setUid(rs.getInt(1));
+                    user.setName(rs.getString(2));
+                    user.setJid(rs.getString(3));
+                    return user;
+                });
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<String> getJIDsbyUID(final int uid) {
+        return getJdbcTemplate().queryForList("SELECT jid FROM jids WHERE user_id = ? AND active = 1", String.class, uid);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public int getUIDbyJID(final String jid) {
+        if (StringUtils.isNotBlank(jid)) {
+            List<Integer> list = getJdbcTemplate().queryForList(
+                    "SELECT user_id FROM jids WHERE jid = ?", Integer.class, jid);
+
+            if (!list.isEmpty())
+                return list.get(0);
+        }
+        return 0;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public int getUIDbyName(final String uname) {
+        if (StringUtils.isNotBlank(uname)) {
+            List<Integer> list = getJdbcTemplate().queryForList(
+                    "SELECT id FROM users WHERE nick = ?", Integer.class, uname);
+
+            if (!list.isEmpty())
+                return list.get(0);
+        }
+        return 0;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public int getUIDbyHash(final String hash) {
+        if (StringUtils.isNotBlank(hash)) {
+            List<Integer> list = getJdbcTemplate().queryForList(
+                    "SELECT user_id FROM logins WHERE hash = ?", Integer.class, hash);
+
+            if (!list.isEmpty())
+                return list.get(0);
+        }
+        return 0;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public com.juick.User getUserByHash(final String hash) {
+        if (StringUtils.isNotBlank(hash)) {
+            List<User> list = getJdbcTemplate().query(
+                    "SELECT logins.user_id, users.nick, users.banned, users.lang FROM logins " +
+                            "INNER JOIN users ON logins.user_id = users.id WHERE logins.hash = ?",
+                    new UserMapper(),
+                    hash);
+
+            if (!list.isEmpty()) {
+                User user = list.get(0);
+                user.setAuthHash(hash);
+                return user;
+            }
+        }
+        return AnonymousUser.INSTANCE;
+    }
+
+    @Transactional
+    @Override
+    public String getHashByUID(final int uid) {
+        List<String> list = getJdbcTemplate().queryForList(
+                "SELECT hash FROM logins WHERE user_id = ?", String.class, uid);
+
+        if (list.isEmpty()) {
+            String hash = HashUtils.generateHash(16);
+            getJdbcTemplate().update("INSERT INTO logins(user_id, hash) VALUES (?, ?)", uid, hash);
+            return hash;
+        }
+        return list.get(0);
+    }
+
+    @Override
+    public int getUIDByHttpAuth(String auth) {
+        if (auth != null && auth.length() > 8 && auth.startsWith("Basic ")) {
+            Base64.Decoder dec = Base64.getDecoder();
+            String loginpassw[] = new String(dec.decode(auth.substring(6))).split(":", 2);
+            if (loginpassw.length == 2 && loginpassw[0].length() > 1 && loginpassw[0].length() < 16 && loginpassw[0].matches("[a-zA-Z0-9\\-]+") && !loginpassw[1].isEmpty()) {
+                return checkPassword(loginpassw[0], loginpassw[1]);
+            }
+        }
+        return 0;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public int checkPassword(final String username, final String password) {
+        if (StringUtils.isNotBlank(username)) {
+            List<User> list = getJdbcTemplate().query(
+                    "SELECT id, nick, banned, passw FROM users WHERE nick = ?",
+                    (rs, rowNum) -> {
+                        User user = new User();
+                        user.setUid(rs.getInt(1));
+                        user.setName(rs.getString(2));
+                        user.setBanned(rs.getBoolean(3));
+                        user.setCredentials(rs.getString(4));
+                        return user;
+                    },
+                    username);
+
+            if (!list.isEmpty()) {
+                User user = list.get(0);
+                if (Objects.equals(password, user.getCredentials()))
+                    return user.getUid();
+            }
+        }
+        return -1;
+    }
+
+    @Transactional
+    @Override
+    public boolean updatePassword(final User user, final String newPassword) {
+        return user != null &&
+                user.getUid() > 0 &&
+                getJdbcTemplate().update("UPDATE users SET passw = ? WHERE id = ?", newPassword, user.getUid()) > 0;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public int getUserOptionInt(final int uid, final String option, final int defaultValue) {
+        if (StringUtils.isBlank(option))
+            return defaultValue;
+
+        List<Integer> list = getJdbcTemplate().queryForList(
+                "SELECT " + option + " FROM useroptions WHERE user_id = ?", Integer.class, uid);
+
+        return list.isEmpty() ? defaultValue : list.get(0);
+    }
+
+    @Transactional
+    @Override
+    public int setUserOptionInt(final int uid, final String option, final int value) {
+        if (StringUtils.isBlank(option))
+            return 0;
+
+        return getJdbcTemplate().update("UPDATE useroptions SET " + option + "= ? WHERE user_id = ?", value, uid);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public UserInfo getUserInfo(final User user) {
+        List<UserInfo> list = getJdbcTemplate().query(
+                "SELECT fullname, country, url, descr FROM usersinfo WHERE user_id = ?",
+                ((rs, rowNum) -> {
+                    UserInfo info = new UserInfo();
+                    info.setFullName(rs.getString(1));
+                    info.setCountry(rs.getString(2));
+                    info.setUrl(rs.getString(3));
+                    info.setDescription(rs.getString(4));
+                    return info;
+                }),
+                user.getUid());
+
+        return list.isEmpty() ? new UserInfo() : list.get(0);
+    }
+
+    @Transactional
+    @Override
+    public boolean updateUserInfo(final User user, final UserInfo info) {
+        return getJdbcTemplate().update(
+                "INSERT INTO usersinfo(user_id, fullname, country, url, descr) VALUES (?, ?, ?, ?, ?) " +
+                        "ON DUPLICATE KEY UPDATE fullname = ?, country = ?, url = ?, descr = ?",
+                user.getUid(),
+                info.getFullName(),
+                info.getCountry(),
+                info.getUrl(),
+                info.getDescription(),
+                info.getFullName(),
+                info.getCountry(),
+                info.getUrl(),
+                info.getDescription()) > 0;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public boolean getCanMedia(final int uid) {
+        List<Integer> list = getJdbcTemplate().queryForList(
+                "SELECT users.lastphoto - UNIX_TIMESTAMP() FROM users WHERE id = ?",
+                Integer.class,
+                uid);
+
+        return !list.isEmpty() && list.get(0) < 3600;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public boolean isInWL(final int uid, final int check) {
+        List<Integer> list = getJdbcTemplate().queryForList(
+                "SELECT 1 FROM wl_users WHERE user_id = ? AND wl_user_id = ?",
+                Integer.class, uid, check);
+
+        return !list.isEmpty() && list.get(0) == 1;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public boolean isInBL(final int uid, final int check) {
+        List<Integer> list = getJdbcTemplate().queryForList(
+                "SELECT 1 FROM bl_users WHERE user_id = ? AND bl_user_id = ?", Integer.class, uid, check);
+
+        return !list.isEmpty() && list.get(0) == 1;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public boolean isInBLAny(final int uid, final int uid2) {
+        List<Integer> list = getJdbcTemplate().queryForList(
+                "SELECT 1 FROM bl_users WHERE (user_id = ? AND bl_user_id = ?) "
+                        + "OR (user_id = ? AND bl_user_id = ?)",
+                new Object[]{uid, uid2, uid2, uid},
+                Integer.class);
+
+        return !list.isEmpty() && list.get(0) == 1;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Integer> checkBL(final int visitor, final Collection<Integer> uids) {
+        if (CollectionUtils.isEmpty(uids))
+            return Collections.emptyList();
+
+        return getNamedParameterJdbcTemplate().queryForList(
+                "SELECT user_id FROM bl_users WHERE bl_user_id = :visitor and user_id IN (:ids)",
+                new MapSqlParameterSource()
+                        .addValue("visitor", visitor)
+                        .addValue("ids", uids),
+                Integer.class);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public boolean isSubscribed(final int uid, final int check) {
+        List<Integer> list = getJdbcTemplate().queryForList(
+                "SELECT 1 FROM subscr_users WHERE suser_id = ? AND user_id = ?",
+                Integer.class, uid, check);
+
+        return !list.isEmpty() && list.get(0) == 1;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Integer> getUserRead(final int uid) {
+        return getJdbcTemplate().queryForList(
+                "SELECT user_id FROM subscr_users WHERE suser_id=?", Integer.class, uid);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<com.juick.User> getUserReadLeastPopular(final int uid, final int cnt) {
+        return getJdbcTemplate().query(
+                "SELECT users.id,users.nick FROM (subscr_users " +
+                        "INNER JOIN users_subscr ON (subscr_users.suser_id=? " +
+                        "AND subscr_users.user_id=users_subscr.user_id)) INNER JOIN users " +
+                        "ON subscr_users.user_id=users.id ORDER BY cnt LIMIT ?",
+                (rs, num) -> {
+                    com.juick.User u = new com.juick.User();
+                    u.setUid(rs.getInt(1));
+                    u.setName(rs.getString(2));
+                    return u;
+                },
+                uid,
+                cnt);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<User> getUserReaders(final int uid) {
+        return getJdbcTemplate().query(
+                "SELECT users.id, users.nick FROM subscr_users " +
+                        "INNER JOIN users ON subscr_users.suser_id=users.id " +
+                        "WHERE subscr_users.user_id=? ORDER BY users.nick",
+                (rs, num) -> {
+                    com.juick.User u = new com.juick.User();
+                    u.setUid(rs.getInt(1));
+                    u.setName(rs.getString(2));
+                    return u;
+                },
+                uid);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<User> getUserFriends(final int uid) {
+        return getJdbcTemplate().query(
+                "SELECT users.id,users.nick FROM subscr_users " +
+                        "INNER JOIN users ON subscr_users.user_id=users.id " +
+                        "WHERE subscr_users.suser_id=? AND users.id!=? " +
+                        "ORDER BY users.nick",
+                (rs, num) -> {
+                    com.juick.User u = new com.juick.User();
+                    u.setUid(rs.getInt(1));
+                    u.setName(rs.getString(2));
+                    return u;
+                },
+                uid,
+                uid);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<com.juick.User> getUserBLUsers(final int uid) {
+        return getJdbcTemplate().query("SELECT users.id,users.nick FROM users INNER JOIN bl_users " +
+                        "ON(bl_users.bl_user_id=users.id) WHERE bl_users.user_id=? ORDER BY users.nick",
+                (rs, num) -> {
+                    com.juick.User u = new com.juick.User();
+                    u.setUid(rs.getInt(1));
+                    u.setName(rs.getString(2));
+                    return u;
+                }, uid);
+    }
+
+    @Transactional
+    @Override
+    public boolean linkTwitterAccount(
+            final User user, final String accessToken, final String accessTokenSecret, final String screenName) {
+        if (getJdbcTemplate().update("INSERT INTO twitter(user_id,access_token,access_token_secret,uname) " +
+                        "VALUES (?,?,?,?)" +
+                        " ON DUPLICATE KEY UPDATE access_token=?,access_token_secret=?,uname=?",
+                user.getUid(), accessToken, accessTokenSecret, screenName, accessToken, accessTokenSecret, screenName) > 0) {
+            return getJdbcTemplate().update("INSERT INTO subscr_users(user_id,suser_id,jid) " +
+                    "VALUES (?,1741,'juick\\@twitter.juick.com')", user.getUid()) > 0;
+        }
+        return false;
+
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public int getStatsIRead(final int uid) {
+        List<Integer> list = getJdbcTemplate().queryForList(
+                "SELECT COUNT(*) FROM subscr_users WHERE suser_id = ?", Integer.class, uid);
+        return list.isEmpty() ? 0 : list.get(0);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public int getStatsMyReaders(final int uid) {
+        List<Integer> list = getJdbcTemplate().queryForList("SELECT COUNT(*) FROM subscr_users WHERE user_id = ?", Integer.class, uid);
+        return list.isEmpty() ? 0 : list.get(0);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public int getStatsMessages(final int uid) {
+        List<Integer> list = getJdbcTemplate().queryForList("SELECT COUNT(*) FROM messages WHERE user_id = ?", Integer.class, uid);
+        return list.isEmpty() ? 0 : list.get(0);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public int getStatsReplies(final int uid) {
+        List<Integer> list = getJdbcTemplate().queryForList("SELECT COUNT(*) FROM replies WHERE user_id = ?", Integer.class, uid);
+        return list.isEmpty() ? 0 : list.get(0);
+    }
+
+    @Transactional
+    @Override
+    public boolean setActiveStatusForJID(final String JID, final UserService.ActiveStatus jidStatus) {
+        User user = getUserByJID(JID);
+        if (user != null) {
+            int newStatus = jidStatus == UserService.ActiveStatus.Active ? 1 : 0;
+            return getJdbcTemplate().update(
+                    "UPDATE jids SET active = ? WHERE user_id = ? AND jid = ?",
+                    newStatus, user.getUid(), JID) >= 0;
+        }
+        return false;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<String> getAllJIDs(final User user) {
+        return getJdbcTemplate().queryForList(
+                "SELECT jid FROM jids WHERE user_id=?", String.class, user.getUid());
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<Auth> getAuthCodes(final User user) {
+        return getJdbcTemplate().query(
+                "SELECT account,authcode FROM auth WHERE user_id=? AND protocol='xmpp'",
+                (rs, num) -> new Auth(rs.getString(1), rs.getString(2)),
+                user.getUid());
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<String> getEmails(final User user) {
+        return getJdbcTemplate().queryForList("SELECT email FROM emails WHERE user_id=?", String.class, user.getUid());
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public EmailOpts getEmailOpts(final User user) {
+        List<EmailOpts> list = getJdbcTemplate().query(
+                "SELECT email,subscr_hour FROM emails WHERE user_id=? AND subscr_hour IS NOT NULL",
+                (rs, num) -> new EmailOpts(rs.getString(1), rs.getInt(2)), user.getUid());
+        return list.isEmpty() ? new EmailOpts("", 0) : list.get(0);
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public String getEmailHash(final User user) {
+        List<String> list = getJdbcTemplate().queryForList(
+                "SELECT hash FROM mail WHERE user_id = ?",
+                String.class,
+                user.getUid());
+        return list.isEmpty() ? StringUtils.EMPTY : list.get(0) + "@mail.juick.com";
+    }
+
+    @Transactional
+    @Override
+    public int deleteLoginForUser(final String name) {
+        if (StringUtils.isBlank(name))
+            return 0;
+
+        return getJdbcTemplate().update(
+                "delete from logins where user_id in (select id from users where nick = ?)", name);
+    }
+
+    @Transactional
+    @Override
+    public int setLoginForUser(final int uid, final String loginHash) {
+        if (StringUtils.isEmpty(loginHash))
+            return 0;
+
+        return getNamedParameterJdbcTemplate().update(
+                "INSERT INTO logins (user_id, hash) VALUES(:uid, :hash) ON DUPLICATE KEY UPDATE hash = :hash",
+                new MapSqlParameterSource()
+                        .addValue("hash", loginHash)
+                        .addValue("uid", uid));
+    }
+
+    @Transactional
+    @Override
+    public void logout(int uid) {
+        getJdbcTemplate().update("DELETE FROM logins WHERE user_id=?", uid);
+    }
+
+    @Transactional
+    @Override
+    public boolean deleteJID(int uid, String jid) {
+        return getJdbcTemplate().update("DELETE FROM jids WHERE user_id=? AND jid=?", uid, jid) > 0;
+    }
+
+    @Transactional
+    @Override
+    public boolean unauthJID(int uid, String jid) {
+        return getJdbcTemplate()
+                .update("DELETE FROM auth WHERE user_id=? AND protocol='xmpp' AND account=?", uid, jid) > 0;
+    }
+
+    @Transactional(readOnly = true)
+    @Override
+    public List<String> getActiveJIDs() {
+        return getJdbcTemplate().queryForList("SELECT jid FROM jids WHERE active=1 AND loginhash IS NULL", String.class);
+    }
+}
diff --git a/juick-server-jdbc/src/main/java/com/juick/service/search/SphinxSearchServiceImpl.java b/juick-server-jdbc/src/main/java/com/juick/service/search/SphinxSearchServiceImpl.java
new file mode 100644
index 00000000..aa903545
--- /dev/null
+++ b/juick-server-jdbc/src/main/java/com/juick/service/search/SphinxSearchServiceImpl.java
@@ -0,0 +1,85 @@
+package com.juick.service.search;
+
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
+import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
+import org.springframework.util.Assert;
+
+import javax.sql.DataSource;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Created by aalexeev on 11/18/16.
+ */
+
+/* Note
+ * Don't use any spring's component annotation (such as @Repository, @Service, @Component, etc).
+ * This class directly used by spring's search configuration class
+ */
+public class SphinxSearchServiceImpl implements SearchService {
+    private static final int DEFAULT_MAX_RESULT = 25;
+
+    private final NamedParameterJdbcTemplate namedParameterSearchJdbcTemplate;
+
+    private int maxResult = DEFAULT_MAX_RESULT;
+
+
+    public SphinxSearchServiceImpl(JdbcTemplate searchJdbcTemplate) {
+        Assert.notNull(searchJdbcTemplate, "JdbcTemplate must be initialized");
+        this.namedParameterSearchJdbcTemplate = new NamedParameterJdbcTemplate(searchJdbcTemplate);
+    }
+
+    public SphinxSearchServiceImpl(DataSource searchDataSource) {
+        Assert.notNull(searchDataSource, "DataSource must be initialized");
+        this.namedParameterSearchJdbcTemplate = new NamedParameterJdbcTemplate(searchDataSource);
+    }
+
+    @Override
+    public List<Integer> searchInAllMessages(final String searchString, final int messageIdBefore) {
+        if (StringUtils.isBlank(searchString))
+            return Collections.emptyList();
+
+        MapSqlParameterSource sqlParameterSource = new MapSqlParameterSource()
+                .addValue("search", searchString)
+                .addValue("before", messageIdBefore)
+                .addValue("limit", maxResult);
+
+        return namedParameterSearchJdbcTemplate.queryForList(
+                "SELECT id AS message_id FROM messages WHERE MATCH(:search) " +
+                        (messageIdBefore > 0 ?
+                                " AND id < :before " : StringUtils.EMPTY) +
+                        " ORDER BY id DESC LIMIT :limit",
+                sqlParameterSource,
+                Integer.class);
+    }
+
+    @Override
+    public List<Integer> searchByStringAndUser(final String searchString, final int userId, int messageIdBefore) {
+        if (StringUtils.isBlank(searchString))
+            return Collections.emptyList();
+
+        MapSqlParameterSource sqlParameterSource = new MapSqlParameterSource()
+                .addValue("search", searchString)
+                .addValue("userId", userId)
+                .addValue("before", messageIdBefore)
+                .addValue("limit", maxResult);
+
+        return namedParameterSearchJdbcTemplate.queryForList(
+                "SELECT id AS message_id FROM messages WHERE user_id = :userId AND MATCH(:search) " +
+                        (messageIdBefore > 0 ?
+                                " AND id < :before " : StringUtils.EMPTY) +
+                        " ORDER BY id DESC LIMIT :limit",
+                sqlParameterSource,
+                Integer.class);
+    }
+
+    @Override
+    public void setMaxResult(int maxResult) {
+        if (maxResult <= 0)
+            throw new IllegalArgumentException("maxResult value (" + maxResult + ") must be greater then 0");
+
+        this.maxResult = maxResult;
+    }
+}
\ No newline at end of file
diff --git a/juick-server-jdbc/src/main/java/rocks/xmpp/core/session/debug/LogbackDebugger.java b/juick-server-jdbc/src/main/java/rocks/xmpp/core/session/debug/LogbackDebugger.java
new file mode 100644
index 00000000..3da660b2
--- /dev/null
+++ b/juick-server-jdbc/src/main/java/rocks/xmpp/core/session/debug/LogbackDebugger.java
@@ -0,0 +1,39 @@
+package rocks.xmpp.core.session.debug;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import rocks.xmpp.core.session.XmppSession;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/**
+ * Created by vitalyster on 17.11.2016.
+ */
+public class LogbackDebugger implements XmppDebugger {
+    private static final Logger logger = LoggerFactory.getLogger(LogbackDebugger.class);
+
+    @Override
+    public void initialize(XmppSession xmppSession) {
+    }
+
+    @Override
+    public void writeStanza(String s, Object o) {
+        logger.info("OUT: {}", s);
+    }
+
+    @Override
+    public void readStanza(String s, Object o) {
+        logger.info("IN: {}", s);
+    }
+
+    @Override
+    public OutputStream createOutputStream(OutputStream outputStream) {
+        return outputStream;
+    }
+
+    @Override
+    public InputStream createInputStream(InputStream inputStream) {
+        return inputStream;
+    }
+}
diff --git a/juick-server-jdbc/src/test/java/com/juick/configuration/MockDataConfiguration.java b/juick-server-jdbc/src/test/java/com/juick/configuration/MockDataConfiguration.java
new file mode 100644
index 00000000..bd2f3f50
--- /dev/null
+++ b/juick-server-jdbc/src/test/java/com/juick/configuration/MockDataConfiguration.java
@@ -0,0 +1,47 @@
+package com.juick.configuration;
+
+import com.juick.service.*;
+import org.mockito.Mockito;
+import org.springframework.context.annotation.Bean;
+
+/**
+ * Created by vitalyster on 12.01.2017.
+ */
+public class MockDataConfiguration {
+    @Bean
+    MessagesService messagesService() {
+        return Mockito.mock(MessagesService.class);
+    }
+    @Bean
+    UserService userService() {
+        return Mockito.mock(UserService.class);
+    }
+    @Bean
+    TagService tagService() {
+        return Mockito.mock(TagService.class);
+    }
+    @Bean
+    PushQueriesService pushQueriesService() {
+        return Mockito.mock(PushQueriesService.class);
+    }
+    @Bean
+    SubscriptionService subscriptionService() {
+        return Mockito.mock(SubscriptionService.class);
+    }
+    @Bean
+    PMQueriesService pmQueriesService() {
+        return Mockito.mock(PMQueriesService.class);
+    }
+    @Bean
+    TelegramService telegramService() {
+        return Mockito.mock(TelegramService.class);
+    }
+    @Bean
+    CrosspostService crosspostService() {
+        return Mockito.mock(CrosspostService.class);
+    }
+    @Bean
+    EmailService emailService() {
+        return Mockito.mock(EmailService.class);
+    }
+}
diff --git a/juick-server-jdbc/src/test/java/com/juick/configuration/RepositoryConfiguration.java b/juick-server-jdbc/src/test/java/com/juick/configuration/RepositoryConfiguration.java
new file mode 100644
index 00000000..4a74349f
--- /dev/null
+++ b/juick-server-jdbc/src/test/java/com/juick/configuration/RepositoryConfiguration.java
@@ -0,0 +1,65 @@
+package com.juick.configuration;
+
+import ch.vorburger.exec.ManagedProcessException;
+import ch.vorburger.mariadb4j.DB;
+import com.juick.service.search.SearchService;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.datasource.DriverManagerDataSource;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Created by aalexeev on 11/25/16.
+ */
+@Configuration
+@ComponentScan(basePackages = "com.juick.service")
+public class RepositoryConfiguration {
+
+    @Bean(destroyMethod = "stop")
+    DB db() throws ManagedProcessException {
+        DB db = DB.newEmbeddedDB(33306);
+
+        db.start();
+        db.createDB("juick");
+        db.source("schema.sql");
+
+        return db;
+    }
+
+    @Bean
+    public DriverManagerDataSource dataSource() {
+        DriverManagerDataSource dataSource = new DriverManagerDataSource();
+        dataSource.setDriverClassName("net.sf.log4jdbc.DriverSpy");
+        dataSource.setUrl("jdbc:log4jdbc:mysql://localhost:33306/juick?autoReconnect=true&user=root");
+
+        return dataSource;
+    }
+
+    @Bean
+    public JdbcTemplate jdbcTemplate() {
+        return new JdbcTemplate(dataSource());
+    }
+
+    @Bean
+    public SearchService emptySearchService() {
+        return new SearchService() {
+            @Override
+            public void setMaxResult(int maxResult) {
+            }
+
+            @Override
+            public List<Integer> searchInAllMessages(String searchString, int messageIdBefore) {
+                return Collections.emptyList();
+            }
+
+            @Override
+            public List<Integer> searchByStringAndUser(String searchString, int userId, int messageIdBefore) {
+                return Collections.emptyList();
+            }
+        };
+    }
+}
diff --git a/juick-server-jdbc/src/test/java/com/juick/service/MessageServiceTest.java b/juick-server-jdbc/src/test/java/com/juick/service/MessageServiceTest.java
new file mode 100644
index 00000000..5f2c2b05
--- /dev/null
+++ b/juick-server-jdbc/src/test/java/com/juick/service/MessageServiceTest.java
@@ -0,0 +1,23 @@
+package com.juick.service;
+
+import com.juick.configuration.RepositoryConfiguration;
+import org.junit.Test;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
+
+import javax.inject.Inject;
+
+/**
+ * Created by aalexeev on 11/25/16.
+ */
+@ContextConfiguration(classes = RepositoryConfiguration.class)
+public class MessageServiceTest extends AbstractJUnit4SpringContextTests {
+    @Inject
+    private MessagesService messagesService;
+
+
+    @Test
+    public void getMyFeed() {
+        messagesService.getMyFeed(1, 1000000);
+    }
+}
diff --git a/juick-server-jdbc/src/test/java/com/juick/tests/util/MockUtils.java b/juick-server-jdbc/src/test/java/com/juick/tests/util/MockUtils.java
new file mode 100644
index 00000000..5344dd23
--- /dev/null
+++ b/juick-server-jdbc/src/test/java/com/juick/tests/util/MockUtils.java
@@ -0,0 +1,34 @@
+package com.juick.tests.util;
+
+import com.juick.Message;
+import com.juick.User;
+import org.apache.commons.text.RandomStringGenerator;
+
+import java.util.Date;
+
+/**
+ * Created by vitalyster on 12.01.2017.
+ */
+public class MockUtils {
+    final static RandomStringGenerator generator = new RandomStringGenerator.Builder().withinRange('a', 'z').build();
+    public static Message mockMessage(Integer mid, final User user, final String messageText) {
+        Message msg = new Message();
+
+        msg.setMid(mid);
+        msg.setUser(user);
+        msg.setText(messageText == null ? generator.generate(24) : messageText);
+        msg.setDate(new Date());
+        return msg;
+    }
+
+    public static User mockUser(final int uid, final String name, final String password) {
+        User user = new User();
+
+        user.setName(name);
+        user.setUid(uid);
+        user.setCredentials(password);
+        user.setBanned(false);
+
+        return user;
+    }
+}