path: root/juick-notifications/src/main/java/com/juick/components/Notifications.java

/*
 * Juick
 * Copyright (C) 2013, Ugnich Anton
 *
 * 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.components;

import com.google.android.gcm.server.*;
import com.juick.json.MessageSerializer;
import com.juick.util.ThreadHelper;
import com.juick.xmpp.JID;
import com.juick.xmpp.Message.MessageListener;
import com.juick.xmpp.Stream;
import com.juick.xmpp.StreamComponent;
import com.juick.xmpp.extensions.JuickMessage;
import com.juick.xmpp.utils.XmlUtils;
import com.notnoop.apns.APNS;
import com.notnoop.apns.ApnsService;
import org.apache.commons.lang3.math.NumberUtils;
import org.apache.http.Consts;
import org.apache.http.Header;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.apache.http.util.TextUtils;
import org.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.core.env.Environment;
import org.springframework.http.HttpMethod;
import org.springframework.web.client.RestTemplate;

import java.io.IOException;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ExecutorService;

/**
 * @author Ugnich Anton
 */
public class Notifications implements InitializingBean, DisposableBean, Stream.StreamListener, MessageListener {
    private static Logger logger = LoggerFactory.getLogger(Notifications.class);

    private final RestTemplate rest;
    private final ExecutorService service;
    private Socket socket;
    private Stream xmpp;
    private final Sender GCMSender;

    private final String wns_application_sip;
    private final String wns_client_secret;
    private final String pushJid;
    private final String xmppHost;
    private final int xmppPort;
    private final String xmppPushPassword;


    public Notifications(final Environment env, final ExecutorService service, final RestTemplate rest) {
        this.service = service;
        this.rest = rest;

        wns_application_sip = env.getProperty("wns_application_sip", "");
        wns_client_secret = env.getProperty("wns_client_secret", "");
        GCMSender = new Sender(env.getProperty("gcm_key", ""), Endpoint.GCM);
        pushJid = env.getProperty("push_jid");
        xmppHost = env.getProperty("xmpp_host", "localhost");
        xmppPort = NumberUtils.toInt(env.getProperty("xmpp_port"), 5347);
        xmppPushPassword = env.getProperty("push_xmpp_password", "");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        try {
            socket = new Socket(xmppHost, xmppPort);
            xmpp = new StreamComponent(new JID("", pushJid, ""), socket.getInputStream(), socket.getOutputStream(), xmppPushPassword);
            xmpp.addChildParser(new JuickMessage());
            xmpp.addListener((Stream.StreamListener) this);
            xmpp.addListener((MessageListener) this);

            service.submit(() -> xmpp.startParsing());

            logger.info("Notifications initialized");
        } catch (Exception e) {
            logger.error("Notifications initialization error", e);
        }
    }

    @Override
    public void destroy() {
        ThreadHelper.shutdownAndAwaitTermination(service);

        logger.info("component destroyed");
    }

    @Override
    public void onStreamReady() {
        logger.info("XMPP STREAM READY");
    }

    @Override
    public void onStreamFail(final Exception e) {
        logger.error("XMPP STREAM FAIL", e);
    }

    @Override
    public void onMessage(final com.juick.xmpp.Message msg) {
        JuickMessage jmsg = (JuickMessage) msg.getChild(JuickMessage.XMLNS);
        boolean isPM = jmsg.getMID() == 0;
        boolean isReply = jmsg.getRID() > 0;
        int pmTo = 0;

        /*** ANDROID ***/
        final List<String> regids = new ArrayList<>();
        if (isPM) {
            regids.addAll(rest.exchange(String.format("http://api.juick.com/notifications?type=gcm&uid=%s",
                    jmsg.getUser().getUID()),
                    HttpMethod.GET, null, new ParameterizedTypeReference<List<String>>() {
                    }).getBody());
        } else {
            regids.addAll(rest.exchange(String.format("http://api.juick.com/notifications?type=gcm&uid=%s&mid=%s",
                    jmsg.getUser().getUID(), jmsg.getMID()),
                    HttpMethod.GET, null, new ParameterizedTypeReference<List<String>>() {
                    }).getBody());
        }

        if (!regids.isEmpty()) {
            MessageSerializer messageSerializer = new MessageSerializer();
            String json = messageSerializer.serialize(jmsg).toString();
            logger.info(json);
            Message message = new Message.Builder().addData("message", json).build();
            try {
                MulticastResult result = GCMSender.send(message, regids, 3);
                List<Result> results = result.getResults();
                for (int i = 0; i < results.size(); i++) {
                    logger.info("RES " + i + ": " + results.get(i).toString());
                }
            } catch (IOException e) {
                logger.error(e.getMessage(), e);
            } catch (IllegalArgumentException err) {
                logger.warn("Android: Invalid API Key");
            }
        } else {
            logger.info("GMS: no recipients");
        }

        /*** WinPhone ***/
        final List<String> urls = new ArrayList<>();
        if (isPM) {
            urls.addAll(rest.exchange(String.format("http://api.juick.com/notifications?type=mpns&uid=%s",
                    jmsg.getUser().getUID()),
                    HttpMethod.GET, null, new ParameterizedTypeReference<List<String>>() {
                    }).getBody());
        } else {
            urls.addAll(rest.exchange(String.format("http://api.juick.com/notifications?type=mpns&uid=%s&mid=%s",
                    jmsg.getUser().getUID(), jmsg.getMID()),
                    HttpMethod.GET, null, new ParameterizedTypeReference<List<String>>() {
                    }).getBody());
        }

        if (urls.isEmpty()) {
            logger.info("WNS: no recipients");
        } else {
            try {
                String wnsToken = getWnsAccessToken();
                String text1 = "@" + jmsg.getUser().getUName();
                if (!jmsg.Tags.isEmpty()) {
                    text1 += ":" + XmlUtils.escape(jmsg.getTagsString());
                }
                String text2 = XmlUtils.escape(jmsg.getText());
                String xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
                        + "<toast>"
                        + "<visual>"
                        + "<binding template=\"ToastImageAndText02\">"
                        + "<image id=\"1\" src=\"http://i.juick.com/as/" + jmsg.getUser().getUID() + ".png\" />"
                        + "<text id=\"1\">" + text1 + "</text>"
                        + "<text id=\"2\">" + text2 + "</text>"
                        + "</binding>"
                        + "</visual>"
                        + "<commands>"
                        + "<command arguments=\"?mid=" + jmsg.getMID() + "\" />"
                        + "</commands>"
                        + "</toast>";
                logger.trace(xml);
                for (String url : urls) {
                    logger.info("WNS: " + url);
                    sendWNS(wnsToken, url, xml);
                }
            } catch (IOException | IllegalStateException e) {
                logger.error("WNS: ", e);
            }
        }

        /*** iOS ***/
        final List<String> tokens = new ArrayList<>();
        if (isPM) {
            tokens.addAll(rest.exchange(String.format("http://api.juick.com/notifications?type=apns&uid=%s",
                    jmsg.getUser().getUID()),
                    HttpMethod.GET, null, new ParameterizedTypeReference<List<String>>() {
                    }).getBody());
        } else {
            tokens.addAll(rest.exchange(String.format("http://api.juick.com/notifications?type=apns&uid=%s&mid=%s",
                    jmsg.getUser().getUID(), jmsg.getMID()),
                    HttpMethod.GET, null, new ParameterizedTypeReference<List<String>>() {
                    }).getBody());
        }
        if (!tokens.isEmpty()) {
            ApnsService service = APNS.newService().withCert("/etc/juick/ios.p12", "juick")
                    .withSandboxDestination().build();
            for (String token : tokens) {
                String payload = APNS.newPayload().alertTitle("@" + jmsg.getUser().getUName()).alertBody(jmsg.getText()).build();
                logger.info("APNS: " + token);
                service.push(token, payload);
            }
        } else {
            logger.info("APNS: no recipients");
        }
    }

    String getWnsAccessToken() throws IOException, IllegalStateException {
        if (TextUtils.isEmpty(wns_application_sip)) {
            throw new IllegalStateException("'wns_application_sip' is not initialized");
        }
        if (TextUtils.isEmpty(wns_client_secret)) {
            throw new IllegalStateException("'wns_client_secret' is not initialized");
        }
        HttpClient client = HttpClientBuilder.create().build();
        String url = "https://login.live.com/accesstoken.srf";
        List<NameValuePair> formParams = new ArrayList<>();
        formParams.add(new BasicNameValuePair("grant_type", "client_credentials"));
        formParams.add(new BasicNameValuePair("client_id", wns_application_sip));
        formParams.add(new BasicNameValuePair("client_secret", wns_client_secret));
        formParams.add(new BasicNameValuePair("scope", "notify.windows.com"));
        UrlEncodedFormEntity entity = new UrlEncodedFormEntity(formParams, Consts.UTF_8);
        HttpPost httppost = new HttpPost(url);
        httppost.setEntity(entity);
        HttpResponse response = client.execute(httppost);
        int statusCode = response.getStatusLine().getStatusCode();
        String responseContent = EntityUtils.toString(response.getEntity(), Consts.UTF_8);
        JSONObject json = new JSONObject(responseContent);
        if (statusCode != 200) {
            throw new IOException(json.opt("error") + ": " + json.opt("error_description"));
        }
        String tokenType = (String) json.get("token_type");
        if (tokenType.length() >= 1) {
            tokenType = Character.toUpperCase(tokenType.charAt(0)) + tokenType.substring(1);
        }
        return tokenType + " " + json.get("access_token");
    }

    void sendWNS(final String wnsToken, final String url, final String xml) throws IOException {
        HttpClient client = HttpClientBuilder.create().build();
        StringEntity entity = new StringEntity(xml, Consts.UTF_8);
        HttpPost httpPost = new HttpPost(url);
        httpPost.setHeader("Content-Type", "text/xml");
        httpPost.setHeader("Authorization", wnsToken);
        httpPost.setHeader("X-WNS-Type", "wns/toast");
        httpPost.setEntity(entity);
        HttpResponse response = client.execute(httpPost);
        int statusCode = response.getStatusLine().getStatusCode();
        if (statusCode != 200) {
            String headersContent = stringifyWnsHttpHeaders(response.getAllHeaders());
            throw new IOException(headersContent);
        }
    }

    static String stringifyWnsHttpHeaders(final Header[] allHeaders) {
        String[] wnsHeaders = Arrays.stream(allHeaders)
                .filter(x -> x.getName().startsWith("X-WNS-") || x.getName().startsWith("WWW-"))
                .map(x -> x.getName() + ": " + x.getValue())
                .toArray(String[]::new);
        return String.join("\n", wnsHeaders);
    }
}