[NEW] Add a bridge to the ITimers interface

src/definition/accessors/IAppAccessors.ts

@@ -1,9 +1,10 @@
-import { IEnvironmentRead, IHttp, IRead } from '../../definition/accessors';
+import { IEnvironmentRead, IHttp, IRead, ITimers } from '../../definition/accessors';
 import { IApiEndpointMetadata } from '../api';
 
 export interface IAppAccessors {
     readonly environmentReader: IEnvironmentRead;
     readonly reader: IRead;
     readonly http: IHttp;
     readonly providedApiEndpoints: Array<IApiEndpointMetadata>;
+    readonly timers: ITimers;
 }

src/definition/accessors/ITimers.ts

@@ -0,0 +1,3 @@
+export interface ITimers {
+    call(nameMethod: string): (callback: (...args: Array<any>) => void, ms: number, ...args: Array<any>) => NodeJS.Timeout;
+}

src/definition/accessors/index.ts

@@ -39,6 +39,7 @@ import { ISettingRead } from './ISettingRead';
 import { ISettingsExtend } from './ISettingsExtend';
 import { ISlashCommandsExtend } from './ISlashCommandsExtend';
 import { ISlashCommandsModify } from './ISlashCommandsModify';
+import { ITimers } from './ITimers';
 import { IUIController } from './IUIController';
 import { IUploadCreator } from './IUploadCreator';
 import { IUploadRead } from './IUploadRead';
@@ -84,6 +85,7 @@ export {
     IRoomBuilder,
     IRoomExtender,
     IRoomRead,
+    ITimers,
     IServerSettingRead,
     IServerSettingsModify,
     ISettingRead,

src/server/accessors/AppAccessors.ts

@@ -1,4 +1,4 @@
-import { IAppAccessors, IEnvironmentRead, IHttp, IRead } from '../../definition/accessors';
+import { IAppAccessors, IEnvironmentRead, IHttp, IRead, ITimers } from '../../definition/accessors';
 import { IApiEndpointMetadata } from '../../definition/api';
 import { AppManager } from '../AppManager';
 import { AppAccessorManager } from '../managers/AppAccessorManager';
@@ -28,4 +28,8 @@ export class AppAccessors implements IAppAccessors {
     public get providedApiEndpoints(): Array<IApiEndpointMetadata> {
         return this.apiManager.listApis(this.appId);
     }
+
+    public get timers(): ITimers {
+        return this.accessorManager.getTimers(this.appId);
+    }
 }

src/server/accessors/Timers.ts

@@ -0,0 +1,9 @@
+import { ITimers } from '../../definition/accessors/ITimers';
+import { AppBridges } from '../bridges/AppBridges';
+
+export class Timers implements ITimers {
+    constructor(private readonly bridges: AppBridges) { }
+    public call(nameMethod: string): (callback: (...args: Array<any>) => void, ms: number, ...args: Array<any>) => NodeJS.Timeout {
+        return this.bridges.getTimersBridge().call(nameMethod);
+    }
+}

src/server/accessors/index.ts

@@ -30,6 +30,7 @@ import { SettingRead } from './SettingRead';
 import { SettingsExtend } from './SettingsExtend';
 import { SlashCommandsExtend } from './SlashCommandsExtend';
 import { SlashCommandsModify } from './SlashCommandsModify';
+import { Timers } from './Timers';
 import { UploadRead } from './UploadRead';
 import { UserBuilder } from './UserBuilder';
 import { UserRead } from './UserRead';
@@ -65,6 +66,7 @@ export {
     SettingsExtend,
     SlashCommandsExtend,
     SlashCommandsModify,
+    Timers,
     UploadRead,
     UserBuilder,
     UserRead,

src/server/bridges/AppBridges.ts

@@ -13,6 +13,7 @@ import { PersistenceBridge } from './PersistenceBridge';
 import { RoomBridge } from './RoomBridge';
 import { SchedulerBridge } from './SchedulerBridge';
 import { ServerSettingBridge } from './ServerSettingBridge';
+import { TimersBridge } from './TimersBridge';
 import { UiInteractionBridge } from './UiInteractionBridge';
 import { UploadBridge } from './UploadBridge';
 import { UserBridge } from './UserBridge';
@@ -48,6 +49,7 @@ export abstract class AppBridges {
     public abstract getRoomBridge(): RoomBridge;
     public abstract getInternalBridge(): IInternalBridge;
     public abstract getServerSettingBridge(): ServerSettingBridge;
+    public abstract getTimersBridge(): TimersBridge;
     public abstract getUploadBridge(): UploadBridge;
     public abstract getUserBridge(): UserBridge;
     public abstract getUiInteractionBridge(): UiInteractionBridge;

src/server/bridges/TimersBridge.ts

@@ -0,0 +1,6 @@
+import { BaseBridge } from './BaseBridge';
+
+export abstract class TimersBridge extends BaseBridge {
+
+    public abstract call(nameMethod: string): (callback: (...args: Array<any>) => void, ms: number, ...args: Array<any>) => NodeJS.Timeout;
+}

src/server/bridges/index.ts

@@ -14,6 +14,7 @@ import { PersistenceBridge } from './PersistenceBridge';
 import { RoomBridge } from './RoomBridge';
 import { SchedulerBridge } from './SchedulerBridge';
 import { ServerSettingBridge } from './ServerSettingBridge';
+import { TimersBridge } from './TimersBridge';
 import { UiInteractionBridge } from './UiInteractionBridge';
 import { UploadBridge } from './UploadBridge';
 import { UserBridge } from './UserBridge';
@@ -34,6 +35,7 @@ export {
     RoomBridge,
     IInternalBridge,
     ServerSettingBridge,
+    TimersBridge,
     UserBridge,
     UploadBridge,
     UiInteractionBridge,

src/server/managers/AppAccessorManager.ts

@@ -7,6 +7,7 @@ import {
     IModify,
     IPersistence,
     IRead,
+    ITimers,
 } from '../../definition/accessors';
 import {
     ApiExtend,
@@ -33,6 +34,7 @@ import {
     SettingsExtend,
     SlashCommandsExtend,
     SlashCommandsModify,
+    Timers,
     UploadRead,
     UserRead,
 } from '../accessors';
@@ -49,6 +51,7 @@ export class AppAccessorManager {
     private readonly modifiers: Map<string, IModify>;
     private readonly persists: Map<string, IPersistence>;
     private readonly https: Map<string, IHttp>;
+    private readonly timers: Map<string, ITimers>;
 
     constructor(private readonly manager: AppManager) {
         this.bridges = this.manager.getBridges();
@@ -59,6 +62,7 @@ export class AppAccessorManager {
         this.modifiers = new Map<string, IModify>();
         this.persists = new Map<string, IPersistence>();
         this.https = new Map<string, IHttp>();
+        this.timers = new Map<string, Timers>();
     }
 
     /**
@@ -74,6 +78,7 @@ export class AppAccessorManager {
         this.modifiers.delete(appId);
         this.persists.delete(appId);
         this.https.delete(appId);
+        this.timers.delete(appId);
     }
 
     public getConfigurationExtend(appId: string): IConfigurationExtend {
@@ -176,4 +181,12 @@ export class AppAccessorManager {
 
         return this.https.get(appId);
     }
+
+    public getTimers(appId: string): ITimers {
+        if (!this.timers.has(appId)) {
+            this.timers.set(appId, new Timers(this.bridges));
+        }
+        return this.timers.get(appId);
+    }
+
 }

tests/server/accessors/Timers.spec.ts

@@ -0,0 +1,37 @@
+import {Expect, SetupFixture, SpyOn, Test} from 'alsatian';
+
+import { Timers } from '../../../src/server/accessors';
+import { AppBridges, TimersBridge } from '../../../src/server/bridges';
+
+export class TimersAccessorsTestFixture {
+    private mockAppBridge: AppBridges;
+    private mockTimersBridge: TimersBridge;
+    private mockTimeout: NodeJS.Timeout;
+
+    @SetupFixture
+    public setupFixture() {
+        const timeout = this.mockTimeout as NodeJS.Timeout;
+        this.mockTimersBridge = {
+            call(nameMethod: string): (callback: (...args: Array<any>) => void, ms: number, ...args: Array<any>) => NodeJS.Timeout {
+                return (callback: (...args: Array<any>) => void, ms: number, ...args: Array<any>) => timeout;
+            },
+        } as TimersBridge;
+
+        const timersBridge = this.mockTimersBridge;
+        this.mockAppBridge = { getTimersBridge(): TimersBridge {
+                return timersBridge;
+            },
+        } as AppBridges;
+    }
+
+    @Test()
+    public useTimers() {
+        Expect(() => new Timers(this.mockAppBridge)).not.toThrow();
+
+        const timers = new Timers(this.mockAppBridge);
+        Expect(timers.call('nameMethod')).toBeDefined();
+
+        SpyOn(this.mockTimersBridge, 'call');
+        SpyOn(timers, 'call');
+    }
+}

tests/test-data/bridges/appBridges.ts

@@ -12,6 +12,7 @@ import {
     RoomBridge,
     SchedulerBridge,
     ServerSettingBridge,
+    TimersBridge,
     UiInteractionBridge,
     UploadBridge,
     UserBridge,
@@ -31,6 +32,7 @@ import { TestsPersisBridge } from './persisBridge';
 import { TestsRoomBridge } from './roomBridge';
 import { TestSchedulerBridge } from './schedulerBridge';
 import { TestsServerSettingBridge } from './serverSettingBridge';
+import { TestsTimersBridge } from './timersBridge';
 import { TestsUiIntegrationBridge } from './uiIntegrationBridge';
 import { TestUploadBridge } from './uploadBridge';
 import { TestsUserBridge } from './userBridge';
@@ -51,6 +53,7 @@ export class TestsAppBridges extends AppBridges {
     private readonly livechatBridge: TestLivechatBridge;
     private readonly uploadBridge: TestUploadBridge;
     private readonly uiIntegrationBridge: TestsUiIntegrationBridge;
+    private readonly timersBridge: TestsTimersBridge;
     private readonly schedulerBridge: TestSchedulerBridge;
     private readonly cloudWorkspaceBridge: TestAppCloudWorkspaceBridge;
 
@@ -71,6 +74,7 @@ export class TestsAppBridges extends AppBridges {
         this.livechatBridge = new TestLivechatBridge();
         this.uploadBridge = new TestUploadBridge();
         this.uiIntegrationBridge = new TestsUiIntegrationBridge();
+        this.timersBridge = new TestsTimersBridge();
         this.schedulerBridge = new TestSchedulerBridge();
         this.cloudWorkspaceBridge = new TestAppCloudWorkspaceBridge();
     }
@@ -139,6 +143,10 @@ export class TestsAppBridges extends AppBridges {
         return this.uiIntegrationBridge;
     }
 
+    public getTimersBridge(): TimersBridge {
+        return this.timersBridge;
+    }
+
     public getSchedulerBridge(): SchedulerBridge {
         return this.schedulerBridge;
     }

tests/test-data/bridges/timersBridge.ts

@@ -0,0 +1,7 @@
+import { TimersBridge } from '../../../src/server/bridges/TimersBridge';
+
+export class TestsTimersBridge extends TimersBridge {
+    public call(nameMethod: string): (callback: (...args: Array<any>) => void, ms: number, ...args: Array<any>) => NodeJS.Timeout {
+        throw new Error('Method not implemented.');
+    }
+}