path: root/juick-server-jdbc/src/main/java/com/juick/service/SubscriptionServiceImpl.java

/*
 * Copyright (C) 2008-2017, Juick
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

package com.juick.service;

import com.juick.Message;
import com.juick.Tag;
import com.juick.User;
import com.juick.server.helpers.NotifyOpts;
import org.apache.commons.lang3.StringUtils;
import org.springframework.dao.DuplicateKeyException;
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.annotation.Nonnull;
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 {
    @Inject
    private UserService userService;
    @Inject
    private MessagesService messagesService;
    @Inject
    private 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(@Nonnull final Message msg, @Nonnull final Message reply) {
        List<Integer> userids = getJdbcTemplate().queryForList(
                "SELECT suser_id FROM subscr_messages WHERE message_id=? AND suser_id!=?",
                Integer.class,
                msg.getMid(), reply.getUser().getUid());

        if (!userids.isEmpty()) {
            return userService.getUsersByID(userids.stream()
                    .filter(u -> !userService.isInBLAny(u, reply.getUser().getUid()))
                    .collect(Collectors.toList()));
        }
        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) {
        try {
            return getJdbcTemplate().update(
                    "INSERT INTO subscr_messages(suser_id, message_id) VALUES (?, ?)", vuid, mid) == 1;
        } catch (DuplicateKeyException e) {
            return true;
        }
    }

    @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) {
        try {
            return getJdbcTemplate().update(
                    "INSERT INTO subscr_users(user_id,suser_id) VALUES (?,?)", toUser.getUid(), user.getUid()) == 1;
        } catch (DuplicateKeyException e) {
            return true;
        }
    }

    @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) {
        try {

            return getJdbcTemplate().update(
                    "INSERT INTO subscr_tags(tag_id,suser_id) VALUES (?,?)", toTag.TID, user.getUid()) == 1;
        } catch (DuplicateKeyException e) {
            return true;
        }
    }

    @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;
    }
}