@futdevpro/nts-dynamo 1.15.41 → 1.15.43

package/src/_modules/usage/usage.data-service.ts

@@ -1,185 +1,185 @@
-
-import { DyFM_Error, DyFM_RelativeDate, DyFM_Time } from '@futdevpro/fsm-dynamo';
-import {
-  DyFM_DailyUsageData,
-  DyFM_UsageData,
-  DyFM_UsageSession, DyFM_usageSession_dataParams
-} from '@futdevpro/fsm-dynamo/usage';
-import { Request } from 'express';
-
-import { DyNTS_DataService } from '../../_services/base/data.service';
-import { DyNTS_Shared } from '../../_services/shared.static-service';
-import { DyNTS_global_settings } from '../../_collections/global-settings.const';
-
-export class DyNTS_Usage_DataService extends DyNTS_DataService<DyFM_UsageSession> {
-  usageData: DyFM_UsageData[] = [];
-  simplifiedDailyUsage: DyFM_DailyUsageData[] = [];
-
-  constructor(
-    set: {
-      usageSession?: DyFM_UsageSession,
-      usageData?: DyFM_UsageData[],
-      issuer: string,
-    }
-  ) {
-    super(
-      new DyFM_UsageSession(set?.usageSession),
-      DyFM_usageSession_dataParams,
-      set.issuer
-    );
-    this.usageData = set?.usageData ?? [];
-  }
-
-  getLocationDataFromRequest(req: Request): void {
-    try {
-      this.data.address = DyNTS_Shared.getIpFromRequest(req);
-      this.data.locationData = DyNTS_Shared.getLocationDataByRequest(req);
-
-      /* console.log(`...getLocationDataFromRequest... ip: ${this.data.address}`, this.data.locationData); */
-    } catch (error) {
-      throw new DyFM_Error({ 
-        ...this.getDefaultErrorSettings('getLocationDataFromRequest', error),
-        
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-US0-GLD`,
-        userMessage: `We were unable to deep analyze your request.`,
-      });
-    }
-  }
-
-  async getUsage(range: DyFM_RelativeDate = DyFM_RelativeDate.lastWeek): Promise<void> {
-    try {
-      await this.dataDBService.find({
-        sessionStart: { $gte: DyFM_Time.getDateByRelativeDate(range) },
-      }).then((res: DyFM_UsageSession[]): void => {
-        this.dataList = res;
-      });
-      this.simplifiedDailyUsage = [];
-      this.dataList.forEach((session: DyFM_UsageSession): void => {
-        let dateIndex = this.simplifiedDailyUsage.findIndex(
-          (dailyData: DyFM_DailyUsageData): boolean => dailyData.date === session.date
-        );
-
-        if (-1 < dateIndex) {
-          this.simplifiedDailyUsage[dateIndex].visitations.push(session);
-        } else {
-          const newUsageSimple = new DyFM_DailyUsageData({ 
-            date: session.date, 
-            visitations: [ session ],
-          });
-
-          this.simplifiedDailyUsage.push(newUsageSimple);
-          dateIndex = this.simplifiedDailyUsage.length - 1;
-        }
-
-        if (session?.locationData?.country) {
-          if (session.locationData.country === 'HU') {
-            this.simplifiedDailyUsage[dateIndex].visitorsHun++;
-          } else {
-            this.simplifiedDailyUsage[dateIndex].visitorsElse++;
-          }
-        }
-        this.simplifiedDailyUsage[dateIndex].totalVisitTime += session.totalSessionTime;
-        this.simplifiedDailyUsage[dateIndex].averageVisitTime = Math.round(
-          (this.simplifiedDailyUsage[dateIndex].totalVisitTime /
-            this.simplifiedDailyUsage[dateIndex].visitations.length) * 100
-        ) / 100;
-      });
-
-      this.simplifiedDailyUsage.sort(
-        (a: DyFM_DailyUsageData, b: DyFM_DailyUsageData): number => 
-          +new Date(b.date) - +new Date(a.date)
-      );
-      this.simplifiedDailyUsage.forEach((daily: DyFM_DailyUsageData): void => {
-        daily.visitations.sort(
-          (a: DyFM_UsageSession, b: DyFM_UsageSession): number => 
-            +a.sessionStart - +b.sessionStart
-        );
-      });
-
-    } catch (error) {
-      throw new DyFM_Error({ 
-        ...this.getDefaultErrorSettings('getLastWeekUsage', error),
-        
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-US0-GLW`,
-        userMessage: `We've failed to collect last week's usage data.`,
-      });
-    }
-  }
-
-  async updateUsageData(req: Request): Promise<void> {
-    try {
-      const data: DyFM_UsageSession = await this.getDataById();
-
-      if (!data) {
-        throw new DyFM_Error({
-          ...this.getDefaultErrorSettings(
-            'updateUsageData', 
-            new Error('usage session NOT FOUND!')
-          ),
-
-          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-US0-UU0`,
-          userMessage: `The attempt to update Usage Data was unsuccessful.`,
-        });
-      }
-
-      data.usageData = this.usageData;
-      let totalTime = 0;
-
-      data.usageData.forEach((data: DyFM_UsageData): void => {
-        totalTime += data.timeSpentOnPage;
-      });
-
-      if (!data.locationData) {
-        this.getLocationDataFromRequest(req);
-      }
-      data.totalSessionTime = totalTime;
-      
-      await this.saveData(data);
-    } catch (error) {
-      throw new DyFM_Error({ 
-        ...this.getDefaultErrorSettings('updateUsageData', error),
-        
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-US0-UU0`,
-        userMessage: `The attempt to update Usage Data was unsuccessful.`,
-      });
-    }
-  }
-
-  async closeSession(req: Request): Promise<void> {
-    try {
-      const data: DyFM_UsageSession = await this.getDataById();
-
-      if (!data) {
-        throw new DyFM_Error({
-          ...this.getDefaultErrorSettings('closeSession', new Error('usage session NOT FOUND!')),
-
-          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-US0-CS0`,
-          userMessage: `The attempt to close Usage Session was unsuccessful.`,
-        });
-      }
-
-      data.sessionEnd = new Date();
-      const newTotalSessionTime = +data.sessionEnd - +data.sessionStart;
-
-      data.usageData[data.usageData.length - 1].timeSpentOnPage = 
-        newTotalSessionTime - data.totalSessionTime;
-      
-      if (!data.locationData) {
-        this.getLocationDataFromRequest(req);
-      }
-      data.usageData.sort(
-        (a: DyFM_UsageData, b: DyFM_UsageData): number => +a.opened - +b.opened
-      );
-      data.totalSessionTime = newTotalSessionTime;
-
-      await this.saveData(data);
-    } catch (error) {
-      throw new DyFM_Error({ 
-        ...this.getDefaultErrorSettings('closeSession', error),
-        
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-US0-CS0`,
-        userMessage: `The attempt to close Usage Session was unsuccessful.`,
-      });
-    }
-  }
-}
+
+import { DyFM_Error, DyFM_RelativeDate, DyFM_Time } from '@futdevpro/fsm-dynamo';
+import {
+  DyFM_DailyUsageData,
+  DyFM_UsageData,
+  DyFM_UsageSession, DyFM_usageSession_dataParams
+} from '@futdevpro/fsm-dynamo/usage';
+import { Request } from 'express';
+
+import { DyNTS_DataService } from '../../_services/base/data.service';
+import { DyNTS_Shared } from '../../_services/shared.static-service';
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+
+export class DyNTS_Usage_DataService extends DyNTS_DataService<DyFM_UsageSession> {
+  usageData: DyFM_UsageData[] = [];
+  simplifiedDailyUsage: DyFM_DailyUsageData[] = [];
+
+  constructor(
+    set: {
+      usageSession?: DyFM_UsageSession,
+      usageData?: DyFM_UsageData[],
+      issuer: string,
+    }
+  ) {
+    super(
+      new DyFM_UsageSession(set?.usageSession),
+      DyFM_usageSession_dataParams,
+      set.issuer
+    );
+    this.usageData = set?.usageData ?? [];
+  }
+
+  getLocationDataFromRequest(req: Request): void {
+    try {
+      this.data.address = DyNTS_Shared.getIpFromRequest(req);
+      this.data.locationData = DyNTS_Shared.getLocationDataByRequest(req);
+
+      /* console.log(`...getLocationDataFromRequest... ip: ${this.data.address}`, this.data.locationData); */
+    } catch (error) {
+      throw new DyFM_Error({ 
+        ...this.getDefaultErrorSettings('getLocationDataFromRequest', error),
+        
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-US0-GLD`,
+        userMessage: `We were unable to deep analyze your request.`,
+      });
+    }
+  }
+
+  async getUsage(range: DyFM_RelativeDate = DyFM_RelativeDate.lastWeek): Promise<void> {
+    try {
+      await this.dataDBService.find({
+        sessionStart: { $gte: DyFM_Time.getDateByRelativeDate(range) },
+      }).then((res: DyFM_UsageSession[]): void => {
+        this.dataList = res;
+      });
+      this.simplifiedDailyUsage = [];
+      this.dataList.forEach((session: DyFM_UsageSession): void => {
+        let dateIndex = this.simplifiedDailyUsage.findIndex(
+          (dailyData: DyFM_DailyUsageData): boolean => dailyData.date === session.date
+        );
+
+        if (-1 < dateIndex) {
+          this.simplifiedDailyUsage[dateIndex].visitations.push(session);
+        } else {
+          const newUsageSimple = new DyFM_DailyUsageData({ 
+            date: session.date, 
+            visitations: [ session ],
+          });
+
+          this.simplifiedDailyUsage.push(newUsageSimple);
+          dateIndex = this.simplifiedDailyUsage.length - 1;
+        }
+
+        if (session?.locationData?.country) {
+          if (session.locationData.country === 'HU') {
+            this.simplifiedDailyUsage[dateIndex].visitorsHun++;
+          } else {
+            this.simplifiedDailyUsage[dateIndex].visitorsElse++;
+          }
+        }
+        this.simplifiedDailyUsage[dateIndex].totalVisitTime += session.totalSessionTime;
+        this.simplifiedDailyUsage[dateIndex].averageVisitTime = Math.round(
+          (this.simplifiedDailyUsage[dateIndex].totalVisitTime /
+            this.simplifiedDailyUsage[dateIndex].visitations.length) * 100
+        ) / 100;
+      });
+
+      this.simplifiedDailyUsage.sort(
+        (a: DyFM_DailyUsageData, b: DyFM_DailyUsageData): number => 
+          +new Date(b.date) - +new Date(a.date)
+      );
+      this.simplifiedDailyUsage.forEach((daily: DyFM_DailyUsageData): void => {
+        daily.visitations.sort(
+          (a: DyFM_UsageSession, b: DyFM_UsageSession): number => 
+            +a.sessionStart - +b.sessionStart
+        );
+      });
+
+    } catch (error) {
+      throw new DyFM_Error({ 
+        ...this.getDefaultErrorSettings('getLastWeekUsage', error),
+        
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-US0-GLW`,
+        userMessage: `We've failed to collect last week's usage data.`,
+      });
+    }
+  }
+
+  async updateUsageData(req: Request): Promise<void> {
+    try {
+      const data: DyFM_UsageSession = await this.getDataById();
+
+      if (!data) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings(
+            'updateUsageData', 
+            new Error('usage session NOT FOUND!')
+          ),
+
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-US0-UU0`,
+          userMessage: `The attempt to update Usage Data was unsuccessful.`,
+        });
+      }
+
+      data.usageData = this.usageData;
+      let totalTime = 0;
+
+      data.usageData.forEach((data: DyFM_UsageData): void => {
+        totalTime += data.timeSpentOnPage;
+      });
+
+      if (!data.locationData) {
+        this.getLocationDataFromRequest(req);
+      }
+      data.totalSessionTime = totalTime;
+      
+      await this.saveData(data);
+    } catch (error) {
+      throw new DyFM_Error({ 
+        ...this.getDefaultErrorSettings('updateUsageData', error),
+        
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-US0-UU0`,
+        userMessage: `The attempt to update Usage Data was unsuccessful.`,
+      });
+    }
+  }
+
+  async closeSession(req: Request): Promise<void> {
+    try {
+      const data: DyFM_UsageSession = await this.getDataById();
+
+      if (!data) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings('closeSession', new Error('usage session NOT FOUND!')),
+
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-US0-CS0`,
+          userMessage: `The attempt to close Usage Session was unsuccessful.`,
+        });
+      }
+
+      data.sessionEnd = new Date();
+      const newTotalSessionTime = +data.sessionEnd - +data.sessionStart;
+
+      data.usageData[data.usageData.length - 1].timeSpentOnPage = 
+        newTotalSessionTime - data.totalSessionTime;
+      
+      if (!data.locationData) {
+        this.getLocationDataFromRequest(req);
+      }
+      data.usageData.sort(
+        (a: DyFM_UsageData, b: DyFM_UsageData): number => +a.opened - +b.opened
+      );
+      data.totalSessionTime = newTotalSessionTime;
+
+      await this.saveData(data);
+    } catch (error) {
+      throw new DyFM_Error({ 
+        ...this.getDefaultErrorSettings('closeSession', error),
+        
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-US0-CS0`,
+        userMessage: `The attempt to close Usage Session was unsuccessful.`,
+      });
+    }
+  }
+}

package/src/_services/base/api.service-base.spec.ts

@@ -1,125 +1,125 @@
-
-import { DyNTS_ApiService_Base } from './api.service-base';
-import { DyNTS_ApiService } from '../core/api.service';
-import { DyFM_Error, DyFM_HttpCallType, DyFM_Log } from '@futdevpro/fsm-dynamo';
-import { DyNTS_ApiCall_Params } from '../../_models/control-models/api-call-params.control-model';
-
-class TestApiService extends DyNTS_ApiService_Base {
-  get baseUrl(): string {
-    return 'https://api.example.com';
-  }
-
-  get testEndpoint(): string {
-    return '/test';
-  }
-
-  get connectingSystemName(): string {
-    return 'TestSystem';
-  }
-
-  static getInstance(): TestApiService {
-    return TestApiService.getSingletonInstance();
-  }
-}
-
-describe('| DyNTS_ApiService_Base', () => {
-  let service: TestApiService;
-
-  beforeEach(() => {
-    service = TestApiService.getInstance();
-  });
-
-  it('| should be a singleton instance', () => {
-    const instance1 = TestApiService.getInstance();
-    const instance2 = TestApiService.getInstance();
-
-    expect(instance1).toBe(instance2);
-    expect(instance1).toBeInstanceOf(TestApiService);
-  });
-
-  describe('| runApiCallWithAvailabilityCheck', () => {
-    it('| should return result when api call succeeds', async () => {
-      const apiCall = jasmine.createSpy('apiCall').and.returnValue(Promise.resolve('success'));
-
-      const result = await service.runApiCallWithAvailabilityCheck(apiCall, 'issuer-123');
-
-      expect(result).toBe('success');
-      expect(apiCall).toHaveBeenCalled();
-    });
-
-    it('| should check server availability when api call fails', async () => {
-      const apiCall = jasmine.createSpy('apiCall').and.returnValue(
-        Promise.reject(new Error('API call failed'))
-      );
-      spyOn(service, 'checkServerAvailability').and.returnValue(Promise.resolve());
-
-      await expectAsync(
-        service.runApiCallWithAvailabilityCheck(apiCall, 'issuer-123')
-      ).toBeRejectedWithError('API call failed');
-
-      expect(service.checkServerAvailability).toHaveBeenCalledWith('issuer-123');
-    });
-  });
-
-  describe('| checkServerAvailability', () => {
-    it('| should succeed when testGet succeeds', async () => {
-      spyOn(service, 'testGet').and.returnValue(Promise.resolve());
-      const logSpy = spyOn(DyFM_Log, 'success');
-
-      await service.checkServerAvailability('issuer-123');
-
-      expect(service.testGet).toHaveBeenCalledWith('issuer-123');
-    });
-
-    it('| should throw error when testGet fails', async () => {
-      spyOn(service, 'testGet').and.returnValue(
-        Promise.reject(new Error('Test failed'))
-      );
-
-      try {
-        await service.checkServerAvailability('issuer-123');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(DyFM_Error);
-        expect((error as DyFM_Error)._message).toContain('TestSystem server is not available');
-        expect((error as DyFM_Error)._message).toContain('baseUrl: https://api.example.com');
-        expect((error as DyFM_Error).__userMessage).toContain('TestSystem server is not available');
-        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-ASB-CSA0');
-      }
-    });
-  });
-
-  describe('| testGet', () => {
-    it('| should call ApiService.startApiCall with correct parameters', async () => {
-      const startApiCallSpy = spyOn(DyNTS_ApiService, 'startApiCall').and.returnValue(
-        Promise.resolve()
-      );
-      const logSpy = spyOn(DyFM_Log, 'success');
-
-      await service.testGet('issuer-123');
-
-      expect(startApiCallSpy).toHaveBeenCalledWith(
-        jasmine.any(DyNTS_ApiCall_Params)
-      );
-      const callParams = startApiCallSpy.calls.mostRecent().args[0] as DyNTS_ApiCall_Params;
-      expect(callParams.type).toBe(DyFM_HttpCallType.get);
-      expect(callParams.baseUrl).toBe('https://api.example.com');
-      expect(callParams.endpoint).toBe('/test');
-      expect(logSpy).toHaveBeenCalled();
-    });
-
-    it('| should throw error when testEndpoint is not set', async () => {
-      const serviceWithoutEndpoint = new (class extends DyNTS_ApiService_Base {
-        get baseUrl(): string { return 'https://api.example.com'; }
-        get testEndpoint(): string { return ''; }
-        get connectingSystemName(): string { return 'TestSystem'; }
-        static getInstance() { return this.getSingletonInstance(); }
-      } as any)();
-
-      await expectAsync(
-        serviceWithoutEndpoint.testGet('issuer-123')
-      ).toBeRejected();
-    });
-  });
-});
-
+
+import { DyNTS_ApiService_Base } from './api.service-base';
+import { DyNTS_ApiService } from '../core/api.service';
+import { DyFM_Error, DyFM_HttpCallType, DyFM_Log } from '@futdevpro/fsm-dynamo';
+import { DyNTS_ApiCall_Params } from '../../_models/control-models/api-call-params.control-model';
+
+class TestApiService extends DyNTS_ApiService_Base {
+  get baseUrl(): string {
+    return 'https://api.example.com';
+  }
+
+  get testEndpoint(): string {
+    return '/test';
+  }
+
+  get connectingSystemName(): string {
+    return 'TestSystem';
+  }
+
+  static getInstance(): TestApiService {
+    return TestApiService.getSingletonInstance();
+  }
+}
+
+describe('| DyNTS_ApiService_Base', () => {
+  let service: TestApiService;
+
+  beforeEach(() => {
+    service = TestApiService.getInstance();
+  });
+
+  it('| should be a singleton instance', () => {
+    const instance1 = TestApiService.getInstance();
+    const instance2 = TestApiService.getInstance();
+
+    expect(instance1).toBe(instance2);
+    expect(instance1).toBeInstanceOf(TestApiService);
+  });
+
+  describe('| runApiCallWithAvailabilityCheck', () => {
+    it('| should return result when api call succeeds', async () => {
+      const apiCall = jasmine.createSpy('apiCall').and.returnValue(Promise.resolve('success'));
+
+      const result = await service.runApiCallWithAvailabilityCheck(apiCall, 'issuer-123');
+
+      expect(result).toBe('success');
+      expect(apiCall).toHaveBeenCalled();
+    });
+
+    it('| should check server availability when api call fails', async () => {
+      const apiCall = jasmine.createSpy('apiCall').and.returnValue(
+        Promise.reject(new Error('API call failed'))
+      );
+      spyOn(service, 'checkServerAvailability').and.returnValue(Promise.resolve());
+
+      await expectAsync(
+        service.runApiCallWithAvailabilityCheck(apiCall, 'issuer-123')
+      ).toBeRejectedWithError('API call failed');
+
+      expect(service.checkServerAvailability).toHaveBeenCalledWith('issuer-123');
+    });
+  });
+
+  describe('| checkServerAvailability', () => {
+    it('| should succeed when testGet succeeds', async () => {
+      spyOn(service, 'testGet').and.returnValue(Promise.resolve());
+      const logSpy = spyOn(DyFM_Log, 'success');
+
+      await service.checkServerAvailability('issuer-123');
+
+      expect(service.testGet).toHaveBeenCalledWith('issuer-123');
+    });
+
+    it('| should throw error when testGet fails', async () => {
+      spyOn(service, 'testGet').and.returnValue(
+        Promise.reject(new Error('Test failed'))
+      );
+
+      try {
+        await service.checkServerAvailability('issuer-123');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error)._message).toContain('TestSystem server is not available');
+        expect((error as DyFM_Error)._message).toContain('baseUrl: https://api.example.com');
+        expect((error as DyFM_Error).__userMessage).toContain('TestSystem server is not available');
+        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-ASB-CSA0');
+      }
+    });
+  });
+
+  describe('| testGet', () => {
+    it('| should call ApiService.startApiCall with correct parameters', async () => {
+      const startApiCallSpy = spyOn(DyNTS_ApiService, 'startApiCall').and.returnValue(
+        Promise.resolve()
+      );
+      const logSpy = spyOn(DyFM_Log, 'success');
+
+      await service.testGet('issuer-123');
+
+      expect(startApiCallSpy).toHaveBeenCalledWith(
+        jasmine.any(DyNTS_ApiCall_Params)
+      );
+      const callParams = startApiCallSpy.calls.mostRecent().args[0] as DyNTS_ApiCall_Params;
+      expect(callParams.type).toBe(DyFM_HttpCallType.get);
+      expect(callParams.baseUrl).toBe('https://api.example.com');
+      expect(callParams.endpoint).toBe('/test');
+      expect(logSpy).toHaveBeenCalled();
+    });
+
+    it('| should throw error when testEndpoint is not set', async () => {
+      const serviceWithoutEndpoint = new (class extends DyNTS_ApiService_Base {
+        get baseUrl(): string { return 'https://api.example.com'; }
+        get testEndpoint(): string { return ''; }
+        get connectingSystemName(): string { return 'TestSystem'; }
+        static getInstance() { return this.getSingletonInstance(); }
+      } as any)();
+
+      await expectAsync(
+        serviceWithoutEndpoint.testGet('issuer-123')
+      ).toBeRejected();
+    });
+  });
+});
+