@gapi/onesignal-notifications 1.8.122

package/.prettierrc

@@ -0,0 +1,4 @@
+{
+    "singleQuote": true,
+    "printWidth": 80
+}

package/README.md

@@ -0,0 +1,108 @@
+# @gapi/onesignal-notifications
+
+#### @Gapi OneSignal Notifications module @StrongTyped forked and re-written with typescript from [onesignal-node](https://github.com/KolektifLabs/onesignal-node)
+
+##### For questions/issues you can write ticket [here](http://gitlab.youvolio.com/gapi/onesignal-notifications/issues)
+##### This module is intended to be used with [GAPI](https://github.com/Stradivario/gapi)
+
+## Installation and basic examples:
+##### To install this Gapi module, run:
+
+```bash
+$ npm install @gapi/onesignal-notifications
+```
+
+## Consuming @gapi/onesignal-notifications
+
+##### Import inside AppModule or CoreModule
+```typescript
+
+import { Module } from '@rxdi/core';
+import { OneSignalModule } from '@gapi/onesignal-notifications';
+
+@Module({
+    imports: [
+        OneSignalModule.forRoot({
+            userAuthKey: 'ZmY2YjVkMjMtMjY0OC00Y2E2LTkxBTQtYTVmOWY1MmJhZDg1',
+            app: {
+                appAuthKey: 'MTa4NGIzNjQtNGFkMy00MzY4AWJjZTctNzNjYzYyODgzZDhh',
+                appId: 'd856cd4h-f834-42cb-b541-22ee20bcf499'
+            }
+        })
+    ],
+    services: [NotificationService],
+    effects: [YourCustomEffects]
+})
+export class CoreModule { }
+```
+
+##### Create NotificationService
+
+```typescript
+
+import { Service } from '@rxdi/core';
+import { PurchasesType } from '../../../purchases/types/purchases.type';
+import { OneSignalClientService, Notification } from '@gapi/onesignal-notifications';
+
+@Service()
+export class NotificationService {
+
+    constructor(
+        private client: OneSignalClientService
+    ) { }
+
+    async createNotification(purchaseData: PurchasesType) {
+        const notification: Notification = new Notification({
+            contents: {
+                en: 'Test notification',
+                tr: 'Test mesajı',
+                bg: 'Съобщение за проба'
+            }
+        });
+        notification.setTargetDevices(['b188dd55-7c70-4072-b696-8b66a56f9c4c']);
+        notification.setParameter('data', { type: 'notification-created', data: {} });
+        return await this.client.sendNotification(notification);
+    }
+
+    async sendNotification() {
+        const firstNotification = new Notification({
+            contents: {
+                en: 'Test notification',
+                tr: 'Test mesajı',
+                bg: 'Съобщение за проба'
+            }
+        });
+        firstNotification.setTargetDevices(['b188dd55-7c70-4072-b696-8b66a56f9c4c']);
+        firstNotification.setParameter('data', { 'abc': '123', 'foo': 'bar' });
+        return await this.client.sendNotification(firstNotification);
+    }
+
+}
+
+```
+
+##### Then use it inside your Gapi Application for example inside Effects:
+
+```typescript
+
+import { OfType, Effect } from '@rxdi/core';
+import { GapiPubSubService } from '@gapi/core';
+import { EffectTypes } from '../core/api-introspection/EffectTypes';
+import { NotificationService } from '../core/services/notification/notification.service';
+
+@Effect()
+export class YourCustomEffects {
+
+    constructor(
+        private notificationService: NotificationService
+    ) {}
+
+    @OfType<EffectTypes>(EffectTypes.myevent)
+    async myEventTrigger(result, {payload}, context) {
+        await this.notificationService.createNotification(result);
+    }
+}
+```
+
+More detailed [DOCUMENTATION](https://github.com/KolektifLabs/onesignal-node) you can find inside original onesignal-node module 
+Enjoy ! :)

package/dist/client.d.ts

@@ -0,0 +1,61 @@
+import { OneSignalClient } from './interfaces/client';
+import { SendNotificationResponse } from './interfaces/notificationResponse';
+import { Notification } from './notification';
+import { OneSignalConfig } from './onesignal.config';
+export interface DevicesData<T> {
+    players: Player<T>[];
+}
+export interface Player<T> {
+    id: string;
+    identifier: string;
+    session_count: number;
+    language: string;
+    timezone: number;
+    game_version: string;
+    device_os: string;
+    device_type: number;
+    device_model: string;
+    ad_id: string;
+    tags: T;
+    last_active: number;
+    playtime: number;
+    amount_spend: number;
+    created_at: number;
+    invalid_identifier: boolean;
+    badge_count: number;
+    sdk: string;
+    test_type: any;
+    ip: any;
+}
+export declare class OneSignalClientService implements OneSignalClient {
+    API_URI: string;
+    app: any;
+    apps: any;
+    userAuthKey: string;
+    constructor(credentials: OneSignalConfig);
+    basicRequest(url: string, apiKey: string, method: 'PUT' | 'POST' | 'GET' | 'DELETE', body: any): Promise<any>;
+    setRootUrl(rootUrl: string): void;
+    setApp(app: any): void;
+    sendNotification(notification: Notification): Promise<SendNotificationResponse>;
+    cancelNotification(notificationId: string): Promise<any>;
+    viewNotification(notificationId: string): Promise<any>;
+    viewNotifications(query: {
+        limit: number;
+        offset: number;
+    }): Promise<any>;
+    viewApps(): Promise<any>;
+    viewApp(appId: string): Promise<any>;
+    createApp(body: any): Promise<any>;
+    updateApp(body: any): Promise<any>;
+    viewDevices<T>(query: {
+        limit: number;
+        offset: number;
+    }): Promise<{
+        data: DevicesData<T>;
+    }>;
+    viewDevice(deviceId: string): Promise<any>;
+    addDevice(body: any): Promise<any>;
+    editDevice(deviceId: string, body: any): Promise<any>;
+    trackOpen(notificationId: string, body: any): Promise<any>;
+    csvExport(body: any): Promise<any>;
+}

package/dist/client.js

@@ -0,0 +1,272 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneSignalClientService = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const core_1 = require("@rxdi/core");
+const request = require("request");
+const constants_1 = require("./constants");
+const onesignal_config_1 = require("./onesignal.config");
+function checkCredential(credentialName, credential) {
+    const ALLOWED_CREDENTIALS = [
+        { name: 'userAuthKey', type: 'string' },
+        { name: 'app', type: 'object', requiredFields: ['appAuthKey', 'appId'] },
+        { name: 'apps', type: 'object' },
+    ];
+    for (let i = 0; i < ALLOWED_CREDENTIALS.length; i++) {
+        if (ALLOWED_CREDENTIALS[i].name === credentialName) {
+            if (typeof credential !== ALLOWED_CREDENTIALS[i].type) {
+                throw new Error(credentialName + ' must be a ' + ALLOWED_CREDENTIALS[i].type);
+            }
+            if (ALLOWED_CREDENTIALS[i].requiredFields) {
+                for (let j = 0; j < ALLOWED_CREDENTIALS[i].requiredFields.length; j++) {
+                    if (!(ALLOWED_CREDENTIALS[i].requiredFields[j] in credential)) {
+                        throw new Error(credentialName +
+                            ' must contain ' +
+                            ALLOWED_CREDENTIALS[i].requiredFields[j]);
+                    }
+                }
+            }
+            return true;
+        }
+    }
+    return false;
+}
+let OneSignalClientService = class OneSignalClientService {
+    constructor(credentials) {
+        if (typeof credentials !== 'object') {
+            throw new Error('credentials parameter must be a JSON object');
+        }
+        this.API_URI = constants_1.Constants.API_ROOT;
+        for (const key in credentials) {
+            if (credentials.hasOwnProperty(key) &&
+                checkCredential(key, credentials[key])) {
+                this[key] = credentials[key];
+            }
+        }
+    }
+    basicRequest(url, apiKey, method, body) {
+        const options = {
+            url: url,
+            method: method,
+        };
+        if (apiKey) {
+            options.headers = {
+                'Content-Type': 'application/json; charset=utf-8',
+                Authorization: 'Basic ' + apiKey,
+            };
+        }
+        if (body) {
+            options.body = body;
+            options.json = true;
+        }
+        return new Promise(function (resolve, reject) {
+            request(options, function (err, httpResponse, data) {
+                if (err) {
+                    return reject(err);
+                }
+                return resolve({ httpResponse: httpResponse, data: data });
+            });
+        });
+    }
+    setRootUrl(rootUrl) {
+        if (!rootUrl) {
+            throw new Error('You must set a valid rootUsrl.');
+        }
+        this.API_URI = rootUrl;
+    }
+    setApp(app) {
+        checkCredential('app', app);
+        this.app = app;
+    }
+    sendNotification(notification) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!notification || !notification.postBody) {
+                throw new Error('notification parameter must be a typeof Notification object.');
+            }
+            const postBody = notification.postBody;
+            if (this.apps && this.apps.length > 0) {
+                postBody.app_ids = this.apps;
+                return yield this.basicRequest(this.API_URI + constants_1.Constants.NOTIFICATIONS_PATH, this.userAuthKey, 'POST', postBody);
+            }
+            if (this.app) {
+                postBody.app_id = this.app.appId;
+                return yield this.basicRequest(this.API_URI + constants_1.Constants.NOTIFICATIONS_PATH, this.app.appAuthKey, 'POST', postBody);
+            }
+            throw new Error('You must set either an "app" or "apps" on Client');
+        });
+    }
+    cancelNotification(notificationId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.app) {
+                throw new Error('You must define an "app" object.');
+            }
+            const notificationUri = this.API_URI +
+                constants_1.Constants.NOTIFICATIONS_PATH +
+                '/' +
+                notificationId +
+                '?app_id=' +
+                this.app.appId;
+            return yield this.basicRequest(notificationUri, this.app.appAuthKey, 'DELETE', null);
+        });
+    }
+    viewNotification(notificationId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.app) {
+                throw new Error('You must define an "app" object.');
+            }
+            const notificationUri = this.API_URI +
+                constants_1.Constants.NOTIFICATIONS_PATH +
+                '/' +
+                notificationId +
+                '?app_id=' +
+                this.app.appId;
+            return yield this.basicRequest(notificationUri, this.app.appAuthKey, 'GET', null);
+        });
+    }
+    viewNotifications(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.app) {
+                throw new Error('You must define an "app" object.');
+            }
+            const appUri = this.API_URI +
+                constants_1.Constants.NOTIFICATIONS_PATH +
+                '?app_id=' +
+                this.app.appId +
+                '&' +
+                query;
+            return yield this.basicRequest(appUri, this.app.appAuthKey, 'GET', null);
+        });
+    }
+    viewApps() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.userAuthKey) {
+                throw new Error('You must define "userAuthKey" on Client');
+            }
+            return yield this.basicRequest(this.API_URI + constants_1.Constants.APPS_PATH, this.userAuthKey, 'GET', null);
+        });
+    }
+    viewApp(appId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.userAuthKey) {
+                throw new Error('You must define "userAuthKey" on Client');
+            }
+            return yield this.basicRequest(this.API_URI + constants_1.Constants.APPS_PATH + '/' + appId, this.userAuthKey, 'GET', null);
+        });
+    }
+    createApp(body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!body.name) {
+                throw new Error('You must specify a name in body');
+            }
+            if (!this.userAuthKey) {
+                throw new Error('You must define "userAuthKey" on Client');
+            }
+            return yield this.basicRequest(this.API_URI + constants_1.Constants.APPS_PATH, this.userAuthKey, 'POST', body);
+        });
+    }
+    updateApp(body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.app) {
+                throw new Error('You must define an "app" object.');
+            }
+            if (!this.userAuthKey) {
+                throw new Error('You must define "userAuthKey" on Client');
+            }
+            return yield this.basicRequest(this.API_URI + constants_1.Constants.APPS_PATH + '/' + this.app.appId, this.userAuthKey, 'PUT', body);
+        });
+    }
+    viewDevices(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.app) {
+                throw new Error('You must define an "app" object.');
+            }
+            const viewUri = this.API_URI +
+                constants_1.Constants.DEVICES_PATH +
+                '?app_id=' +
+                this.app.appId +
+                '&' +
+                query;
+            return yield this.basicRequest(viewUri, this.app.appAuthKey, 'GET', null);
+        });
+    }
+    viewDevice(deviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.app) {
+                throw new Error('You must define an "app" object.');
+            }
+            const viewUri = this.API_URI +
+                constants_1.Constants.DEVICES_PATH +
+                '/' +
+                deviceId +
+                '?app_id=' +
+                this.app.appId;
+            return yield this.basicRequest(viewUri, this.app.appAuthKey, 'GET', null);
+        });
+    }
+    addDevice(body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.app) {
+                throw new Error('You must define an "app" object.');
+            }
+            if (!('app_id' in body)) {
+                body.app_id = this.app.appId;
+            }
+            return yield this.basicRequest(this.API_URI + constants_1.Constants.DEVICES_PATH, this.app.appAuthKey, 'POST', body);
+        });
+    }
+    editDevice(deviceId, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.app) {
+                throw new Error('You must define an "app" object.');
+            }
+            return yield this.basicRequest(this.API_URI + constants_1.Constants.DEVICES_PATH + '/' + deviceId, this.app.appAuthKey, 'PUT', body);
+        });
+    }
+    trackOpen(notificationId, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.app) {
+                throw new Error('You must define an "app" object.');
+            }
+            if (!('app_id' in body)) {
+                body.app_id = this.app.appId;
+            }
+            return yield this.basicRequest(this.API_URI + constants_1.Constants.NOTIFICATIONS_PATH + '/' + notificationId, this.app.appAuthKey, 'PUT', body);
+        });
+    }
+    csvExport(body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.app) {
+                throw new Error('You must define an "app" object.');
+            }
+            const csvUri = this.API_URI +
+                constants_1.Constants.DEVICES_PATH +
+                '/csv_export' +
+                '?app_id=' +
+                this.app.appId;
+            return yield this.basicRequest(csvUri, this.app.appAuthKey, 'POST', body);
+        });
+    }
+};
+OneSignalClientService = __decorate([
+    core_1.Service(),
+    __metadata("design:paramtypes", [onesignal_config_1.OneSignalConfig])
+], OneSignalClientService);
+exports.OneSignalClientService = OneSignalClientService;