@shieldiot/ngx-pulseiot-lib 1.0.0

package/esm2022/lib/services/UsrReportsInstanceService.mjs

@@ -0,0 +1,83 @@
+import { Injectable, Inject } from '@angular/core';
+import { APP_CONFIG } from '../../config';
+import * as i0 from "@angular/core";
+import * as i1 from "../../rest-utils";
+import * as i2 from "../../config";
+// UsrReportsInstanceEndPoint is a list of system reports related actions 
+export class UsrReportsInstanceService {
+    // Class constructor
+    constructor(config, rest) {
+        this.config = config;
+        this.rest = rest;
+        // URL to web api
+        this.baseUrl = '/reports-instance';
+        this.baseUrl = this.config.api + this.baseUrl;
+    }
+    /**
+     * Update existing report
+     */
+    update(body) {
+        return this.rest.patch(`${this.baseUrl}`, typeof body === 'object' ? JSON.stringify(body) : body);
+    }
+    /**
+     * Delete report
+     */
+    delete(id) {
+        return this.rest.delete(`${this.baseUrl}/${id}`);
+    }
+    /**
+     * Get a single report by id
+     */
+    get(id) {
+        return this.rest.get(`${this.baseUrl}/${id}`);
+    }
+    /**
+     * Find reports by query
+     */
+    find(accountId, search, sort, page, size, from, to, reportTriggerSource) {
+        const params = [];
+        if (accountId != null) {
+            params.push(`accountId=${accountId}`);
+        }
+        if (search != null) {
+            params.push(`search=${search}`);
+        }
+        if (sort != null) {
+            params.push(`sort=${sort}`);
+        }
+        if (page != null) {
+            params.push(`page=${page}`);
+        }
+        if (size != null) {
+            params.push(`size=${size}`);
+        }
+        if (from != null) {
+            params.push(`from=${from}`);
+        }
+        if (to != null) {
+            params.push(`to=${to}`);
+        }
+        if (reportTriggerSource != null) {
+            params.push(`reportTriggerSource=${reportTriggerSource}`);
+        }
+        return this.rest.get(`${this.baseUrl}`, ...params);
+    }
+    /**
+     * Download report file as stream of PDF
+     */
+    downloadReport(id) {
+        return this.rest.download(`usr-reports-instance`, `${this.baseUrl}/${id}/download-report`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UsrReportsInstanceService, deps: [{ token: APP_CONFIG }, { token: i1.RestUtils }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UsrReportsInstanceService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UsrReportsInstanceService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i2.AppConfig, decorators: [{
+                    type: Inject,
+                    args: [APP_CONFIG]
+                }] }, { type: i1.RestUtils }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/UsrReportsService.mjs

@@ -0,0 +1,157 @@
+import { Injectable, Inject } from '@angular/core';
+import { APP_CONFIG } from '../../config';
+import * as i0 from "@angular/core";
+import * as i1 from "../../rest-utils";
+import * as i2 from "../../config";
+// UsrReportsEndPoint is a list of system reports related actions 
+export class UsrReportsService {
+    // Class constructor
+    constructor(config, rest) {
+        this.config = config;
+        this.rest = rest;
+        // URL to web api
+        this.baseUrl = '/reports';
+        this.baseUrl = this.config.api + this.baseUrl;
+    }
+    /**
+     * Create new report
+     */
+    create(body) {
+        return this.rest.put(`${this.baseUrl}`, typeof body === 'object' ? JSON.stringify(body) : body);
+    }
+    /**
+     * Update existing report
+     */
+    update(body) {
+        return this.rest.patch(`${this.baseUrl}`, typeof body === 'object' ? JSON.stringify(body) : body);
+    }
+    /**
+     * Delete report
+     */
+    delete(id) {
+        return this.rest.delete(`${this.baseUrl}/${id}`);
+    }
+    /**
+     * Get a single report by id
+     */
+    get(id) {
+        return this.rest.get(`${this.baseUrl}/${id}`);
+    }
+    /**
+     * Find reports by query
+     */
+    find(accountId, search, sort, page, size) {
+        const params = [];
+        if (accountId != null) {
+            params.push(`accountId=${accountId}`);
+        }
+        if (search != null) {
+            params.push(`search=${search}`);
+        }
+        if (sort != null) {
+            params.push(`sort=${sort}`);
+        }
+        if (page != null) {
+            params.push(`page=${page}`);
+        }
+        if (size != null) {
+            params.push(`size=${size}`);
+        }
+        return this.rest.get(`${this.baseUrl}`, ...params);
+    }
+    /**
+     * Create PDF compliance report
+     */
+    getComplianceReport(streamId, from, to) {
+        const params = [];
+        if (streamId != null) {
+            params.push(`streamId=${streamId}`);
+        }
+        if (from != null) {
+            params.push(`from=${from}`);
+        }
+        if (to != null) {
+            params.push(`to=${to}`);
+        }
+        return this.rest.download(`usr-reports`, `${this.baseUrl}/compliance`, ...params);
+    }
+    /**
+     * Create PDF compliance report and send it by mail to the user's email
+     */
+    getComplianceReportByMail(streamId, from, to, addressee) {
+        const params = [];
+        if (streamId != null) {
+            params.push(`streamId=${streamId}`);
+        }
+        if (from != null) {
+            params.push(`from=${from}`);
+        }
+        if (to != null) {
+            params.push(`to=${to}`);
+        }
+        if (addressee != null) {
+            params.push(`addressee=${addressee}`);
+        }
+        return this.rest.get(`${this.baseUrl}/compliance-by-mail`, ...params);
+    }
+    /**
+     * Get network activity over time histogram over the provided time period
+     */
+    getNetworkActivityOverTime(streamId, from, to) {
+        const params = [];
+        if (streamId != null) {
+            params.push(`streamId=${streamId}`);
+        }
+        if (from != null) {
+            params.push(`from=${from}`);
+        }
+        if (to != null) {
+            params.push(`to=${to}`);
+        }
+        return this.rest.get(`${this.baseUrl}/network-activity-over-time`, ...params);
+    }
+    /**
+     * Get device groups by communication frequency over the provided time period
+     */
+    getDeviceGroupsByCommunicationFrequency(streamId, from, to) {
+        const params = [];
+        if (streamId != null) {
+            params.push(`streamId=${streamId}`);
+        }
+        if (from != null) {
+            params.push(`from=${from}`);
+        }
+        if (to != null) {
+            params.push(`to=${to}`);
+        }
+        return this.rest.get(`${this.baseUrl}/device-groups-by-communication-frequency`, ...params);
+    }
+    /**
+     * Get device distribution by number of destinations over the provided time period
+     */
+    getDeviceDistributionByNumberOfDestinations(streamId, from, to) {
+        const params = [];
+        if (streamId != null) {
+            params.push(`streamId=${streamId}`);
+        }
+        if (from != null) {
+            params.push(`from=${from}`);
+        }
+        if (to != null) {
+            params.push(`to=${to}`);
+        }
+        return this.rest.get(`${this.baseUrl}/device-distribution-by-number-of-destinations`, ...params);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UsrReportsService, deps: [{ token: APP_CONFIG }, { token: i1.RestUtils }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UsrReportsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UsrReportsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i2.AppConfig, decorators: [{
+                    type: Inject,
+                    args: [APP_CONFIG]
+                }] }, { type: i1.RestUtils }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"UsrReportsService.js","sourceRoot":"","sources":["../../../../../projects/ngx-pulseiot-lib/src/lib/services/UsrReportsService.ts"],"names":[],"mappings":"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","sourcesContent":["\nimport { Injectable, Inject } from '@angular/core';\nimport { RestUtils } from '../../rest-utils';\nimport { APP_CONFIG, AppConfig } from '../../config';\n\nimport { GraphSeries } from '../model';\nimport { Report } from '../model';\nimport { EntityResponse } from '../model';\nimport { ActionResponse } from '../model';\nimport { EntitiesResponse } from '../model';\nimport { TimeSeries } from '../model';\n\n// UsrReportsEndPoint is a list of system reports related actions \n@Injectable({\n  providedIn: 'root'\n})\nexport class UsrReportsService {\n\n  // URL to web api\n  private baseUrl = '/reports';\n\n  // Class constructor\n  constructor(@Inject(APP_CONFIG) private config: AppConfig, private rest: RestUtils) {\n    this.baseUrl = this.config.api + this.baseUrl;\n  }\n\n  /**\n   * Create new report\n   */\n  create(body?: Report) {\n    return this.rest.put<EntityResponse<Report>>(`${this.baseUrl}`, typeof body === 'object' ? JSON.stringify(body) : body);\n  }\n\n  /**\n   * Update existing report\n   */\n  update(body?: Report) {\n    return this.rest.patch<EntityResponse<Report>>(`${this.baseUrl}`, typeof body === 'object' ? JSON.stringify(body) : body);\n  }\n\n  /**\n   * Delete report\n   */\n  delete(id?: string) {\n    return this.rest.delete<ActionResponse>(`${this.baseUrl}/${id}`);\n  }\n\n  /**\n   * Get a single report by id\n   */\n  get(id?: string) {\n    return this.rest.get<EntityResponse<Report>>(`${this.baseUrl}/${id}`);\n  }\n\n  /**\n   * Find reports by query\n   */\n  find(accountId?: string, search?: string, sort?: string, page?: number, size?: number) {\n    const params = [];\n    if (accountId != null) { params.push(`accountId=${accountId}`); }\n    if (search != null) { params.push(`search=${search}`); }\n    if (sort != null) { params.push(`sort=${sort}`); }\n    if (page != null) { params.push(`page=${page}`); }\n    if (size != null) { params.push(`size=${size}`); }\n\n\t\treturn this.rest.get<EntitiesResponse<Report>>(`${this.baseUrl}`, ...params);\n  }\n\n  /**\n   * Create PDF compliance report\n   */\n  getComplianceReport(streamId?: string, from?: number, to?: number) {\n    const params = [];\n    if (streamId != null) { params.push(`streamId=${streamId}`); }\n    if (from != null) { params.push(`from=${from}`); }\n    if (to != null) { params.push(`to=${to}`); }\n\n\t\treturn this.rest.download(`usr-reports`,`${this.baseUrl}/compliance`, ...params);\n  }\n\n  /**\n   * Create PDF compliance report and send it by mail to the user's email\n   */\n  getComplianceReportByMail(streamId?: string, from?: number, to?: number, addressee?: string[]) {\n    const params = [];\n    if (streamId != null) { params.push(`streamId=${streamId}`); }\n    if (from != null) { params.push(`from=${from}`); }\n    if (to != null) { params.push(`to=${to}`); }\n    if (addressee != null) { params.push(`addressee=${addressee}`); }\n\n\t\treturn this.rest.get<ActionResponse>(`${this.baseUrl}/compliance-by-mail`, ...params);\n  }\n\n  /**\n   * Get network activity over time histogram over the provided time period\n   */\n  getNetworkActivityOverTime(streamId?: string, from?: number, to?: number) {\n    const params = [];\n    if (streamId != null) { params.push(`streamId=${streamId}`); }\n    if (from != null) { params.push(`from=${from}`); }\n    if (to != null) { params.push(`to=${to}`); }\n\n\t\treturn this.rest.get<EntityResponse<TimeSeries<number>>>(`${this.baseUrl}/network-activity-over-time`, ...params);\n  }\n\n  /**\n   * Get device groups by communication frequency over the provided time period\n   */\n  getDeviceGroupsByCommunicationFrequency(streamId?: string, from?: number, to?: number) {\n    const params = [];\n    if (streamId != null) { params.push(`streamId=${streamId}`); }\n    if (from != null) { params.push(`from=${from}`); }\n    if (to != null) { params.push(`to=${to}`); }\n\n\t\treturn this.rest.get<EntityResponse<GraphSeries<string, number>>>(`${this.baseUrl}/device-groups-by-communication-frequency`, ...params);\n  }\n\n  /**\n   * Get device distribution by number of destinations over the provided time period\n   */\n  getDeviceDistributionByNumberOfDestinations(streamId?: string, from?: number, to?: number) {\n    const params = [];\n    if (streamId != null) { params.push(`streamId=${streamId}`); }\n    if (from != null) { params.push(`from=${from}`); }\n    if (to != null) { params.push(`to=${to}`); }\n\n\t\treturn this.rest.get<EntityResponse<GraphSeries<string, number>>>(`${this.baseUrl}/device-distribution-by-number-of-destinations`, ...params);\n  }\n\n}\n"]}

package/esm2022/lib/services/UsrRulesService.mjs

@@ -0,0 +1,168 @@
+import { Injectable, Inject } from '@angular/core';
+import { APP_CONFIG } from '../../config';
+import * as i0 from "@angular/core";
+import * as i1 from "../../rest-utils";
+import * as i2 from "../../config";
+// UsrRulesEndPoint is a list of rules related actions 
+export class UsrRulesService {
+    // Class constructor
+    constructor(config, rest) {
+        this.config = config;
+        this.rest = rest;
+        // URL to web api
+        this.baseUrl = '/rules';
+        this.baseUrl = this.config.api + this.baseUrl;
+    }
+    /**
+     * region Endpoint REST handlers ---------------------------------------------------------------------------------------
+     * Create new rule configuration
+     */
+    create(body) {
+        return this.rest.put(`${this.baseUrl}`, typeof body === 'object' ? JSON.stringify(body) : body);
+    }
+    /**
+     * Update existing rule configuration
+     */
+    update(body) {
+        return this.rest.patch(`${this.baseUrl}`, typeof body === 'object' ? JSON.stringify(body) : body);
+    }
+    /**
+     * Delete rule configuration
+     */
+    delete(id) {
+        return this.rest.delete(`${this.baseUrl}/${id}`);
+    }
+    /**
+     * Get a single rule by id
+     */
+    get(id) {
+        return this.rest.get(`${this.baseUrl}/${id}`);
+    }
+    /**
+     * Get a single rule with computed SQL statement by rule's id
+     */
+    getWithSQL(id) {
+        return this.rest.get(`${this.baseUrl}/sql/${id}`);
+    }
+    /**
+     * Get a all active rules fro stream id  with computed SQL statement
+     */
+    getWithSQLByStreamId(id) {
+        return this.rest.get(`${this.baseUrl}/sql`);
+    }
+    /**
+     * Find rules by query
+     */
+    find(streamId, search, eventSeverity, activityStatus, eventType, includeSysRules, sort, page, size) {
+        const params = [];
+        if (streamId != null) {
+            params.push(`streamId=${streamId}`);
+        }
+        if (search != null) {
+            params.push(`search=${search}`);
+        }
+        if (eventSeverity != null) {
+            params.push(`eventSeverity=${eventSeverity}`);
+        }
+        if (activityStatus != null) {
+            params.push(`activityStatus=${activityStatus}`);
+        }
+        if (eventType != null) {
+            params.push(`eventType=${eventType}`);
+        }
+        if (includeSysRules != null) {
+            params.push(`includeSysRules=${includeSysRules}`);
+        }
+        if (sort != null) {
+            params.push(`sort=${sort}`);
+        }
+        if (page != null) {
+            params.push(`page=${page}`);
+        }
+        if (size != null) {
+            params.push(`size=${size}`);
+        }
+        return this.rest.get(`${this.baseUrl}`, ...params);
+    }
+    /**
+     * Analyze rule configuration against historic data
+     */
+    analyze(from, to, interval, size, body) {
+        const params = [];
+        if (from != null) {
+            params.push(`from=${from}`);
+        }
+        if (to != null) {
+            params.push(`to=${to}`);
+        }
+        if (interval != null) {
+            params.push(`interval=${interval}`);
+        }
+        if (size != null) {
+            params.push(`size=${size}`);
+        }
+        return this.rest.post(`${this.baseUrl}/analyze`, typeof body === 'object' ? JSON.stringify(body) : body, ...params);
+    }
+    /**
+     * Get rules distribution by severity filtered by query
+     */
+    countBySeverity(streamId, search, eventSeverity, activityStatus, eventType, includeSysRules) {
+        const params = [];
+        if (streamId != null) {
+            params.push(`streamId=${streamId}`);
+        }
+        if (search != null) {
+            params.push(`search=${search}`);
+        }
+        if (eventSeverity != null) {
+            params.push(`eventSeverity=${eventSeverity}`);
+        }
+        if (activityStatus != null) {
+            params.push(`activityStatus=${activityStatus}`);
+        }
+        if (eventType != null) {
+            params.push(`eventType=${eventType}`);
+        }
+        if (includeSysRules != null) {
+            params.push(`includeSysRules=${includeSysRules}`);
+        }
+        return this.rest.get(`${this.baseUrl}/count/by-severity`, ...params);
+    }
+    /**
+     * Get alerts count by rule filtered by query
+     */
+    countAlertsByRule(streamId, search, eventSeverity, activityStatus, eventType, includeSysRules) {
+        const params = [];
+        if (streamId != null) {
+            params.push(`streamId=${streamId}`);
+        }
+        if (search != null) {
+            params.push(`search=${search}`);
+        }
+        if (eventSeverity != null) {
+            params.push(`eventSeverity=${eventSeverity}`);
+        }
+        if (activityStatus != null) {
+            params.push(`activityStatus=${activityStatus}`);
+        }
+        if (eventType != null) {
+            params.push(`eventType=${eventType}`);
+        }
+        if (includeSysRules != null) {
+            params.push(`includeSysRules=${includeSysRules}`);
+        }
+        return this.rest.get(`${this.baseUrl}/count-alerts/by-rule-id`, ...params);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UsrRulesService, deps: [{ token: APP_CONFIG }, { token: i1.RestUtils }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UsrRulesService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UsrRulesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i2.AppConfig, decorators: [{
+                    type: Inject,
+                    args: [APP_CONFIG]
+                }] }, { type: i1.RestUtils }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"UsrRulesService.js","sourceRoot":"","sources":["../../../../../projects/ngx-pulseiot-lib/src/lib/services/UsrRulesService.ts"],"names":[],"mappings":"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","sourcesContent":["\nimport { Injectable, Inject } from '@angular/core';\nimport { RestUtils } from '../../rest-utils';\nimport { APP_CONFIG, AppConfig } from '../../config';\n\nimport { EntitiesResponse } from '../model';\nimport { SeverityTypeCode } from '../model';\nimport { RuleActivityStatusCode } from '../model';\nimport { TimeSeries } from '../model';\nimport { Distribution } from '../model';\nimport { EntityResponse } from '../model';\nimport { ActionResponse } from '../model';\nimport { EventTypeCode } from '../model';\nimport { Rule } from '../model';\nimport { RuleWithSQL } from '../model';\n\n// UsrRulesEndPoint is a list of rules related actions \n@Injectable({\n  providedIn: 'root'\n})\nexport class UsrRulesService {\n\n  // URL to web api\n  private baseUrl = '/rules';\n\n  // Class constructor\n  constructor(@Inject(APP_CONFIG) private config: AppConfig, private rest: RestUtils) {\n    this.baseUrl = this.config.api + this.baseUrl;\n  }\n\n  /**\n   * region Endpoint REST handlers ---------------------------------------------------------------------------------------\n   * Create new rule configuration\n   */\n  create(body?: Rule) {\n    return this.rest.put<EntityResponse<Rule>>(`${this.baseUrl}`, typeof body === 'object' ? JSON.stringify(body) : body);\n  }\n\n  /**\n   * Update existing rule configuration\n   */\n  update(body?: Rule) {\n    return this.rest.patch<EntityResponse<Rule>>(`${this.baseUrl}`, typeof body === 'object' ? JSON.stringify(body) : body);\n  }\n\n  /**\n   * Delete rule configuration\n   */\n  delete(id?: string) {\n    return this.rest.delete<ActionResponse>(`${this.baseUrl}/${id}`);\n  }\n\n  /**\n   * Get a single rule by id\n   */\n  get(id?: string) {\n    return this.rest.get<EntityResponse<Rule>>(`${this.baseUrl}/${id}`);\n  }\n\n  /**\n   * Get a single rule with computed SQL statement by rule's id\n   */\n  getWithSQL(id?: string) {\n    return this.rest.get<EntityResponse<RuleWithSQL>>(`${this.baseUrl}/sql/${id}`);\n  }\n\n  /**\n   * Get a all active rules fro stream id  with computed SQL statement\n   */\n  getWithSQLByStreamId(id?: string) {\n    return this.rest.get<EntitiesResponse<RuleWithSQL>>(`${this.baseUrl}/sql`);\n  }\n\n  /**\n   * Find rules by query\n   */\n  find(streamId?: string, search?: string, eventSeverity?: SeverityTypeCode[], activityStatus?: RuleActivityStatusCode[], eventType?: EventTypeCode[], includeSysRules?: boolean, sort?: string, page?: number, size?: number) {\n    const params = [];\n    if (streamId != null) { params.push(`streamId=${streamId}`); }\n    if (search != null) { params.push(`search=${search}`); }\n    if (eventSeverity != null) { params.push(`eventSeverity=${eventSeverity}`); }\n    if (activityStatus != null) { params.push(`activityStatus=${activityStatus}`); }\n    if (eventType != null) { params.push(`eventType=${eventType}`); }\n    if (includeSysRules != null) { params.push(`includeSysRules=${includeSysRules}`); }\n    if (sort != null) { params.push(`sort=${sort}`); }\n    if (page != null) { params.push(`page=${page}`); }\n    if (size != null) { params.push(`size=${size}`); }\n\n\t\treturn this.rest.get<EntitiesResponse<Rule>>(`${this.baseUrl}`, ...params);\n  }\n\n  /**\n   * Analyze rule configuration against historic data\n   */\n  analyze(from?: number, to?: number, interval?: number, size?: number, body?: Rule) {\n    const params = [];\n    if (from != null) { params.push(`from=${from}`); }\n    if (to != null) { params.push(`to=${to}`); }\n    if (interval != null) { params.push(`interval=${interval}`); }\n    if (size != null) { params.push(`size=${size}`); }\n\n\t\treturn this.rest.post<EntityResponse<TimeSeries<number>>>(`${this.baseUrl}/analyze`, typeof body === 'object' ? JSON.stringify(body) : body, ...params);\n  }\n\n  /**\n   * Get rules distribution by severity filtered by query\n   */\n  countBySeverity(streamId?: string, search?: string, eventSeverity?: SeverityTypeCode[], activityStatus?: RuleActivityStatusCode[], eventType?: EventTypeCode[], includeSysRules?: boolean) {\n    const params = [];\n    if (streamId != null) { params.push(`streamId=${streamId}`); }\n    if (search != null) { params.push(`search=${search}`); }\n    if (eventSeverity != null) { params.push(`eventSeverity=${eventSeverity}`); }\n    if (activityStatus != null) { params.push(`activityStatus=${activityStatus}`); }\n    if (eventType != null) { params.push(`eventType=${eventType}`); }\n    if (includeSysRules != null) { params.push(`includeSysRules=${includeSysRules}`); }\n\n\t\treturn this.rest.get<EntityResponse<Distribution<number>>>(`${this.baseUrl}/count/by-severity`, ...params);\n  }\n\n  /**\n   * Get alerts count by rule filtered by query\n   */\n  countAlertsByRule(streamId?: string, search?: string, eventSeverity?: SeverityTypeCode[], activityStatus?: RuleActivityStatusCode[], eventType?: EventTypeCode[], includeSysRules?: boolean) {\n    const params = [];\n    if (streamId != null) { params.push(`streamId=${streamId}`); }\n    if (search != null) { params.push(`search=${search}`); }\n    if (eventSeverity != null) { params.push(`eventSeverity=${eventSeverity}`); }\n    if (activityStatus != null) { params.push(`activityStatus=${activityStatus}`); }\n    if (eventType != null) { params.push(`eventType=${eventType}`); }\n    if (includeSysRules != null) { params.push(`includeSysRules=${includeSysRules}`); }\n\n\t\treturn this.rest.get<EntityResponse<Distribution<number>>>(`${this.baseUrl}/count-alerts/by-rule-id`, ...params);\n  }\n\n}\n"]}

package/esm2022/lib/services/UsrUserService.mjs

@@ -0,0 +1,120 @@
+import { Injectable, Inject } from '@angular/core';
+import { APP_CONFIG } from '../../config';
+import * as i0 from "@angular/core";
+import * as i1 from "../../rest-utils";
+import * as i2 from "../../config";
+// UsrUserEndPoint Services for user registration and login 
+export class UsrUserService {
+    // Class constructor
+    constructor(config, rest) {
+        this.config = config;
+        this.rest = rest;
+        // URL to web api
+        this.baseUrl = '/user';
+        this.baseUrl = this.config.api + this.baseUrl;
+    }
+    /**
+     * Authorize user, verify user against account
+     * The response includes access token valid for 20 minutes. The client side should renew the token before expiration using refresh-token method
+     */
+    authorize(body) {
+        return this.rest.post(`${this.baseUrl}/authorize`, typeof body === 'object' ? JSON.stringify(body) : body);
+    }
+    /**
+     * Refresh token (set new expiration time) and associate with new account if required
+     * The response includes the newly refreshed token both in the HTTP header and the new account details
+     */
+    setAccount(id) {
+        return this.rest.post(`${this.baseUrl}/set-account/${id}`, '');
+    }
+    /**
+     * Get user's current account details
+     */
+    getAccount() {
+        return this.rest.get(`${this.baseUrl}/get-account`);
+    }
+    /**
+     * Get user's current account logo
+     */
+    getAccountLogo() {
+        return this.rest.get(`${this.baseUrl}/get-account-logo`);
+    }
+    /**
+     * Get user's current account features
+     */
+    getAccountFeatures() {
+        return this.rest.get(`${this.baseUrl}/get-account-features`);
+    }
+    /**
+     * Get list of account streams accessible by the user
+     */
+    getAccountStreams() {
+        return this.rest.get(`${this.baseUrl}/get-account-streams`);
+    }
+    /**
+     * Get all the user memberships (all accounts that the current user has access to)
+     */
+    memberships() {
+        return this.rest.get(`${this.baseUrl}/memberships`);
+    }
+    /**
+     * Save user's never show again guides
+     */
+    setNeverShowAgainGuides(guides) {
+        return this.rest.patch(`${this.baseUrl}/never-show-guides/${guides}`, '');
+    }
+    /**
+     * Save user's avatar
+     */
+    saveAvatar(body) {
+        return this.rest.patch(`${this.baseUrl}/avatar`, typeof body === 'object' ? JSON.stringify(body) : body);
+    }
+    /**
+     * Get user's avatar
+     */
+    getAvatar() {
+        return this.rest.get(`${this.baseUrl}/avatar`);
+    }
+    /**
+     * Get arbitrary image
+     */
+    getImage(id) {
+        return this.rest.get(`${this.baseUrl}/images/${id}`);
+    }
+    /**
+     * Get arbitrary image as stream
+     */
+    getImageStream(id) {
+        return this.rest.download(`export`, `${this.baseUrl}/image-bytes/${id}`);
+    }
+    /**
+     * Get personal access token
+     */
+    getAccessToken() {
+        return this.rest.get(`${this.baseUrl}/access-token`);
+    }
+    /**
+     * Ask for premium request
+     */
+    premiumRequest(featureCode) {
+        return this.rest.get(`${this.baseUrl}/premium-request`);
+    }
+    /**
+     * Get system configuration parameters
+     */
+    getSysConfig() {
+        return this.rest.get(`${this.baseUrl}/get-sys-config`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UsrUserService, deps: [{ token: APP_CONFIG }, { token: i1.RestUtils }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UsrUserService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UsrUserService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i2.AppConfig, decorators: [{
+                    type: Inject,
+                    args: [APP_CONFIG]
+                }] }, { type: i1.RestUtils }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"UsrUserService.js","sourceRoot":"","sources":["../../../../../projects/ngx-pulseiot-lib/src/lib/services/UsrUserService.ts"],"names":[],"mappings":"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","sourcesContent":["\nimport { Injectable, Inject } from '@angular/core';\nimport { RestUtils } from '../../rest-utils';\nimport { APP_CONFIG, AppConfig } from '../../config';\n\nimport { Image } from '../model';\nimport { UserMemberships } from '../model';\nimport { ConfigParam } from '../model';\nimport { ActionResponse } from '../model';\nimport { EntityResponse } from '../model';\nimport { AccountDTO } from '../model';\nimport { EntitiesResponse } from '../model';\nimport { Feature } from '../model';\nimport { Stream } from '../model';\n\n// UsrUserEndPoint Services for user registration and login \n@Injectable({\n  providedIn: 'root'\n})\nexport class UsrUserService {\n\n  // URL to web api\n  private baseUrl = '/user';\n\n  // Class constructor\n  constructor(@Inject(APP_CONFIG) private config: AppConfig, private rest: RestUtils) {\n    this.baseUrl = this.config.api + this.baseUrl;\n  }\n\n  /**\n   * Authorize user, verify user against account\n   * The response includes access token valid for 20 minutes. The client side should renew the token before expiration using refresh-token method\n   */\n  authorize(body?: string) {\n    return this.rest.post<ActionResponse>(`${this.baseUrl}/authorize`, typeof body === 'object' ? JSON.stringify(body) : body);\n  }\n\n  /**\n   * Refresh token (set new expiration time) and associate with new account if required\n   * The response includes the newly refreshed token both in the HTTP header and the new account details\n   */\n  setAccount(id?: string) {\n    return this.rest.post<EntityResponse<AccountDTO>>(`${this.baseUrl}/set-account/${id}`, '');\n  }\n\n  /**\n   * Get user's current account details\n   */\n  getAccount() {\n    return this.rest.get<EntityResponse<AccountDTO>>(`${this.baseUrl}/get-account`);\n  }\n\n  /**\n   * Get user's current account logo\n   */\n  getAccountLogo() {\n    return this.rest.get<EntityResponse<Image>>(`${this.baseUrl}/get-account-logo`);\n  }\n\n  /**\n   * Get user's current account features\n   */\n  getAccountFeatures() {\n    return this.rest.get<EntitiesResponse<Feature>>(`${this.baseUrl}/get-account-features`);\n  }\n\n  /**\n   * Get list of account streams accessible by the user\n   */\n  getAccountStreams() {\n    return this.rest.get<EntitiesResponse<Stream>>(`${this.baseUrl}/get-account-streams`);\n  }\n\n  /**\n   * Get all the user memberships (all accounts that the current user has access to)\n   */\n  memberships() {\n    return this.rest.get<EntityResponse<UserMemberships>>(`${this.baseUrl}/memberships`);\n  }\n\n  /**\n   * Save user's never show again guides\n   */\n  setNeverShowAgainGuides(guides?: string) {\n    return this.rest.patch<ActionResponse>(`${this.baseUrl}/never-show-guides/${guides}`, '');\n  }\n\n  /**\n   * Save user's avatar\n   */\n  saveAvatar(body?: Image) {\n    return this.rest.patch<ActionResponse>(`${this.baseUrl}/avatar`, typeof body === 'object' ? JSON.stringify(body) : body);\n  }\n\n  /**\n   * Get user's avatar\n   */\n  getAvatar() {\n    return this.rest.get<EntityResponse<Image>>(`${this.baseUrl}/avatar`);\n  }\n\n  /**\n   * Get arbitrary image\n   */\n  getImage(id?: string) {\n    return this.rest.get<EntityResponse<Image>>(`${this.baseUrl}/images/${id}`);\n  }\n\n  /**\n   * Get arbitrary image as stream\n   */\n  getImageStream(id?: string) {\n    return this.rest.download(`export`,`${this.baseUrl}/image-bytes/${id}`);\n  }\n\n  /**\n   * Get personal access token\n   */\n  getAccessToken() {\n    return this.rest.get<ActionResponse>(`${this.baseUrl}/access-token`);\n  }\n\n  /**\n   * Ask for premium request\n   */\n  premiumRequest(featureCode?: string) {\n    return this.rest.get<ActionResponse>(`${this.baseUrl}/premium-request`);\n  }\n\n  /**\n   * Get system configuration parameters\n   */\n  getSysConfig() {\n    return this.rest.get<EntitiesResponse<ConfigParam>>(`${this.baseUrl}/get-sys-config`);\n  }\n\n}\n"]}

package/esm2022/lib/services/index.mjs

@@ -0,0 +1,29 @@
+export * from './UsrDevicesService';
+export * from './UsrReportsService';
+export * from './UsrUserService';
+export * from './McpToolsService';
+export * from './SysAccountsService';
+export * from './SysKeysService';
+export * from './SysRuleTemplatesService';
+export * from './SysStreamsService';
+export * from './SysUsersService';
+export * from './UsrEventsService';
+export * from './UsrInsightsService';
+export * from './SysCheckpointsService';
+export * from './SysConfigService';
+export * from './SysFeaturesService';
+export * from './SysIdsRulesService';
+export * from './SysInsightsService';
+export * from './UsrIntegrationsService';
+export * from './UsrReportsInstanceService';
+export * from './SysRulesService';
+export * from './SysStatisticsService';
+export * from './UsrAlertsService';
+export * from './UsrMembersService';
+export * from './UsrNetworkService';
+export * from './UsrNotificationMessagesService';
+export * from './UsrRulesService';
+export * from './SysAuditLogService';
+export * from './SysGroupsService';
+export * from './SysMembersService';
+//# sourceMappingURL=data:application/json;base64,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