http-request-manager 18.15.32 → 18.15.34

package/src/lib/http-request-services-demo/request-manager-ws-demo/components/services/state-data-request.service.ts

@@ -0,0 +1,119 @@
+import { Injectable } from '@angular/core';
+import { RandomNumber } from '../../../../services/utils/encryption/random';
+import { RetryOptions, DataType, DatabaseStorage } from '../../../../models';
+
+import { HTTPManagerStateService, ApiRequest, RequestOptions } from '../../../../services';
+
+import { OIDCClient } from '../../models/oidc-client.model';
+import { UserData } from '../../models/user-data.model';
+import { ChannelMessage } from '../../../../services/ws-manager-service/models/channel-message.model';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class StateDataRequestService extends HTTPManagerStateService<any> {
+
+  attempts$ = this.wsRetryAttempts$
+  nextRetry$ = this.wsNextRetry$
+
+  path: (string|number)[] = ['ai','tests']
+
+  constructor() {
+    super(
+        ApiRequest.adapt({
+          server: '',
+          retry: RetryOptions.adapt({
+            times: 3,
+            delay: 1,
+          }),
+          adapter: OIDCClient.adapt,
+          ws: {
+            id: ``,
+            // wsChannels: ['allChannels'],
+            // access: ['read,write,delete,update'],
+            wsServer: '',
+            jwtToken: '',
+            user: UserData.adapt(),
+            retry: RetryOptions.adapt({
+              times: 3,
+              delay: 10,
+            }),
+          }
+        }),
+        DataType.ARRAY,
+        DatabaseStorage.adapt({
+          table: 'ws_demo_data',
+          expiresIn: '5mn',
+        })
+      )
+    }
+
+    updateConnection(
+      server: string,
+      wsServer: string,
+      jwtToken: string,
+      user: any,
+      path: (string|number)[] = [],
+    ) {
+
+      this.path = path
+
+      this.setApiRequestOptions({
+          server,
+          retry: RetryOptions.adapt({
+            times: 3,
+            delay: 1,
+          }),
+          adapter: OIDCClient.adapt,
+          ws: {
+            id: this.path.join('/'),
+            wsServer,
+            jwtToken,
+            user, // general info about user
+            retry: RetryOptions.adapt({
+              times: 3,
+              delay: 10,
+            }),
+          }
+        })
+
+    }
+
+    addData() {
+
+      const num = RandomNumber(1000, 9999)
+
+      const newData =     {
+          "spiffe": `sample.com/developer/${num}`,
+          "last_name": "boni",
+          "email": "mikeboni@hotmail.com",
+          "first_name": "mike"
+      }
+
+      this.createRecord(newData, RequestOptions.adapt({ path: this.path }) )
+
+    }
+
+    sendMessage(data: ChannelMessage) {
+      console.log('sendMessage', data)
+      this.wsMessaging(data)
+    }
+
+    getData() {
+      this.fetchRecords(RequestOptions.adapt({ path: this.path }) )
+    }
+
+    updateData(data: any) {
+      const sampleOptions = RequestOptions.adapt({ path: [...this.path, data.id] })
+      console.log('updateData', sampleOptions)
+      this.updateRecord(data, sampleOptions)
+
+    }
+
+    deleteData(data: any) {
+      const sampleOptions = RequestOptions.adapt({ path: [...this.path, data.id] })
+      console.log('deleteData', sampleOptions)
+      this.deleteRecord(sampleOptions)
+    }
+
+}

package/src/lib/http-request-services-demo/request-manager-ws-demo/components/ws-ai-messaging/ws-ai-messaging.component.html

@@ -0,0 +1,3 @@
+<p>
+  ws-ai-messaging coming soon!
+</p>

package/src/lib/http-request-services-demo/request-manager-ws-demo/components/ws-ai-messaging/ws-ai-messaging.component.ts

@@ -0,0 +1,16 @@
+import { Component, OnInit } from '@angular/core';
+
+@Component({
+    selector: 'app-ws-ai-messaging',
+    templateUrl: './ws-ai-messaging.component.html',
+    styleUrls: ['./ws-ai-messaging.component.css'],
+    standalone: false
+})
+export class WsAiMessagingComponent implements OnInit {
+
+  constructor() { }
+
+  ngOnInit() {
+  }
+
+}

package/src/lib/http-request-services-demo/request-manager-ws-demo/components/ws-chats/ws-chats.component.html

@@ -0,0 +1,3 @@
+<p>
+  ws-chats coming soon!
+</p>

package/src/lib/http-request-services-demo/request-manager-ws-demo/components/ws-chats/ws-chats.component.ts

@@ -0,0 +1,16 @@
+import { Component, OnInit } from '@angular/core';
+
+@Component({
+    selector: 'app-ws-chats',
+    templateUrl: './ws-chats.component.html',
+    styleUrls: ['./ws-chats.component.css'],
+    standalone: false
+})
+export class WsChatsComponent implements OnInit {
+
+  constructor() { }
+
+  ngOnInit() {
+  }
+
+}

package/src/lib/http-request-services-demo/request-manager-ws-demo/components/ws-data-control/ws-data-control.component.css

@@ -0,0 +1,31 @@
+/* Highlight the current user chip with the theme primary color */
+.user-chip--primary {
+  /* Prefer MDC/Material tokens; fall back to a safe primary */
+  background-color: var(--mdc-theme-primary, var(--md-sys-color-primary, #3f51b5)) !important;
+  /* Ensure foreground text renders white */
+  color: #fff !important;
+  /* Also set MDC chip variables where applicable */
+  --mdc-evolution-chip-container-color: var(--mdc-theme-primary, var(--md-sys-color-primary, #3f51b5));
+  --mdc-evolution-chip-label-text-color: #fff;
+}
+
+/* Force inner MDC chip parts to inherit white foreground */
+.user-chip--primary :is(
+  .mdc-evolution-chip__text-label,
+  .mdc-evolution-chip__action,
+  .mdc-evolution-chip__cell,
+  .mat-mdc-chip-action-label
+) {
+  color: #fff !important;
+}
+
+/* Strong fallback: ensure all descendants render white */
+.user-chip--primary,
+.user-chip--primary * {
+  color: #fff !important;
+}
+.box {
+  padding: .5rem;
+  border: 1px solid rgb(174, 174, 13);
+  background-color: rgb(236, 236, 175);
+}

package/src/lib/http-request-services-demo/request-manager-ws-demo/components/ws-data-control/ws-data-control.component.html

@@ -0,0 +1,94 @@
+@if ((data$ | async); as data) {
+  <div style="margin: 1rem;">
+    @if ((users$ |async); as users) {
+      <div>
+        @if (users.length > 0) {
+          <h3 style="margin: 0;">Connected Users</h3>
+        } @else {
+          <h3 style="margin: 0;">No Users</h3>
+        }
+        <mat-chip-set>
+          @for (user of users; track $index) {
+            <mat-chip
+              [class.user-chip--primary]="isUser(user, (user$ | async))"
+              [style.color]="isUser(user, (user$ | async)) ? '#fff' : null"
+              [disableRipple]="true"
+            >
+              {{ user.name || user.ldap || user.id || 'Anonymous' }}
+            </mat-chip>
+          }
+        </mat-chip-set>
+      </div>
+    }
+    <div style="margin-top: 1rem; margin-bottom: 1rem;">
+      <mat-divider></mat-divider>
+    </div>
+
+    <div class="box" style="margin-bottom: 1rem;" *ngIf="(userAction$ | async) as userAction">
+      {{ userAction?.content?.user?.name }} has {{ userAction?.content?.method }}
+    </div>
+
+    <h3 style="margin: 0;">Data Actions</h3>
+    <div style="display: flex; gap: 1rem; margin-bottom: 1rem;">
+      <button mat-stroked-button (click)="onGetData()">Get Data</button>
+      <div style="flex:1"></div>
+      <button mat-stroked-button color="accent" (click)="onUpdateData(data)">Update Data</button>
+      <button mat-stroked-button color="warn" (click)="onRemoveData(data)">Remove Data</button>
+      <button mat-stroked-button color="primary" (click)="onAddData()">Add Data</button>
+    </div>
+
+    <h3 style="margin: 0; margin-top: 1rem;">WebSocketMessageService Test</h3>
+
+    <p style="font-size: 0.875rem; color: #666; margin: 0;">
+      <strong>Note:</strong> "Fake SessionId" will be received and processed. "Current SessionId" will be filtered out (self-message).
+    @if (data.length > 0) {
+      <div>
+        <table mat-table [dataSource]="data" style="border: 1px solid grey;">
+          <ng-container matColumnDef="id">
+            <th mat-header-cell *matHeaderCellDef> ID </th>
+            <td mat-cell *matCellDef="let element"> {{element.id}} </td>
+          </ng-container>
+          <ng-container matColumnDef="spiffe">
+            <th mat-header-cell *matHeaderCellDef> Spiffe </th>
+            <td mat-cell *matCellDef="let element"> {{element.spiffe}} </td>
+          </ng-container>
+          <ng-container matColumnDef="name">
+            <th mat-header-cell *matHeaderCellDef> Name </th>
+            <td mat-cell *matCellDef="let element"> {{element.first_name}} {{element.last_name}}</td>
+          </ng-container>
+          <ng-container matColumnDef="email">
+            <th mat-header-cell *matHeaderCellDef> Email </th>
+            <td mat-cell *matCellDef="let element"> {{element.email}} </td>
+          </ng-container>
+          <tr mat-header-row *matHeaderRowDef="['id', 'spiffe', 'name', 'email']"></tr>
+          <tr mat-row *matRowDef="let row; columns: ['id', 'spiffe', 'name', 'email'];"></tr>
+        </table>
+        <div style="border: 1px solid grey; padding: .5rem; border-top: none;">
+          <h3 style="margin: 0;">Total Records {{ data.length }}</h3>
+        </div>
+      </div>
+    } @else {
+      <div style="margin-top: 1rem; font-style: italic;">
+        No Data Available
+      </div>
+    }
+
+    <div style="margin-bottom: 1rem; margin-top: 1rem;">
+      <mat-divider></mat-divider>
+    </div>
+
+    <div style="display: flex; gap: 0.5rem; margin-bottom: 1rem;">
+      <button mat-flat-button color="primary" (click)="onTestDirectStateMessage(63, true)">
+        Test UPDATE (Fake Id)
+      </button>
+      <button mat-stroked-button (click)="onTestDirectStateMessage(63, false)">
+        Test UPDATE (Current Id)
+      </button>
+      <button mat-stroked-button (click)="onTestDirectStateMessage(63, false, 'custom-session-123')">
+        Test UPDATE (Custom Id)
+      </button>
+    </div>
+
+  </div>
+}
+

package/src/lib/http-request-services-demo/request-manager-ws-demo/components/ws-data-control/ws-data-control.component.scss

@@ -0,0 +1,41 @@
+.user-chip--primary {
+  background-color: var(--mdc-theme-primary, var(--md-sys-color-primary, #3f51b5)) !important;
+  color: #fff !important;
+  --mdc-evolution-chip-container-color: var(--mdc-theme-primary, var(--md-sys-color-primary, #3f51b5));
+  --mdc-evolution-chip-label-text-color: #fff;
+}
+
+.user-chip--primary :is(
+  .mdc-evolution-chip__text-label,
+  .mdc-evolution-chip__action,
+  .mdc-evolution-chip__cell,
+  .mat-mdc-chip-action-label
+) {
+  color: #fff !important;
+}
+
+.user-chip--primary,
+.user-chip--primary * {
+  color: #fff !important;
+}
+
+:host ::ng-deep .user-chip--primary {
+  background-color: var(--mdc-theme-primary, var(--md-sys-color-primary, #3f51b5)) !important;
+  color: #fff !important;
+  --mdc-evolution-chip-container-color: var(--mdc-theme-primary, var(--md-sys-color-primary, #3f51b5));
+  --mdc-evolution-chip-label-text-color: #fff;
+
+  .mdc-evolution-chip__text-label,
+  .mdc-evolution-chip__action,
+  .mdc-evolution-chip__cell,
+  .mat-mdc-chip-action-label,
+  * {
+    color: #fff !important;
+  }
+}
+
+.box {
+  padding: .5rem;
+  border: 1px solid rgb(174, 174, 13);
+  background-color: rgb(236, 236, 175);
+}

package/src/lib/http-request-services-demo/request-manager-ws-demo/components/ws-data-control/ws-data-control.component.spec.ts

@@ -0,0 +1,203 @@
+import { ComponentFixture, TestBed, fakeAsync, tick } from '@angular/core/testing';
+import { WsDataControlComponent } from './ws-data-control.component';
+import { StateDataRequestService } from '../services/state-data-request.service';
+import { BehaviorSubject } from 'rxjs';
+import { MatChipsModule } from '@angular/material/chips';
+import { MatTableModule } from '@angular/material/table';
+import { MatButtonModule } from '@angular/material/button';
+import { MatDividerModule } from '@angular/material/divider';
+import { NoopAnimationsModule } from '@angular/platform-browser/animations';
+import { CommonModule } from '@angular/common';
+
+describe('WsDataControlComponent', () => {
+  let component: WsDataControlComponent;
+  let fixture: ComponentFixture<WsDataControlComponent>;
+
+  // Mock Data
+  const mockUser = { sessionId: 'session-123', name: 'Mike Boni' };
+  const mockUsers = [mockUser, { sessionId: 'session-456', name: 'Other User' }];
+  const mockData = [
+    { id: 1, spiffe: 'wavecoders.com/developer/1111', first_name: 'John', last_name: 'Doe', email: 'john@test.com' },
+    { id: 63, spiffe: 'wavecoders.com/developer/2222', first_name: 'mike', last_name: 'boni', email: 'mikeboni@hotmail.com' }
+  ];
+  const mockAction = { content: { user: mockUser, method: 'updated data' } };
+
+  // Subjects to control the observables in the mock service
+  const userSubject = new BehaviorSubject<any>(mockUser);
+  const usersSubject = new BehaviorSubject<any[]>(mockUsers);
+  const userActionSubject = new BehaviorSubject<any>(mockAction);
+  const dataSubject = new BehaviorSubject<any[]>(mockData);
+
+  // Mock Service Class
+  class MockStateDataRequestService {
+    user$ = userSubject.asObservable();
+    userList$ = usersSubject.asObservable();
+    userAction$ = userActionSubject.asObservable();
+    data$ = dataSubject.asObservable();
+
+    updateConnection(server: string, wsServer: string, jwtToken: string, user: any, path: (string|number)[]) {}
+    getData() {}
+    addData() {}
+    updateData(data: any) {}
+    deleteData(data: any) {}
+  }
+
+  let mockServiceInstance: MockStateDataRequestService;
+
+  beforeEach(async () => {
+    // Ensure mock data is available immediately
+    dataSubject.next(mockData);
+    userSubject.next(mockUser);
+    usersSubject.next(mockUsers);
+    userActionSubject.next(mockAction);
+
+    // Create mock service instance
+    mockServiceInstance = new MockStateDataRequestService();
+
+    // Spy on methods
+    spyOn(mockServiceInstance, 'updateConnection');
+    spyOn(mockServiceInstance, 'getData');
+    spyOn(mockServiceInstance, 'addData');
+    spyOn(mockServiceInstance, 'updateData');
+    spyOn(mockServiceInstance, 'deleteData');
+
+    await TestBed.configureTestingModule({
+      declarations: [WsDataControlComponent],
+      imports: [
+        CommonModule,
+        MatChipsModule,
+        MatTableModule,
+        MatButtonModule,
+        MatDividerModule,
+        NoopAnimationsModule
+      ],
+      providers: [
+        { provide: StateDataRequestService, useValue: mockServiceInstance }
+      ]
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(WsDataControlComponent);
+    component = fixture.componentInstance;
+
+    // Set required @Input properties
+    component.server = 'http://api.test.com';
+    component.wsServer = 'ws://ws.test.com';
+    component.jwtToken = 'mock-jwt-token';
+    component.user = mockUser;
+    component.path = ['ai', 'tests'];
+
+    // Ensure initial data is available for table rendering test
+    fixture.detectChanges();
+  });
+
+  it('should create the component', () => {
+    expect(component).toBeTruthy();
+  });
+
+  it('should call updateConnection and getData during initialization', () => {
+    expect(mockServiceInstance.updateConnection).toHaveBeenCalledWith(
+      component.server,
+      component.wsServer,
+      component.jwtToken,
+      component.user,
+      component.path
+    );
+    expect(mockServiceInstance.getData).toHaveBeenCalled();
+  });
+
+  it('should call getData when onGetData is triggered', () => {
+    component.onGetData();
+    // once during init, once during manual call
+    expect(mockServiceInstance.getData).toHaveBeenCalledTimes(2);
+  });
+
+  it('should call addData when onAddData is triggered', () => {
+    component.onAddData();
+    expect(mockServiceInstance.addData).toHaveBeenCalled();
+  });
+
+  it('should call updateData with generated random spiffe when onUpdateData is triggered', () => {
+    // Call the method - we can't easily mock RandomNumber, so we just verify updateData is called
+    component.onUpdateData(mockData);
+
+    expect(mockServiceInstance.updateData).toHaveBeenCalled();
+
+    // Verify the data structure passed to updateData
+    const callArgs = (mockServiceInstance.updateData as any).calls.mostRecent().args[0];
+    expect(callArgs).toBeDefined();
+    expect(callArgs.spiffe).toBeDefined();
+    expect(callArgs.spiffe).toMatch(/^wavecoders\.com\/developer\/\d{4,5}$/);
+    expect(callArgs.id).toBe(63);
+    expect(callArgs.first_name).toBe('mike');
+    expect(callArgs.last_name).toBe('boni');
+    expect(callArgs.email).toBe('mikeboni@hotmail.com');
+  });
+
+  it('should call deleteData with the last record when onRemoveData is triggered', () => {
+    component.onRemoveData(mockData);
+    const lastRecord = mockData[mockData.length - 1];
+    expect(mockServiceInstance.deleteData).toHaveBeenCalledWith(lastRecord);
+  });
+
+  it('should correctly verify if a user is the current user via isUser', () => {
+    const userA = { sessionId: 'AAA' };
+    const userB = { sessionId: 'AAA' };
+    const userC = { sessionId: 'CCC' };
+
+    expect(component.isUser(userA, userB)).toBeTrue();
+    expect(component.isUser(userA, userC)).toBeFalse();
+  });
+
+  it('should handle userAction$ timing logic (reset after 3 seconds)', fakeAsync(() => {
+    let currentAction: any;
+    const sub = component.userAction$.subscribe(val => currentAction = val);
+
+    // 1. Initial state (from BehaviorSubject)
+    expect(currentAction).toEqual(mockAction);
+
+    // 2. Push new action
+    const newAction = { content: { user: mockUser, method: 'added data' } };
+    userActionSubject.next(newAction);
+    tick(); // process the pipe
+    expect(currentAction).toEqual(newAction);
+
+    // 3. Wait 3 seconds
+    tick(3000);
+    expect(currentAction).toBeNull();
+
+    sub.unsubscribe();
+  }));
+
+  it('should render the table when data is available', fakeAsync(() => {
+    // Initial setup
+    fixture.detectChanges();
+    tick();
+
+    const compiled = fixture.nativeElement as HTMLElement;
+
+    // Multiple rounds of change detection to ensure async pipes resolve
+    for (let i = 0; i < 3; i++) {
+      fixture.detectChanges();
+      tick();
+    }
+
+    const table = compiled.querySelector('table');
+    expect(table).toBeTruthy();
+
+    // Give Angular Material table more time to render
+    fixture.detectChanges();
+    tick();
+
+    // Check for table rows (header + data rows)
+    const rows = compiled.querySelectorAll('tr');
+    expect(rows.length).toBeGreaterThan(1);
+  }));
+
+  it('should display "No Data Available" when data list is empty', () => {
+    dataSubject.next([]);
+    fixture.detectChanges();
+
+    const compiled = fixture.nativeElement as HTMLElement;
+    expect(compiled.textContent).toContain('No Data Available');
+  });
+});

package/src/lib/http-request-services-demo/request-manager-ws-demo/components/ws-data-control/ws-data-control.component.ts

@@ -0,0 +1,144 @@
+import { Component, inject, Input, OnInit } from '@angular/core';
+import { RandomNumber } from '../../../../services/utils/encryption/random';
+
+import { StateDataRequestService } from '../services/state-data-request.service';
+import { switchMap, timer, map, startWith } from 'rxjs';
+import { WebSocketMessageService } from '../../../../services/ws-manager-service/services/websocket-message.service';
+import { StateMessage } from '../../../../services/ws-manager-service/models/state-message.model';
+
+@Component({
+    selector: 'app-ws-data-control',
+    templateUrl: './ws-data-control.component.html',
+    styleUrls: ['./ws-data-control.component.scss'],
+    standalone: false
+})
+export class WsDataControlComponent implements OnInit {
+
+  @Input() server!: string;
+  @Input() wsServer!: string;
+  @Input() jwtToken!: string;
+  @Input() user!: any;
+  @Input() path: (string|number)[] = ['ai','tests'];
+
+  stateDataRequestService = inject(StateDataRequestService)
+  webSocketMessageService = inject(WebSocketMessageService)
+
+  user$ = this.stateDataRequestService.user$
+  users$ = this.stateDataRequestService.userList$
+
+  userAction$ = this.stateDataRequestService.userAction$
+  .pipe(
+    switchMap((action) =>
+      timer(3 * 1000).pipe(
+        map(() => null),
+        startWith(action)
+      )
+    )
+  );
+
+  data$ = this.stateDataRequestService.data$;
+
+  isUser = (user: any, userItem: any) => {
+    return user.sessionId === userItem.sessionId
+  }
+
+  ngOnInit() {
+    this.stateDataRequestService.updateConnection(this.server, this.wsServer, this.jwtToken, this.user, this.path);
+    this.stateDataRequestService.getData()
+  }
+
+  onGetData() {
+    this.stateDataRequestService.getData()
+  }
+
+  onAddData() {
+    this.stateDataRequestService.addData()
+  }
+
+  onUpdateData(data: any[]) {
+
+    const num = RandomNumber(1000, 9999)
+
+    const newData = {
+      "spiffe": `wavecoders.com/developer/${num}`,
+      "id": 63,
+      "last_name": "boni",
+      "email": "mikeboni@hotmail.com",
+      "first_name": "mike"
+    }
+
+    this.stateDataRequestService.updateData(newData)
+
+  }
+
+  onRemoveData(data: any) {
+    const lastRec = data[data.length -1]
+    this.stateDataRequestService.deleteData(lastRec)
+  }
+
+  /**
+   * Test direct state message via WebSocketMessageService
+   * Sends an UPDATE message that should trigger fetchRecord() in the state manager
+   *
+   * @param recordId - The record ID to update (default: 63)
+   * @param useFakeSessionId - If true, uses a fake sessionId to avoid filtering (default: true)
+   * @param customSessionId - Optional custom sessionId (overrides useFakeSessionId if provided)
+   */
+  onTestDirectStateMessage(recordId: number = 63, useFakeSessionId: boolean = true, customSessionId?: string) {
+    // Get actual sessionId from sessionStorage (stored by HTTPManagerStateService)
+    const actualSessionId = sessionStorage.getItem('WSID') || 'unknown';
+
+    // Determine sessionId to use
+    let sessionId: string;
+    if (customSessionId) {
+      sessionId = customSessionId;
+    } else if (useFakeSessionId) {
+      sessionId = `test-${Date.now()}`;
+    } else {
+      // Use actual sessionId (will be filtered out by receiver)
+      sessionId = actualSessionId;
+    }
+
+    // Build StateMessage with same structure as CRUD operations
+    const stateMessage: StateMessage = {
+      sessionId: {
+        id: sessionId,
+        name: useFakeSessionId ? 'Test Sender' : (this.user?.name || 'Current User')
+      },
+      content: {
+        method: 'UPDATE',
+        path: ['ai', 'tests', recordId],
+        user: {
+          id: sessionId,
+          name: useFakeSessionId ? 'Test Sender' : (this.user?.name || 'Current User')
+        }
+      }
+    };
+
+    console.log('🧪 [TEST] Sending direct state message:', {
+      recordId,
+      sessionId,
+      actualSessionId,
+      useFakeSessionId,
+      stateMessage
+    });
+
+    const success = this.webSocketMessageService.sendStateMessage(
+      ['ai', 'tests'],
+      stateMessage
+    );
+
+    console.log('🧪 [TEST] Message sent:', {
+      success,
+      actualSessionId,
+      sentSessionId: sessionId,
+      expectedBehavior: success
+        ? 'Server will broadcast to SYS-ai/tests subscribers'
+        : 'Failed to send (check connection)',
+      receiverBehavior: sessionId !== actualSessionId
+        ? 'Receiver will process message and call fetchRecord()'
+        : 'Receiver will filter out (sessionId match)'
+    });
+  }
+
+}