node-pushnotifications

Node Push Notifications

A node.js module for interfacing with Apple Push Notification, Google Cloud Messaging, Windows Push Notification and Amazon Device Messaging services.

NOTE: Version 1.x has completely been redesigned to be compatible with new apn 2.x and written in es6. Tests have been implemented.

Installation

npm install node-pushnotifications --save

Features

• Powerful and intuitive.
• Multi platform push notifications.
• Automatically detects destination device type.
• Unified error handling.
• Compatible with ES5 through babel transpilation.

Usage

1. Import and setup push module:

const settings = {
    gcm: {
        id: null,
        ...
    },
    apn: {
        cert: 'cert.pem',
        key: 'key.pem',
        ...
    },
    adm: {
        client_id: null,
        client_secret: null,
        ...
    },
    wns: {
        client_id: null,
        client_secret: null,
        notificationMethod: 'sendTileSquareBlock',
        ...
    }
};
const PushNotifications = new require('node-pushnotifications');
const push = new PushNotifications(settings);

• GCM and ADM options: see node-gcm
• APN options: see node-apn
• ADM options: see node-gcm
• WNS options: see wns

iOS: It is recomended to use provider authentication tokens. However, you can also use certificates. See node-apn to see how to prepare cert.pem and key.pem.

### 2. Define destination device ID. You can send to multiple devices, independently of platform, creating an array with different destination device IDs.

// Single destination
const registrationIds = 'INSERT_YOUR_DEVICE_ID';

// Multiple destinations
const registrationIds = [];
registrationIds.push('INSERT_YOUR_DEVICE_ID');
registrationIds.push('INSERT_OTHER_DEVICE_ID');

3. Create a JSON object with a title and message and send the notification.

const data = {
  title: 'New push notification',
  body: 'Powered by AppFeel',
};
push.send(registrationIds, data, (err, result) => {
    if (err) {
        console.log(err);
    } else {
	    console.log(result);
    }
});

// Or you could use it as a promise:
push.send(registrationIds, data)
    .then((results) => { ... })
    .catch((err) => { ... });

err will be null if all went fine, will return the error otherwise. Result will contain an array with the following objects:

[
    {
        method: 'gcm', // The method used send notifications and which this info is related to
        multicastId: [], // (only Android) Array with unique ID (number) identifying the multicast message, one identifier for each chunk of 1.000 notifications)
        success: 0, // Number of notifications that have been successfully sent. It does not mean that the notification has been deliveried.
        failure: 0, // Number of notifications that have been failed to be send.
        message: [{
            messageId: '', // (only for android) String specifying a unique ID for each successfully processed message or undefined if error
            regId: value, // The registrationId
            error: new Error('unknown'), // If any there will be an Error object here
        }],
    },
    {
        method: 'apn',
        ... // Same structure here
    },
    ...
]

GCM

NOTE If you provide more than 1.000 registration tokens, they will automatically be splitted in 1.000 chunks (see this issue in gcm repo) The following parameters are used to create a GCM message. See https://developers.google.com/cloud-messaging/http-server-ref#table5 for more info:

{
    collapseKey: data.collapseKey,
    priority: data.priority,
    contentAvailable: data.contentAvailable || false,
    delayWhileIdle: data.delayWhileIdle || false, // Deprecated from Nov 15th 2016 (will be ignored)
    timeToLive: data.expiry - Math.floor(Date.now() / 1000) || data.timeToLive || 28 * 86400,
    restrictedPackageName: data.restrictedPackageName,
    dryRun: data.dryRun || false,
    data: data.custom,
    notification: {
        title: data.title, // Android, iOS (Watch)
        body: data.body, // Android, iOS
        icon: data.icon, // Android
        sound: data.sound, // Android, iOS
        badge: data.badge, // iOS
        tag: data.tag, // Android
        color: data.color, // Android
        click_action: data.clickAction || data.category, // Android, iOS
        body_loc_key: data.locKey, // Android, iOS
        body_loc_args: data.locArgs, // Android, iOS
        title_loc_key: data.titleLocKey, // Android, iOS
        title_loc_args: data.titleLocArgs, // Android, iOS
    },
}

• See node-gcm fields

APN

The following parameters are used to create an APN message:

{
    retryLimit: data.retries || -1,
    expiry: data.expiry || ((data.timeToLive || 28 * 86400) + Math.floor(Date.now() / 1000)),
    priority: data.priority,
    encoding: data.encoding,
    payload: data.custom,
    badge: data.badge,
    sound: data.sound || 'ping.aiff',
    alert: data.alert || {
        title: data.title,
        body: data.body,
        'title-loc-key': data.titleLocKey,
        'title-loc-args': data.titleLocArgs,
        'loc-key': data.locKey,
        'loc-args': data.locArgs,
        'launch-image': data.launchImage,
        action: data.action,
    },
    topic: data.topic || '',
    category: data.category || data.clickAction,
    contentAvailable: data.contentAvailable,
    mdm: data.mdm,
    urlArgs: data.urlArgs,
    truncateAtWordEnd: data.truncateAtWordEnd,
}

• See apn fields

ADM

The following parameters are used to create an ADM message:

const data = Object.assign({}, _data); // _data is the data passed as method parameter
const consolidationKey = data.consolidationKey;
const expiry = data.expiry;
const timeToLive = data.timeToLive;

delete data.consolidationKey;
delete data.expiry;
delete data.timeToLive;

const ADMmesssage = {
    expiresAfter: expiry - Math.floor(Date.now() / 1000) || timeToLive || 28 * 86400,
    consolidationKey,
    data,
};

• See node-adm fields

WNS

The following fields are used to create a WNS message:

const notificationMethod = settings.wns.notificationMethod;
const opts = Object.assign({}, settings.wns);
opts.headers = data.headers || opts.headers;
opts.launch = data.launch || opts.launch;
opts.duration = data.duration || opts.duration;

delete opts.notificationMethod;
delete data.headers;
delete data.launch;
delete data.duration;

wns[notificationMethod](regId, data, opts, (err, response) => { ... });

• See wns optional fileds Note: Please take in mind that if data.accessToken is supplied then each push notification will be sent after the previous one has been responded. This is due to the fact that in the response while sending a push notification it is possible that Microsoft servers responds with a new accessToken and it should be used for next requests. This can slow down the whole process.

##Resources

• Node Push Notify from alexlds
• Google Cloud Messaging setup guide
• Apple Push Notification setup guide Part 1
• Apple Push Notification setup guide Part 2

Made in Barcelona with <3 and Code