@eso-status/service-alerts 1.0.8 → 2.0.0-dev.0

package/lib/identifier/slug.identifier.d.ts

@@ -0,0 +1,89 @@
+import SlugMatch from './slug.match';
+/**
+ * Class for identifying the list of slugs contained in an announcement
+ */
+export default class SlugIdentifier {
+    private readonly raw;
+    /**
+     * List of slug information found in the announcement
+     */
+    slugMatches: SlugMatch[];
+    /**
+     * List of slugs to check for presence in the announcement
+     * @private
+     */
+    private readonly slugList;
+    /**
+     * List of indicators proving that the announcement pertains to the slug server_pc_eu
+     * @private
+     */
+    private readonly ServerPcEuMatchesList;
+    /**
+     * List of indicators proving that the announcement pertains to the slug server_ps_eu
+     * @private
+     */
+    private readonly ServerPsEuMatchesList;
+    /**
+     * List of indicators proving that the announcement pertains to the slug server_xbox_eu
+     * @private
+     */
+    private readonly ServerXboxEuMatchesList;
+    /**
+     * List of indicators proving that the announcement pertains to the slug server_pc_na
+     * @private
+     */
+    private readonly ServerPcNaMatchesList;
+    /**
+     * List of indicators proving that the announcement pertains to the slug server_ps_na
+     * @private
+     */
+    private readonly ServerPsNaMatchesList;
+    /**
+     * List of indicators proving that the announcement pertains to the slug server_xbox_na
+     * @private
+     */
+    private readonly ServerXboxNaMatchesList;
+    /**
+     * List of indicators proving that the announcement pertains to the slug server_pc_pts
+     * @private
+     */
+    private readonly ServerPcPtsMatchesList;
+    /**
+     * List of indicators proving that the announcement pertains to the slug service_store_eso
+     * @private
+     */
+    private readonly ServiceStoreEsoMatchesList;
+    /**
+     * List of indicators proving that the announcement pertains to the slug service_system_account
+     * @private
+     */
+    private readonly ServiceSystemAccountMatchesList;
+    /**
+     * @param raw Raw data of the announcement
+     */
+    constructor(raw: string);
+    /**
+     * Method for retrieving the list of indicators for a slug to test
+     * @param slug Slug to test
+     * @private
+     */
+    private getMatchList;
+    /**
+     * Method for retrieving the name of the list of indicators for a slug to test
+     * @param slug Slug to test
+     * @private
+     */
+    private static getMatchListName;
+    /**
+     * Method for retrieving the indicators of a slug present in the announcement
+     * @param slug Slug to test
+     * @private
+     */
+    private getMatches;
+    /**
+     * Method for testing if the announcement contains indicators of a given slug
+     * @param slug Slug to test
+     * @private
+     */
+    private identify;
+}

package/lib/identifier/slug.identifier.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@eso-status/types");
+const slug_match_1 = require("./slug.match");
+/**
+ * Class for identifying the list of slugs contained in an announcement
+ */
+class SlugIdentifier {
+    /**
+     * @param raw Raw data of the announcement
+     */
+    constructor(raw) {
+        this.raw = raw;
+        /**
+         * List of slugs to check for presence in the announcement
+         * @private
+         */
+        this.slugList = [
+            types_1.ServerPcEuSlug,
+            types_1.ServerPsEuSlug,
+            types_1.ServerXboxEuSlug,
+            types_1.ServerPcNaSlug,
+            types_1.ServerPsNaSlug,
+            types_1.ServerXboxNaSlug,
+            types_1.ServerPcPtsSlug,
+            types_1.ServiceStoreEsoSlug,
+            types_1.ServiceSystemAccountSlug,
+        ];
+        /**
+         * List of indicators proving that the announcement pertains to the slug server_pc_eu
+         * @private
+         */
+        this.ServerPcEuMatchesList = [
+            'The European megaservers',
+            'The European PC/Mac megaserver',
+        ];
+        /**
+         * List of indicators proving that the announcement pertains to the slug server_ps_eu
+         * @private
+         */
+        this.ServerPsEuMatchesList = [
+            'The European megaservers',
+            'The European PlayStation® megaserver',
+        ];
+        /**
+         * List of indicators proving that the announcement pertains to the slug server_xbox_eu
+         * @private
+         */
+        this.ServerXboxEuMatchesList = [
+            'The European megaservers',
+            'The European Xbox megaserver',
+            'North American and European Xbox megaservers',
+            'Xbox Live™',
+        ];
+        /**
+         * List of indicators proving that the announcement pertains to the slug server_pc_na
+         * @private
+         */
+        this.ServerPcNaMatchesList = [
+            'The North American megaservers',
+            'The North American PC/Mac megaserver',
+        ];
+        /**
+         * List of indicators proving that the announcement pertains to the slug server_ps_na
+         * @private
+         */
+        this.ServerPsNaMatchesList = [
+            'The North American megaservers',
+            'North American PlayStation® megaserver',
+        ];
+        /**
+         * List of indicators proving that the announcement pertains to the slug server_xbox_na
+         * @private
+         */
+        this.ServerXboxNaMatchesList = [
+            'The North American megaservers',
+            'The North American Xbox megaserver',
+            'North American and European Xbox megaservers',
+            'Xbox Live™',
+        ];
+        /**
+         * List of indicators proving that the announcement pertains to the slug server_pc_pts
+         * @private
+         */
+        this.ServerPcPtsMatchesList = ['PTS'];
+        /**
+         * List of indicators proving that the announcement pertains to the slug service_store_eso
+         * @private
+         */
+        this.ServiceStoreEsoMatchesList = ['ESO store'];
+        /**
+         * List of indicators proving that the announcement pertains to the slug service_system_account
+         * @private
+         */
+        this.ServiceSystemAccountMatchesList = ['account system'];
+        this.slugMatches = [];
+        this.slugList.forEach((slug) => this.identify(slug));
+    }
+    /**
+     * Method for retrieving the list of indicators for a slug to test
+     * @param slug Slug to test
+     * @private
+     */
+    getMatchList(slug) {
+        return this[SlugIdentifier.getMatchListName(slug)];
+    }
+    /**
+     * Method for retrieving the name of the list of indicators for a slug to test
+     * @param slug Slug to test
+     * @private
+     */
+    static getMatchListName(slug) {
+        return `${slug
+            .split('_')
+            .map((item) => item.charAt(0).toUpperCase() + item.slice(1))
+            .join('')}MatchesList`;
+    }
+    /**
+     * Method for retrieving the indicators of a slug present in the announcement
+     * @param slug Slug to test
+     * @private
+     */
+    getMatches(slug) {
+        return this.getMatchList(slug).filter((identifier) => this.raw.includes(identifier));
+    }
+    /**
+     * Method for testing if the announcement contains indicators of a given slug
+     * @param slug Slug to test
+     * @private
+     */
+    identify(slug) {
+        const matches = this.getMatches(slug);
+        if (!matches.length) {
+            return;
+        }
+        this.slugMatches.push(new slug_match_1.default(matches[0], slug));
+    }
+}
+exports.default = SlugIdentifier;
+//# sourceMappingURL=slug.identifier.js.map

package/lib/identifier/slug.match.d.ts

@@ -0,0 +1,26 @@
+import { Slug, Support, Type, Zone } from '@eso-status/types';
+import { RemoteRawSlug } from '../type/remoteRawSlug.type';
+/**
+ * Class for retrieving information about a slug found in an announcement
+ */
+export default class SlugMatch {
+    readonly rawSlug: RemoteRawSlug;
+    readonly slug: Slug;
+    /**
+     * @param rawSlug Data used to identify the presence of the slug in the announcement
+     * @param slug Slug found in the announcement
+     */
+    constructor(rawSlug: RemoteRawSlug, slug: Slug);
+    /**
+     * Method for retrieving the type of the slug
+     */
+    getType(): Type;
+    /**
+     * Method for retrieving the support of the slug
+     */
+    getSupport(): Support;
+    /**
+     * Method for retrieving the area of the slug
+     */
+    getZone(): Zone;
+}

package/lib/identifier/slug.match.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Class for retrieving information about a slug found in an announcement
+ */
+class SlugMatch {
+    /**
+     * @param rawSlug Data used to identify the presence of the slug in the announcement
+     * @param slug Slug found in the announcement
+     */
+    constructor(rawSlug, slug) {
+        this.rawSlug = rawSlug;
+        this.slug = slug;
+    }
+    /**
+     * Method for retrieving the type of the slug
+     */
+    getType() {
+        return this.slug.split('_')[0];
+    }
+    /**
+     * Method for retrieving the support of the slug
+     */
+    getSupport() {
+        return this.slug.split('_')[1];
+    }
+    /**
+     * Method for retrieving the area of the slug
+     */
+    getZone() {
+        return this.slug.split('_')[2];
+    }
+}
+exports.default = SlugMatch;
+//# sourceMappingURL=slug.match.js.map

package/lib/identifier/status.identifier.d.ts

@@ -0,0 +1,58 @@
+import { Status } from '@eso-status/types';
+import { RemoteRawStatus } from '../type/remoteRawStatus.type';
+/**
+ * Class for identifying the status contained in an announcement
+ */
+export default class StatusIdentifier {
+    private readonly raw;
+    /**
+     * Data used to identify the presence of the status in the announcement
+     */
+    rawStatus: RemoteRawStatus;
+    /**
+     * Status found in the announcement
+     */
+    status: Status;
+    /**
+     * List of statuses to check for presence in the announcement
+     * @private
+     */
+    private readonly statusList;
+    /**
+     * List of indicators proving that the announcement pertains to the status up
+     * @private
+     */
+    private readonly upMatchesList;
+    /**
+     * List of indicators proving that the announcement pertains to the status down
+     * @private
+     */
+    private readonly downMatchesList;
+    /**
+     * List of indicators proving that the announcement pertains to the status planned
+     * @private
+     */
+    private readonly issuesMatchesList;
+    /**
+     * @param raw Raw data of the announcement
+     */
+    constructor(raw: string);
+    /**
+     * Method for retrieving the list of indicators for a status to test
+     * @param status Status to test
+     * @private
+     */
+    private getMatchList;
+    /**
+     * Method for retrieving the indicators of a status present in the announcement
+     * @param status Status to test
+     * @private
+     */
+    private getMatches;
+    /**
+     * Method for testing if the announcement contains indicators of a given status
+     * @param status Status to test
+     * @private
+     */
+    private identify;
+}

package/lib/identifier/status.identifier.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@eso-status/types");
+/**
+ * Class for identifying the status contained in an announcement
+ */
+class StatusIdentifier {
+    /**
+     * @param raw Raw data of the announcement
+     */
+    constructor(raw) {
+        this.raw = raw;
+        /**
+         * List of statuses to check for presence in the announcement
+         * @private
+         */
+        this.statusList = [types_1.UpStatus, types_1.DownStatus, types_1.IssuesStatus];
+        /**
+         * List of indicators proving that the announcement pertains to the status up
+         * @private
+         */
+        this.upMatchesList = [
+            'currently available',
+            'been resolved',
+        ];
+        /**
+         * List of indicators proving that the announcement pertains to the status down
+         * @private
+         */
+        this.downMatchesList = [
+            'currently unavailable',
+        ];
+        /**
+         * List of indicators proving that the announcement pertains to the status planned
+         * @private
+         */
+        this.issuesMatchesList = [
+            'currently investigating issues',
+            'currently experiencing a service interruption',
+        ];
+        this.statusList.forEach((status) => this.identify(status));
+    }
+    /**
+     * Method for retrieving the list of indicators for a status to test
+     * @param status Status to test
+     * @private
+     */
+    getMatchList(status) {
+        return this[`${status}MatchesList`];
+    }
+    /**
+     * Method for retrieving the indicators of a status present in the announcement
+     * @param status Status to test
+     * @private
+     */
+    getMatches(status) {
+        return this.getMatchList(status).filter((identifier) => this.raw.includes(identifier));
+    }
+    /**
+     * Method for testing if the announcement contains indicators of a given status
+     * @param status Status to test
+     * @private
+     */
+    identify(status) {
+        const matches = this.getMatches(status);
+        if (!matches.length) {
+            return;
+        }
+        this.rawStatus = matches.shift();
+        this.status = status;
+    }
+}
+exports.default = StatusIdentifier;
+//# sourceMappingURL=status.identifier.js.map

package/lib/index.d.ts

@@ -1,15 +1,10 @@
-import { RawEsoStatus } from '@eso-status/types';
+import { EsoStatusRawData } from '@eso-status/types';
 /**
- * Class of Service Alerts
+ * Class for retrieving announcement information
  */
-export declare class ServiceAlerts {
+export default class ServiceAlerts {
     /**
-       * Methode used to get Service Alerts data
-       *
-       * @public
-       * @static
-       *
-       * @return Promise<RawEsoStatus[]> Service Alerts elements
-       */
-    static getData(): Promise<RawEsoStatus[]>;
+     * Method for retrieving announcement information
+     */
+    static getData(): Promise<EsoStatusRawData[]>;
 }

package/lib/index.js

@@ -1,77 +1,16 @@
 "use strict";
-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());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceAlerts = void 0;
-var ServiceAlertConnector_1 = require("./connectors/ServiceAlertConnector");
+const connector_1 = require("./connector");
 /**
- * Class of Service Alerts
+ * Class for retrieving announcement information
  */
-var ServiceAlerts = /** @class */ (function () {
-    function ServiceAlerts() {
-    }
+class ServiceAlerts {
     /**
-       * Methode used to get Service Alerts data
-       *
-       * @public
-       * @static
-       *
-       * @return Promise<RawEsoStatus[]> Service Alerts elements
-       */
-    ServiceAlerts.getData = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var remoteContent, filteredContent, filteredContentList, rawData, splitRawData, splitRawDataWithSlug, splitRawDataList, lastRawData;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, ServiceAlertConnector_1.default.getRemoteContent()];
-                    case 1:
-                        remoteContent = _a.sent();
-                        filteredContent = ServiceAlertConnector_1.default.getFilterContent(remoteContent);
-                        filteredContentList = ServiceAlertConnector_1.default.changeFilterContentForList(filteredContent);
-                        rawData = ServiceAlertConnector_1.default.getRawData(filteredContentList);
-                        splitRawData = ServiceAlertConnector_1.default.splitRawData(rawData);
-                        splitRawDataWithSlug = ServiceAlertConnector_1.default.getSlugOfSplitRawData(splitRawData);
-                        splitRawDataList = ServiceAlertConnector_1.default.splitRawDataList(splitRawDataWithSlug);
-                        lastRawData = ServiceAlertConnector_1.default.getLastRawData(splitRawDataList);
-                        return [2 /*return*/, ServiceAlertConnector_1.default.getData(lastRawData)];
-                }
-            });
-        });
-    };
-    return ServiceAlerts;
-}());
-exports.ServiceAlerts = ServiceAlerts;
+     * Method for retrieving announcement information
+     */
+    static async getData() {
+        return (await connector_1.default.init()).rawEsoStatus;
+    }
+}
+exports.default = ServiceAlerts;
+//# sourceMappingURL=index.js.map

package/lib/interface/esoStatusRawData.interface.d.ts

@@ -0,0 +1,54 @@
+import { Moment } from 'moment/moment';
+import { Slug, Status, Support, Type, Zone } from '@eso-status/types';
+import { RemoteRawSlug } from '../type/remoteRawSlug.type';
+import { RemoteRawStatus } from '../type/remoteRawStatus.type';
+import { SourceUrl } from '../type/sourceUrl.type';
+/**
+ * Donnée brute du status d'un server/service ESO
+ */
+export interface EsoStatusRawData {
+    /**
+     * URL de la source de la donnée
+     */
+    source: SourceUrl;
+    /**
+     * Donnée brute permettant d'identifier le server/service et son status
+     */
+    raw: string;
+    /**
+     * Status du server/service
+     */
+    status: Status;
+    /**
+     * Donnée brute ayant permis d'identifier le status
+     */
+    rawStatus: RemoteRawStatus;
+    /**
+     * Slug du server/service
+     */
+    slug: Slug;
+    /**
+     * Donnée brute ayant permis d'identifier le slug
+     */
+    rawSlug: RemoteRawSlug;
+    /**
+     * Type du server/service
+     */
+    type: Type;
+    /**
+     * Support du server/service
+     */
+    support: Support;
+    /**
+     * Zone du server/service
+     */
+    zone: Zone;
+    /**
+     * Liste des dates contenue dans l'annonce
+     */
+    dates: Moment[];
+    /**
+     * Donnée brute de la date contenue dans l'annonce
+     */
+    rawDate: string;
+}

package/lib/interface/esoStatusRawData.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=esoStatusRawData.interface.js.map

package/lib/raw.d.ts

@@ -0,0 +1,39 @@
+import { EsoStatusRawData } from './interface/esoStatusRawData.interface';
+/**
+ * Class containing announcement information
+ */
+export default class Raw {
+    private raw;
+    /**
+     * Status identification class
+     * @private
+     */
+    private readonly statusIdentifier;
+    /**
+     * Class for identifying and formatting the date(s)
+     * @private
+     */
+    private readonly dateFormatter;
+    /**
+     * Class for identifying the list of slugs
+     * @private
+     */
+    private slugsIdentifier;
+    /**
+     * List of information about slugs found in the announcement
+     */
+    matches: EsoStatusRawData[];
+    /**
+     * @param raw Raw data of the announcement
+     */
+    constructor(raw: string);
+    /**
+     * Method for formatting each slug found in the announcement to RawEsoStatus
+     * @private
+     */
+    private split;
+    /**
+     * Method for generating the RawEsoStatus object
+     */
+    private getRawEsoStatus;
+}

package/lib/raw.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const status_identifier_1 = require("./identifier/status.identifier");
+const date_formatter_1 = require("./formatter/date.formatter");
+const slug_identifier_1 = require("./identifier/slug.identifier");
+const const_1 = require("./const");
+/**
+ * Class containing announcement information
+ */
+class Raw {
+    /**
+     * @param raw Raw data of the announcement
+     */
+    constructor(raw) {
+        this.raw = raw;
+        /**
+         * List of information about slugs found in the announcement
+         */
+        this.matches = [];
+        this.statusIdentifier = new status_identifier_1.default(this.raw);
+        this.dateFormatter = new date_formatter_1.default(this.raw);
+        this.slugsIdentifier = new slug_identifier_1.default(this.raw);
+        this.split();
+    }
+    /**
+     * Method for formatting each slug found in the announcement to RawEsoStatus
+     * @private
+     */
+    split() {
+        this.matches = this.slugsIdentifier.slugMatches.map((slugMatch) => this.getRawEsoStatus(slugMatch));
+    }
+    /**
+     * Method for generating the RawEsoStatus object
+     */
+    getRawEsoStatus(slugMatch) {
+        return {
+            source: const_1.default,
+            raw: this.raw,
+            slug: slugMatch.slug,
+            type: slugMatch.getType(),
+            support: slugMatch.getSupport(),
+            zone: slugMatch.getZone(),
+            status: this.statusIdentifier.status,
+            rawStatus: this.statusIdentifier.rawStatus,
+            rawSlug: slugMatch.rawSlug,
+            rawDate: this.dateFormatter.rawDate,
+            dates: this.dateFormatter.dates,
+        };
+    }
+}
+exports.default = Raw;
+//# sourceMappingURL=raw.js.map