@etainabl/nodejs-sdk 1.2.15 → 1.2.17

package/dist/cjs/api.d.ts

@@ -0,0 +1,99 @@
+import type { AxiosRequestConfig, AxiosInstance, CreateAxiosDefaults } from 'axios';
+import type { Account, Asset, Company, Invoice, Log, Reading, Supplier } from '../types/index.js';
+export interface ETNPagedResponse<T = any> {
+    data: T[];
+    total: number;
+    limit: number;
+    skip: number;
+}
+export interface ETNReq {
+    method: string;
+    url: string;
+}
+interface AuthOptions {
+    key?: string;
+    token?: string;
+}
+declare const _default: (auth: AuthOptions, instanceOptions?: CreateAxiosDefaults) => {
+    instance: AxiosInstance;
+    getAccount: (id: string, options?: AxiosRequestConfig<any>) => Promise<Account>;
+    listAccounts: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<Account>>;
+    updateAccount: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    createAccount: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    removeAccount: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    getAccountSchema: (options?: AxiosRequestConfig<any>) => Promise<any>;
+    getAsset: (id: string, options?: AxiosRequestConfig<any>) => Promise<Asset>;
+    listAssets: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<Asset>>;
+    updateAsset: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    createAsset: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    removeAsset: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    getAssetSchema: (options?: AxiosRequestConfig<any>) => Promise<any>;
+    getAssetGroup: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    listAssetGroups: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<any>>;
+    updateAssetGroup: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    createAssetGroup: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    removeAssetGroup: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    getAssetGroupAssets: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    getAssetGroupSchema: (options?: AxiosRequestConfig<any>) => Promise<any>;
+    getAutomation: (id: string, options?: AxiosRequestConfig<any>) => Promise<Automation>;
+    listAutomations: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<Automation>>;
+    updateAutomation: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    createAutomation: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    removeAutomation: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    createAutomationLog: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    updateAutomationLog: (id: string, subId: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    removeAutomationLog: (id: string, subId: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    getCompany: (id: string, options?: AxiosRequestConfig<any>) => Promise<Company>;
+    getConsumption: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    listConsumptions: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<any>>;
+    updateConsumption: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    createConsumption: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    removeConsumption: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    getConsumptionSchema: (options?: AxiosRequestConfig<any>) => Promise<any>;
+    getEmail: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    listEmails: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<any>>;
+    updateEmail: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    createEmail: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    removeEmail: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    getEmissionFactor: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    listEmissionFactors: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<any>>;
+    updateEmissionFactor: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    createEmissionFactor: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    removeEmissionFactor: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    getLog: (id: string, options?: AxiosRequestConfig<any>) => Promise<Log>;
+    listLogs: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<Log>>;
+    updateLog: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    createLog: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    removeLog: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    getReading: (id: string, options?: AxiosRequestConfig<any>) => Promise<Reading>;
+    listReadings: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<Reading>>;
+    updateReading: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    createReading: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    removeReading: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    getReadingSchema: (options?: AxiosRequestConfig<any>) => Promise<any>;
+    getReport: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    listReports: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<any>>;
+    updateReport: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    createReport: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    removeReport: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    sendReport: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    getReportTemplate: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    listReportTemplates: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<any>>;
+    updateReportTemplate: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    createReportTemplate: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    removeReportTemplate: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    getScheduledReport: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    listScheduledReports: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<any>>;
+    updateScheduledReport: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    createScheduledReport: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    removeScheduledReport: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    sendScheduledReport: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    getInvoice: (id: string, options?: AxiosRequestConfig<any>) => Promise<Invoice>;
+    listInvoices: (options?: AxiosRequestConfig<any>) => Promise<ETNPagedResponse<Invoice>>;
+    updateInvoice: (id: string, data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    createInvoice: (data: any, options?: AxiosRequestConfig<any>) => Promise<any>;
+    removeInvoice: (id: string, options?: AxiosRequestConfig<any>) => Promise<any>;
+    getInvoiceSchema: (options?: AxiosRequestConfig<any>) => Promise<any>;
+    getSupplierSchema: (options?: AxiosRequestConfig<any>) => Promise<Supplier>;
+};
+export default _default;

package/dist/cjs/api.js

@@ -0,0 +1,303 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const https_1 = __importDefault(require("https"));
+const logger_js_1 = __importDefault(require("./logger.js"));
+const log = (0, logger_js_1.default)('etainablApi');
+function _handleResponse(req, res, isPaged = false) {
+    if (!res) {
+        throw new Error(`No response from API (${req.method} ${req.url})`);
+    }
+    if (res.status !== 200) {
+        throw new Error(`${res.status} ${res.statusText} response from API (${req.method} ${req.url})`);
+    }
+    if (!res.data) {
+        throw new Error(`No data from API (${req.method} ${req.url})`);
+    }
+    if (isPaged && !res.data.data) {
+        throw new Error(`No data from API (${req.method} ${req.url})`);
+    }
+    return res;
+}
+const factory = {
+    getWithId: (etainablApi, endpoint, postEndpoint) => (id, options = {}) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const req = {
+            method: 'GET',
+            url: `${endpoint}/${id}${postEndpoint ? `/${postEndpoint}` : ''}`
+        };
+        log.info(`API Request: ${req.method} ${process.env.ETAsINABL_API_URL}/${req.url}`);
+        let res;
+        try {
+            res = yield etainablApi.get(req.url, options);
+        }
+        catch (e) {
+            if ((_a = e.response) === null || _a === void 0 ? void 0 : _a.data)
+                throw new Error(`API error response: ${JSON.stringify(e.response.data)}`);
+            throw e;
+        }
+        console.log(`API Response: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
+        _handleResponse(req, res);
+        return res.data;
+    }),
+    get: (etainablApi, endpoint, postEndpoint) => (options = {}) => __awaiter(void 0, void 0, void 0, function* () {
+        var _b;
+        const req = {
+            method: 'GET',
+            url: `${endpoint}${postEndpoint ? `/${postEndpoint}` : ''}`
+        };
+        log.info(`API Request: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
+        let res;
+        try {
+            res = yield etainablApi.get(req.url, options);
+        }
+        catch (e) {
+            if ((_b = e.response) === null || _b === void 0 ? void 0 : _b.data)
+                throw new Error(`API error response: ${JSON.stringify(e.response.data)}`);
+            throw e;
+        }
+        console.log(`API Response: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
+        _handleResponse(req, res);
+        return res.data;
+    }),
+    list: (etainablApi, endpoint, postEndpoint) => (options = {}) => __awaiter(void 0, void 0, void 0, function* () {
+        var _c;
+        const req = {
+            method: 'GET',
+            url: `${endpoint}${postEndpoint ? `/${postEndpoint}` : ''}`
+        };
+        log.info(`API Request: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
+        let res;
+        try {
+            res = yield etainablApi.get(req.url, options);
+        }
+        catch (e) {
+            if ((_c = e.response) === null || _c === void 0 ? void 0 : _c.data)
+                throw new Error(`API error response: ${JSON.stringify(e.response.data)}`);
+            throw e;
+        }
+        console.log(`API Response: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
+        _handleResponse(req, res, true);
+        return res.data;
+    }),
+    update: (etainablApi, endpoint, postEndpoint) => (id, data, options = {}) => __awaiter(void 0, void 0, void 0, function* () {
+        var _d;
+        const req = {
+            method: 'PATCH',
+            url: `${endpoint}/${id}${postEndpoint ? `/${postEndpoint}` : ''}`
+        };
+        log.info(`API Request: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
+        let res;
+        try {
+            res = yield etainablApi.patch(req.url, data, options);
+        }
+        catch (e) {
+            if ((_d = e.response) === null || _d === void 0 ? void 0 : _d.data)
+                throw new Error(`API error response: ${JSON.stringify(e.response.data)}`);
+            throw e;
+        }
+        _handleResponse(req, res);
+        return res.data;
+    }),
+    create: (etainablApi, endpoint, postEndpoint) => (data, options = {}) => __awaiter(void 0, void 0, void 0, function* () {
+        var _e;
+        const req = {
+            method: 'POST',
+            url: `${endpoint}${postEndpoint ? `/${postEndpoint}` : ''}`
+        };
+        log.info(`API Request: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
+        let res;
+        try {
+            res = yield etainablApi.post(req.url, data, options);
+        }
+        catch (e) {
+            if ((_e = e.response) === null || _e === void 0 ? void 0 : _e.data)
+                throw new Error(`API error response: ${JSON.stringify(e.response.data)}`);
+            throw e;
+        }
+        _handleResponse(req, res);
+        return res.data;
+    }),
+    remove: (etainablApi, endpoint, postEndpoint) => (id, options = {}) => __awaiter(void 0, void 0, void 0, function* () {
+        var _f;
+        const req = {
+            method: 'DELETE',
+            url: `${endpoint}/${id}${postEndpoint ? `/${postEndpoint}` : ''}`
+        };
+        let res;
+        log.info(`API Request: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
+        try {
+            res = yield etainablApi.delete(req.url, options);
+        }
+        catch (e) {
+            if ((_f = e.response) === null || _f === void 0 ? void 0 : _f.data)
+                throw new Error(`API error response: ${JSON.stringify(e.response.data)}`);
+            throw e;
+        }
+        _handleResponse(req, res);
+        return res.data;
+    }),
+    customWithId: (etainablApi, method, endpoint, postEndpoint) => (id, data, options = {}) => __awaiter(void 0, void 0, void 0, function* () {
+        var _g;
+        const req = Object.assign({ method: method, url: `${endpoint}/${id}${postEndpoint ? `/${postEndpoint}` : ''}`, data }, options);
+        log.info(`API Request (Custom): ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
+        let res;
+        try {
+            res = yield etainablApi.request(req);
+        }
+        catch (e) {
+            if ((_g = e.response) === null || _g === void 0 ? void 0 : _g.data)
+                throw new Error(`API error response: ${JSON.stringify(e.response.data)}`);
+            throw e;
+        }
+        _handleResponse(req, res);
+        return res.data;
+    })
+};
+// ETN Sub Endpoints
+// e.g. /assets/:id/documents/:documentId
+const subFactory = {
+    // e.g. POST /assets/:id/documents
+    create: (etainablApi, endpoint, subEndpoint) => (id, data, options = {}) => __awaiter(void 0, void 0, void 0, function* () {
+        const subUrl = `${id}/${subEndpoint}`;
+        return factory.create(etainablApi, endpoint, subUrl)(data, options);
+    }),
+    // e.g. PATCH /assets/:id/documents/:documentId
+    update: (etainablApi, endpoint, subEndpoint) => (id, subId, data, options = {}) => __awaiter(void 0, void 0, void 0, function* () {
+        const subUrl = `${subEndpoint}/${subId}`;
+        return factory.update(etainablApi, endpoint, subUrl)(id, data, options);
+    }),
+    // e.g. DELETE /assets/:id/documents/:documentId
+    remove: (etainablApi, endpoint, subEndpoint) => (id, subId, options = {}) => __awaiter(void 0, void 0, void 0, function* () {
+        const subUrl = `${subEndpoint}/${subId}`;
+        return factory.remove(etainablApi, endpoint, subUrl)(id, options);
+    })
+};
+exports.default = (auth, instanceOptions = {}) => {
+    try {
+        const headers = {};
+        if (auth.key) {
+            headers['x-key'] = auth.key;
+        }
+        else if (auth.token) {
+            headers['Authorization'] = auth.token;
+        }
+        else {
+            headers['x-key'] = process.env.ETAINABL_API_KEY;
+        }
+        const etainablApi = axios_1.default.create(Object.assign({ baseURL: process.env.ETAINABL_API_URL, timeout: 300000, httpsAgent: new https_1.default.Agent({ keepAlive: true }), headers }, instanceOptions));
+        return {
+            instance: etainablApi,
+            // accounts
+            getAccount: factory.getWithId(etainablApi, 'accounts'),
+            listAccounts: factory.list(etainablApi, 'accounts'),
+            updateAccount: factory.update(etainablApi, 'accounts'),
+            createAccount: factory.create(etainablApi, 'accounts'),
+            removeAccount: factory.remove(etainablApi, 'accounts'),
+            getAccountSchema: factory.get(etainablApi, 'accounts', 'schema'),
+            // assets
+            getAsset: factory.getWithId(etainablApi, 'assets'),
+            listAssets: factory.list(etainablApi, 'assets'),
+            updateAsset: factory.update(etainablApi, 'assets'),
+            createAsset: factory.create(etainablApi, 'assets'),
+            removeAsset: factory.remove(etainablApi, 'assets'),
+            getAssetSchema: factory.get(etainablApi, 'assets', 'schema'),
+            // assetGroups
+            getAssetGroup: factory.getWithId(etainablApi, 'asset-groups'),
+            listAssetGroups: factory.list(etainablApi, 'asset-groups'),
+            updateAssetGroup: factory.update(etainablApi, 'asset-groups'),
+            createAssetGroup: factory.create(etainablApi, 'asset-groups'),
+            removeAssetGroup: factory.remove(etainablApi, 'asset-groups'),
+            getAssetGroupAssets: factory.getWithId(etainablApi, 'asset-groups', 'assets'),
+            getAssetGroupSchema: factory.get(etainablApi, 'asset-groups', 'schema'),
+            // automation
+            getAutomation: factory.getWithId(etainablApi, 'automation'),
+            listAutomations: factory.list(etainablApi, 'automation'),
+            updateAutomation: factory.update(etainablApi, 'automation'),
+            createAutomation: factory.create(etainablApi, 'automation'),
+            removeAutomation: factory.remove(etainablApi, 'automation'),
+            createAutomationLog: subFactory.create(etainablApi, 'automation', 'logs'),
+            updateAutomationLog: subFactory.update(etainablApi, 'automation', 'logs'),
+            removeAutomationLog: subFactory.remove(etainablApi, 'automation', 'logs'),
+            // company
+            getCompany: factory.getWithId(etainablApi, 'companies'),
+            // consumption
+            getConsumption: factory.getWithId(etainablApi, 'consumptions'),
+            listConsumptions: factory.list(etainablApi, 'consumptions'),
+            updateConsumption: factory.update(etainablApi, 'consumptions'),
+            createConsumption: factory.create(etainablApi, 'consumptions'),
+            removeConsumption: factory.remove(etainablApi, 'consumptions'),
+            getConsumptionSchema: factory.get(etainablApi, 'consumptions', 'schema'),
+            // emails
+            getEmail: factory.getWithId(etainablApi, 'emails'),
+            listEmails: factory.list(etainablApi, 'emails'),
+            updateEmail: factory.update(etainablApi, 'emails'),
+            createEmail: factory.create(etainablApi, 'emails'),
+            removeEmail: factory.remove(etainablApi, 'emails'),
+            // emission factors
+            getEmissionFactor: factory.getWithId(etainablApi, 'emission-factors'),
+            listEmissionFactors: factory.list(etainablApi, 'emission-factors'),
+            updateEmissionFactor: factory.update(etainablApi, 'emission-factors'),
+            createEmissionFactor: factory.create(etainablApi, 'emission-factors'),
+            removeEmissionFactor: factory.remove(etainablApi, 'emission-factors'),
+            // logs
+            getLog: factory.getWithId(etainablApi, 'logs'),
+            listLogs: factory.list(etainablApi, 'logs'),
+            updateLog: factory.update(etainablApi, 'logs'),
+            createLog: factory.create(etainablApi, 'logs'),
+            removeLog: factory.remove(etainablApi, 'logs'),
+            // readings
+            getReading: factory.getWithId(etainablApi, 'readings'),
+            listReadings: factory.list(etainablApi, 'readings'),
+            updateReading: factory.update(etainablApi, 'readings'),
+            createReading: factory.create(etainablApi, 'readings'),
+            removeReading: factory.remove(etainablApi, 'readings'),
+            getReadingSchema: factory.get(etainablApi, 'readings', 'schema'),
+            // reports
+            getReport: factory.getWithId(etainablApi, 'reports'),
+            listReports: factory.list(etainablApi, 'reports'),
+            updateReport: factory.update(etainablApi, 'reports'),
+            createReport: factory.create(etainablApi, 'reports'),
+            removeReport: factory.remove(etainablApi, 'reports'),
+            sendReport: factory.customWithId(etainablApi, 'post', 'reports', 'send'),
+            // report templates
+            getReportTemplate: factory.getWithId(etainablApi, 'report-templates'),
+            listReportTemplates: factory.list(etainablApi, 'report-templates'),
+            updateReportTemplate: factory.update(etainablApi, 'report-templates'),
+            createReportTemplate: factory.create(etainablApi, 'report-templates'),
+            removeReportTemplate: factory.remove(etainablApi, 'report-templates'),
+            // scheduled reports
+            getScheduledReport: factory.getWithId(etainablApi, 'scheduled-reports'),
+            listScheduledReports: factory.list(etainablApi, 'scheduled-reports'),
+            updateScheduledReport: factory.update(etainablApi, 'scheduled-reports'),
+            createScheduledReport: factory.create(etainablApi, 'scheduled-reports'),
+            removeScheduledReport: factory.remove(etainablApi, 'scheduled-reports'),
+            sendScheduledReport: factory.customWithId(etainablApi, 'post', 'scheduled-reports', 'send'),
+            // invoices
+            getInvoice: factory.getWithId(etainablApi, 'invoices'),
+            listInvoices: factory.list(etainablApi, 'invoices'),
+            updateInvoice: factory.update(etainablApi, 'invoices'),
+            createInvoice: factory.create(etainablApi, 'invoices'),
+            removeInvoice: factory.remove(etainablApi, 'invoices'),
+            getInvoiceSchema: factory.get(etainablApi, 'invoices', 'schema'),
+            //suppliers
+            getSupplierSchema: factory.get(etainablApi, 'suppliers', 'schema')
+        };
+    }
+    catch (e) {
+        log.error(e);
+        throw e;
+    }
+};

package/dist/cjs/consumption.d.ts

@@ -0,0 +1,14 @@
+import moment from 'moment';
+interface ConsumptionData {
+    date: Date;
+    consumption: number;
+}
+export declare const dayNightConsumption: (data: ConsumptionData[]) => {
+    dayConsumption: number;
+    nightConsumption: number;
+    consumption: number;
+};
+export declare const calcMaxConsumptionValue: (data: ConsumptionData[]) => number;
+export declare const calcMaxDemand: (data: ConsumptionData[]) => number;
+export declare const calcPeakLoad: (consumption: number, maxDemand: number, startDate: string | moment.Moment, endDate: string | moment.Moment) => number;
+export {};

package/dist/cjs/consumption.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calcPeakLoad = exports.calcMaxDemand = exports.calcMaxConsumptionValue = exports.dayNightConsumption = void 0;
+const moment_1 = __importDefault(require("moment"));
+const dayNightConsumption = (data) => data.reduce((acc, item) => {
+    const hour = moment_1.default.utc(item.date).hour(); // End Time of HH consumption period
+    if (hour >= 0 && hour < 7) {
+        acc.nightConsumption += item.consumption;
+    }
+    else {
+        acc.dayConsumption += item.consumption;
+    }
+    acc.consumption += item.consumption;
+    return acc;
+}, {
+    dayConsumption: 0,
+    nightConsumption: 0,
+    consumption: 0
+});
+exports.dayNightConsumption = dayNightConsumption;
+const calcMaxConsumptionValue = (data) => Math.max(...data.map((item) => item.consumption));
+exports.calcMaxConsumptionValue = calcMaxConsumptionValue;
+const calcMaxDemand = (data) => (0, exports.calcMaxConsumptionValue)(data) * 2;
+exports.calcMaxDemand = calcMaxDemand;
+const calcPeakLoad = (consumption, maxDemand, startDate, endDate) => {
+    const days = Math.ceil((0, moment_1.default)(endDate).diff((0, moment_1.default)(startDate), 'days', true));
+    return maxDemand === 0 ? 0 : ((consumption / (maxDemand * 24 * days)) * 100);
+};
+exports.calcPeakLoad = calcPeakLoad;

package/dist/cjs/db.d.ts

@@ -0,0 +1,6 @@
+import { Db } from 'mongodb';
+declare function connectToDatabase(): Promise<Db>;
+declare const _default: {
+    connectToDatabase: typeof connectToDatabase;
+};
+export default _default;

package/dist/cjs/db.js

@@ -0,0 +1,49 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongodb_1 = require("mongodb");
+const logger_js_1 = __importDefault(require("./logger.js"));
+const log = (0, logger_js_1.default)('dbHelpers');
+let cachedDb;
+function connectToDatabase() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!process.env.ETAINABL_DB_URL)
+            throw new Error("ETAINABL_DB_URL is not set");
+        if (!process.env.AWS_ACCESS_KEY_ID)
+            throw new Error("AWS_ACCESS_KEY_ID is not set");
+        if (!process.env.AWS_SECRET_ACCESS_KEY)
+            throw new Error("AWS_SECRET_ACCESS_KEY is not set");
+        if (cachedDb) {
+            log.debug('Using cached MongoDB connection.');
+            return Promise.resolve(cachedDb);
+        }
+        log.debug('Connecting to MongoDB server...');
+        const uri = `mongodb+srv://${process.env.ETAINABL_DB_URL}`;
+        const client = new mongodb_1.MongoClient(uri, {
+            auth: {
+                username: process.env.AWS_ACCESS_KEY_ID,
+                password: process.env.AWS_SECRET_ACCESS_KEY
+            },
+            authSource: '$external',
+            authMechanism: 'MONGODB-AWS'
+        });
+        yield client.connect();
+        log.debug('Connected successfully to MongoDB server!');
+        cachedDb = client.db('etainabl');
+        return cachedDb;
+    });
+}
+exports.default = {
+    connectToDatabase
+};

package/dist/cjs/etainabl.d.ts

@@ -0,0 +1,10 @@
+export interface AuthorizerContext {
+    companyId: string;
+    isAdmin: boolean;
+    isKiosk: boolean;
+    isPublicApiRequest: boolean;
+    isService: boolean;
+    scope: string;
+    sub: string;
+    token: string;
+}

package/dist/cjs/etainabl.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/index.d.ts

@@ -0,0 +1,11 @@
+import api from './api.js';
+import logger from './logger.js';
+import db from './db.js';
+import slack from './slack.js';
+import * as units from './units.js';
+import * as consumption from './consumption.js';
+import * as monitoring from './monitoring.js';
+import * as reporting from './reporting.js';
+import type { Account, Asset, Automation, Company, Invoice, Log, Reading, Supplier } from '../types/index.d.js';
+export { api, logger, consumption, monitoring, db, slack, units, reporting };
+export type { Account, Asset, Automation, Company, Invoice, Log, Reading, Supplier };

package/dist/cjs/index.js

@@ -0,0 +1,45 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reporting = exports.units = exports.slack = exports.db = exports.monitoring = exports.consumption = exports.logger = exports.api = void 0;
+const api_js_1 = __importDefault(require("./api.js"));
+exports.api = api_js_1.default;
+const logger_js_1 = __importDefault(require("./logger.js"));
+exports.logger = logger_js_1.default;
+const db_js_1 = __importDefault(require("./db.js"));
+exports.db = db_js_1.default;
+const slack_js_1 = __importDefault(require("./slack.js"));
+exports.slack = slack_js_1.default;
+const units = __importStar(require("./units.js"));
+exports.units = units;
+const consumption = __importStar(require("./consumption.js"));
+exports.consumption = consumption;
+const monitoring = __importStar(require("./monitoring.js"));
+exports.monitoring = monitoring;
+const reporting = __importStar(require("./reporting.js"));
+exports.reporting = reporting;

package/dist/cjs/logger.d.ts

@@ -0,0 +1,3 @@
+import winston from 'winston';
+declare const _default: (namespace: string) => winston.Logger;
+export default _default;

package/dist/cjs/logger.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const winston_1 = __importDefault(require("winston"));
+exports.default = (namespace) => winston_1.default.createLogger({
+    level: 'debug',
+    format: winston_1.default.format.combine(winston_1.default.format.timestamp(), winston_1.default.format.json()),
+    defaultMeta: { service: process.env.AWS_LAMBDA_FUNCTION_NAME, script: namespace },
+    transports: [
+        new winston_1.default.transports.Console()
+    ]
+});

package/dist/cjs/monitoring.d.ts

@@ -0,0 +1 @@
+export declare const sendHeartbeat: () => Promise<boolean>;

package/dist/cjs/monitoring.js

@@ -0,0 +1,31 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendHeartbeat = void 0;
+const axios_1 = __importDefault(require("axios"));
+const logger_js_1 = __importDefault(require("./logger.js"));
+const log = (0, logger_js_1.default)('monitoring');
+const sendHeartbeat = () => __awaiter(void 0, void 0, void 0, function* () {
+    if (!process.env.HEARTBEAT_URL || process.env.HEARTBEAT_URL.endsWith('/'))
+        return false;
+    try {
+        yield axios_1.default.post(process.env.HEARTBEAT_URL);
+        return true;
+    }
+    catch (e) {
+        log.warn(`Failed to send heartbeat: ${e.message || e}`);
+        return false;
+    }
+});
+exports.sendHeartbeat = sendHeartbeat;

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}

package/dist/cjs/reporting.d.ts

@@ -0,0 +1,2 @@
+import moment from 'moment';
+export declare const getScheduledReportRunTimes: (schedule: any, limit?: number, taskTime?: moment.Moment) => moment.Moment[];