UserPushSubscription.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2019 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * 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 org.turro.push;
 
import java.io.IOException;
import java.io.StringReader;
import java.security.GeneralSecurityException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.Security;
import java.security.spec.InvalidKeySpecException;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.json.Json;
import javax.json.JsonObject;
import javax.json.JsonReader;
import org.turro.string.Strings;
import org.apache.hc.core5.http.HttpResponse;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.jose4j.lang.JoseException;
import org.turro.auth.Authentication;
import org.turro.collections.KeyValueMap;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.context.IConstructor;
import org.turro.elephant.db.ElephantPU;
import org.turro.elephant.direct.AbstractDirect;
import org.turro.elephant.direct.DirectContent;
import org.turro.elephant.entities.db.PushSubscription;
import org.turro.lock.Initializer;
import org.turro.push.security.ServerKeys;
import org.turro.push.service.Notification;
import org.turro.push.service.PushService;
import org.turro.push.service.Subscription;
import org.turro.sql.SqlClause;
 
@DirectContent(identifier="push-subscription")
public class UserPushSubscription extends AbstractDirect {
 
  // https://web-push-book.gauntface.com/
  
  public static void pushMessage(String idContact, String payload) {
    subscriptions(idContact).forEach(pushSubscription -> {
      pushMessage(pushSubscription, payload);
    });
  }
 
  public static void pushMessage(PushSubscription pushSubscription, String payload) {
    try {          
      PushService pushService = instance();
      Subscription.Keys keys = new Subscription.Keys(
              pushSubscription.getPublicKey(), pushSubscription.getPrivateKey());
      Subscription subscription = new Subscription(pushSubscription.getEndpoint(), keys);
      Notification notification = new Notification(subscription, payload);
      HttpResponse response = pushService.send(notification);
      if(REMOVE_RESPONSES.contains(response.getCode())) {
        removeSubscription(pushSubscription);
      }
    } catch (NoSuchAlgorithmException | NoSuchProviderException | InvalidKeySpecException ex) {
      Logger.getLogger(UserPushSubscription.class.getName()).log(Level.SEVERE, null, ex);
    } catch (GeneralSecurityException | IOException | JoseException | ExecutionException | InterruptedException ex) {
      Logger.getLogger(UserPushSubscription.class.getName()).log(Level.SEVERE, null, ex);
    }
  }
 
  /* DirectContent */
  
  public UserPushSubscription() {
  }
  
  @Override
  protected String getIdentifier() {
    return UserPushSubscription.class.getAnnotation(DirectContent.class).identifier();
  }
 
  @Override
  protected void doExecute(IConstructor constructor, KeyValueMap map) {
    if(map.containsKey("json")) {
      JsonReader reader = Json.createReader(new StringReader(map.get("json")));
      JsonObject subs = reader.readObject();
      JsonObject keys = subs.getJsonObject("keys");
      PushSubscription subscription = new PushSubscription();
      subscription.setContactId(Authentication.getIContact().getId());
      subscription.setEndpoint(subs.getString("endpoint"));
      subscription.setPrivateKey(keys.getString("auth"));
      subscription.setPublicKey(keys.getString("p256dh"));
      new ElephantPU().saveObject(subscription);
      pushMessage(subscription, PushMessage.title("Welcome")
              .message("Successfully subscribed on this device")
              .click(ElephantContext.getServerUrl("http")).json());
    }
  }
 
  private static List<PushSubscription> subscriptions(String idContact) {
    return SqlClause.select("ps").from("PushSubscription ps")
            .startIf(!Strings.isBlank(idContact))
            .where().equal("ps.contactId", idContact)
            .endIf()
            .dao(new ElephantPU())
            .resultList(PushSubscription.class);
  }
  
  private static void removeSubscription(PushSubscription subscription) {
    new ElephantPU().deleteObject(subscription);
  }
  
  /* Factory */
  
  private static final Initializer<PushService> PUSH_SERVICE = new Initializer<>();
  
  public static PushService instance() {
    return PUSH_SERVICE.instance(() -> {
      Security.addProvider(new BouncyCastleProvider());
      try {
        return new PushService(
                ServerKeys.publicKey(),
                ServerKeys.privateKey(),
                "mailto:lluis@turro.org");
      } catch (GeneralSecurityException ex) {
        Logger.getLogger(UserPushSubscription.class.getName()).log(Level.SEVERE, null, ex);
        return null;
      }
    });
  }
  
  private static final Set<Integer> REMOVE_RESPONSES = Set.of(401, 404, 410);
  
}