@futdevpro/nts-dynamo 1.15.156 → 1.15.160

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

@@ -1,332 +0,0 @@
-
-import { DyNTS_Usage_DataService } from './usage.data-service';
-import { DyFM_RelativeDate } from '@futdevpro/fsm-dynamo';
-import { DyFM_UsageSession, DyFM_UsageData } from '@futdevpro/fsm-dynamo/usage';
-import { DyNTS_GlobalService } from '../../_services/core/global.service';
-import { DyNTS_DBService } from '../../_services/base/db.service';
-import { DyNTS_Shared } from '../../_services/shared.static-service';
-import { Request } from 'express';
-
-describe('| DyNTS_Usage_DataService', () => {
-  let service: DyNTS_Usage_DataService;
-  let mockDBService: jasmine.SpyObj<DyNTS_DBService<DyFM_UsageSession>>;
-  let mockRequest: Partial<Request>;
-
-  beforeEach(() => {
-    mockDBService = jasmine.createSpyObj('DyNTS_DBService', [
-      'getAll',
-      'getDataById',
-      'find',
-      'createData',
-      'modifyData',
-    ]);
-
-    spyOn(DyNTS_GlobalService, 'getDBService').and.returnValue(mockDBService);
-
-    mockRequest = {
-      ip: '127.0.0.1',
-      headers: {
-        'x-forwarded-for': '192.168.1.1',
-      },
-    };
-
-    service = new DyNTS_Usage_DataService({
-      usageSession: new DyFM_UsageSession({
-        _id: 'session-id',
-        sessionStart: new Date(),
-      }),
-      usageData: [],
-      issuer: 'test-issuer',
-    });
-  });
-
-  it('| should create service instance', () => {
-    expect(service).toBeDefined();
-    expect(service.data).toBeDefined();
-    expect(service.usageData).toEqual([]);
-    expect(service.simplifiedDailyUsage).toEqual([]);
-  });
-
-  it('| should initialize with usage data', () => {
-    const usageData: DyFM_UsageData[] = [
-      {
-        page: '/test',
-        opened: new Date(),
-        timeSpentOnPage: 1000,
-      },
-    ];
-
-    const serviceWithData = new DyNTS_Usage_DataService({
-      usageData,
-      issuer: 'test-issuer',
-    });
-
-    expect(serviceWithData.usageData).toEqual(usageData);
-  });
-
-  describe('| getLocationDataFromRequest', () => {
-    it('| should get location data from request', () => {
-      spyOn(DyNTS_Shared, 'getIpFromRequest').and.returnValue('192.168.1.1');
-      spyOn(DyNTS_Shared, 'getLocationDataByRequest').and.returnValue({
-        range: [0, 0],
-        country: 'US',
-        region: 'NY',
-        eu: '0',
-        timezone: 'America/New_York',
-        city: 'New York',
-        ll: [40.7128, -74.0060],
-        metro: 0,
-        area: 0,
-      });
-
-      service.getLocationDataFromRequest(mockRequest as Request);
-
-      expect(service.data.address).toBe('192.168.1.1');
-      expect(service.data.locationData).toBeDefined();
-      expect(service.data.locationData?.country).toBe('US');
-    });
-
-    it('| should throw error when location data retrieval fails', () => {
-      spyOn(DyNTS_Shared, 'getIpFromRequest').and.throwError('IP retrieval failed');
-
-      expect(() => {
-        service.getLocationDataFromRequest(mockRequest as Request);
-      }).toThrow();
-    });
-  });
-
-  describe('| getUsage', () => {
-    it('| should get usage data for range', async () => {
-      const mockSessions = [
-        new DyFM_UsageSession({
-          _id: 'session-1',
-          date: '2024-01-01',
-          sessionStart: new Date('2024-01-01'),
-          totalSessionTime: 5000,
-          locationData: {
-            range: [0, 0],
-            country: 'HU',
-            region: 'BU',
-            eu: '1',
-            timezone: 'Europe/Budapest',
-            city: 'Budapest',
-            ll: [47.4979, 19.0402],
-            metro: 0,
-            area: 0,
-          },
-        }),
-        new DyFM_UsageSession({
-          _id: 'session-2',
-          date: '2024-01-01',
-          sessionStart: new Date('2024-01-01'),
-          totalSessionTime: 3000,
-          locationData: {
-            range: [0, 0],
-            country: 'US',
-            region: 'NY',
-            eu: '0',
-            timezone: 'America/New_York',
-            city: 'New York',
-            ll: [40.7128, -74.0060],
-            metro: 0,
-            area: 0,
-          },
-        }),
-      ];
-      mockDBService.find.and.returnValue(Promise.resolve(mockSessions));
-
-      await service.getUsage(DyFM_RelativeDate.lastWeek);
-
-      expect(service.dataList.length).toBe(2);
-      expect(service.simplifiedDailyUsage.length).toBe(1);
-      expect(service.simplifiedDailyUsage[0].date).toBe('2024-01-01');
-      expect(service.simplifiedDailyUsage[0].visitorsHun).toBe(1);
-      expect(service.simplifiedDailyUsage[0].visitorsElse).toBe(1);
-      expect(service.simplifiedDailyUsage[0].totalVisitTime).toBe(8000);
-    });
-
-    it('| should group sessions by date', async () => {
-      const mockSessions = [
-        new DyFM_UsageSession({
-          _id: 'session-1',
-          date: '2024-01-01',
-          sessionStart: new Date('2024-01-01'),
-          totalSessionTime: 5000,
-        }),
-        new DyFM_UsageSession({
-          _id: 'session-2',
-          date: '2024-01-02',
-          sessionStart: new Date('2024-01-02'),
-          totalSessionTime: 3000,
-        }),
-      ];
-      mockDBService.find.and.returnValue(Promise.resolve(mockSessions));
-
-      await service.getUsage(DyFM_RelativeDate.lastWeek);
-
-      expect(service.simplifiedDailyUsage.length).toBe(2);
-    });
-
-    it('| should calculate average visit time', async () => {
-      const mockSessions = [
-        new DyFM_UsageSession({
-          _id: 'session-1',
-          date: '2024-01-01',
-          sessionStart: new Date('2024-01-01'),
-          totalSessionTime: 5000,
-        }),
-        new DyFM_UsageSession({
-          _id: 'session-2',
-          date: '2024-01-01',
-          sessionStart: new Date('2024-01-01'),
-          totalSessionTime: 3000,
-        }),
-      ];
-      mockDBService.find.and.returnValue(Promise.resolve(mockSessions));
-
-      await service.getUsage(DyFM_RelativeDate.lastWeek);
-
-      // Average is (5000 + 3000) / 2 = 4000 ms, then Math.round(4000 * 100) / 100 = 4000
-      expect(service.simplifiedDailyUsage[0].averageVisitTime).toBe(4000);
-    });
-
-    it('| should sort daily usage by date descending', async () => {
-      const mockSessions = [
-        new DyFM_UsageSession({
-          _id: 'session-1',
-          date: '2024-01-01',
-          sessionStart: new Date('2024-01-01'),
-          totalSessionTime: 5000,
-        }),
-        new DyFM_UsageSession({
-          _id: 'session-2',
-          date: '2024-01-02',
-          sessionStart: new Date('2024-01-02'),
-          totalSessionTime: 3000,
-        }),
-      ];
-      mockDBService.find.and.returnValue(Promise.resolve(mockSessions));
-
-      await service.getUsage(DyFM_RelativeDate.lastWeek);
-
-      expect(service.simplifiedDailyUsage[0].date).toBe('2024-01-02');
-      expect(service.simplifiedDailyUsage[1].date).toBe('2024-01-01');
-    });
-  });
-
-  describe('| updateUsageData', () => {
-    it('| should update usage data', async () => {
-      const existingSession = new DyFM_UsageSession({
-        _id: 'session-id',
-        sessionStart: new Date(),
-        usageData: [],
-      });
-      mockDBService.getDataById.and.returnValue(Promise.resolve(existingSession));
-      spyOn(service, 'saveData').and.returnValue(Promise.resolve(existingSession));
-      spyOn(service, 'getLocationDataFromRequest');
-
-      service.usageData = [
-        {
-          page: '/test',
-          opened: new Date(),
-          timeSpentOnPage: 1000,
-        },
-        {
-          page: '/test2',
-          opened: new Date(),
-          timeSpentOnPage: 2000,
-        },
-      ];
-
-      await service.updateUsageData(mockRequest as Request);
-
-      expect(service.saveData).toHaveBeenCalled();
-      expect(existingSession.totalSessionTime).toBe(3000);
-    });
-
-    it('| should throw error when session not found', async () => {
-      mockDBService.getDataById.and.returnValue(Promise.resolve(null));
-
-      await expectAsync(
-        service.updateUsageData(mockRequest as Request)
-      ).toBeRejected();
-    });
-
-    it('| should get location data if not present', async () => {
-      const existingSession = new DyFM_UsageSession({
-        _id: 'session-id',
-        sessionStart: new Date(),
-        usageData: [],
-      });
-      mockDBService.getDataById.and.returnValue(Promise.resolve(existingSession));
-      spyOn(service, 'saveData').and.returnValue(Promise.resolve(existingSession));
-      const getLocationSpy = spyOn(service, 'getLocationDataFromRequest');
-
-      await service.updateUsageData(mockRequest as Request);
-
-      expect(getLocationSpy).toHaveBeenCalled();
-    });
-  });
-
-  describe('| closeSession', () => {
-    it('| should close session', async () => {
-      const sessionStart = new Date('2024-01-01T10:00:00');
-      const existingSession = new DyFM_UsageSession({
-        _id: 'session-id',
-        sessionStart,
-        usageData: [
-          {
-            page: '/test',
-            opened: sessionStart,
-            timeSpentOnPage: 1000,
-          },
-        ],
-        totalSessionTime: 1000,
-      });
-      mockDBService.getDataById.and.returnValue(Promise.resolve(existingSession));
-      spyOn(service, 'saveData').and.returnValue(Promise.resolve(existingSession));
-      spyOn(service, 'getLocationDataFromRequest');
-
-      await service.closeSession(mockRequest as Request);
-
-      expect(existingSession.sessionEnd).toBeDefined();
-      expect(service.saveData).toHaveBeenCalled();
-    });
-
-    it('| should calculate total session time', async () => {
-      const sessionStart = new Date('2024-01-01T10:00:00');
-      const sessionEnd = new Date('2024-01-01T10:00:10');
-      const existingSession = new DyFM_UsageSession({
-        _id: 'session-id',
-        sessionStart,
-        usageData: [
-          {
-            page: '/test',
-            opened: sessionStart,
-            timeSpentOnPage: 1000,
-          },
-        ],
-        totalSessionTime: 1000,
-      });
-      mockDBService.getDataById.and.returnValue(Promise.resolve(existingSession));
-      spyOn(service, 'saveData').and.returnValue(Promise.resolve(existingSession));
-      spyOn(service, 'getLocationDataFromRequest');
-      jasmine.clock().install();
-      jasmine.clock().mockDate(sessionEnd);
-
-      await service.closeSession(mockRequest as Request);
-
-      expect(existingSession.totalSessionTime).toBe(10000);
-      jasmine.clock().uninstall();
-    });
-
-    it('| should throw error when session not found', async () => {
-      mockDBService.getDataById.and.returnValue(Promise.resolve(null));
-
-      await expectAsync(
-        service.closeSession(mockRequest as Request)
-      ).toBeRejected();
-    });
-  });
-});
-

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

@@ -1,185 +0,0 @@
-
-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 +0,0 @@
-
-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();
-    });
-  });
-});
-