easyproctor 2.1.0 → 2.2.0

package/interfaces/ParamsConfig.d.ts

@@ -23,9 +23,12 @@ export type VideoBehaviourParameters = {
     detectCellPhone?: boolean;
     detectNoise?: boolean;
     detectSpeech?: boolean;
+    retryEnabled?: boolean;
+    maxRetries?: number;
 };
 export default interface IParamsConfig {
     audioBehaviourParameters?: AudioBehaviourParameters;
     imageBehaviourParameters?: ImageBehaviourParameters;
     videoBehaviourParameters?: VideoBehaviourParameters;
+    spyScanInterval?: number;
 }

package/modules/SpyCam.d.ts

@@ -0,0 +1,31 @@
+import { DevicesInterface } from "../new-flow/backend/SpyCamBackendService";
+import { ProctoringContext } from "../proctoring/proctoring";
+export interface SpyCamDevice {
+    macAddress: string;
+    destinationsCount: number;
+    totalPackages: number;
+    packageRate: number;
+    rssi: number;
+    deviceType: number;
+}
+export declare class SpyCam {
+    private backendService;
+    private readonly context;
+    private readonly backend;
+    private proctoringId;
+    private scanInterval;
+    private startTime;
+    private checkSpyCam;
+    private currentIsPlugged;
+    private options;
+    constructor(context: ProctoringContext, options: {
+        onRealtimeAlertsCallback?: (response: any) => void;
+    });
+    setProctoringId(proctoringId: string): void;
+    isPluggedIn(sendEvent?: boolean): Promise<boolean>;
+    isAlive(): Promise<boolean>;
+    connectAndScan(): Promise<any>;
+    devices({ deviceType, rssiThreshold, packageRateThreshold }: DevicesInterface): Promise<SpyCamDevice[]>;
+    startCheckSpyCam(spyScanInterval: number, { deviceType, rssiThreshold, packageRateThreshold }: DevicesInterface): Promise<void>;
+    stopCheckSpyCam(): void;
+}

package/new-flow/backend/BackendService.d.ts

@@ -20,11 +20,13 @@ export declare class BackendService {
     getParamsConfig(proctoringOptions: ProctoringContext): Promise<IParamsConfig>;
     getSignedUrlImage(token: string, body: any): Promise<string[]>;
     getSignedUrl(token: string, file: File, proctoringId?: string): Promise<string>;
-    saveScreenAlerts(proctoringOptions: ProctoringContext, proctoringSession: ProctoringSession): Promise<void>;
+    saveAlerts(proctoringOptions: ProctoringContext, proctoringSession: ProctoringSession): Promise<void>;
     finishAndSendUrls(proctoringOptions: ProctoringContext, proctoringSession: ProctoringSession): Promise<void>;
     log(eventName: string, properties?: {
         [key: string]: any;
     }): Promise<string>;
+    signTerm(): Promise<string>;
+    signTermUrl(): Promise<string>;
     getServerHour(token: string): Promise<string>;
     private makeRequest;
     makeRequestAxios<R>(data: {

package/new-flow/backend/SpyCamBackendService.d.ts

@@ -0,0 +1,27 @@
+import type { SpyCamDevice } from "../../modules/SpyCam";
+export declare enum DeviceTypeEnum {
+    UNKNOWN = 0,
+    ROUTER = 1,
+    CLIENT_DEVICE = 2,
+    POTENCIAL_CAMERA = 3
+}
+export interface DevicesInterface {
+    deviceType?: DeviceTypeEnum;
+    rssiThreshold?: number;
+    packageRateThreshold?: number;
+}
+export declare class SpyCamBackendService {
+    private readonly baseUrl;
+    token: string;
+    constructor();
+    isAlive(): Promise<boolean>;
+    isPluggedIn(): Promise<boolean>;
+    ConnectAndScan(): Promise<any>;
+    Devices({ deviceType, rssiThreshold, packageRateThreshold, }: DevicesInterface): Promise<SpyCamDevice[]>;
+    makeRequestAxios<R>(data: {
+        path: string;
+        method: "GET" | "POST" | "PUT";
+        body?: any;
+        jwt: string;
+    }): Promise<R>;
+}

package/new-flow/checkers/DeviceCheckerService.d.ts

@@ -9,6 +9,7 @@ export interface checkDevicesReturn {
     allowedAmbient?: boolean;
     allowedPositionFace?: boolean;
     allowedMicrophone?: boolean;
+    allowedSpyScan?: boolean | null;
     result: boolean;
     faceDetectionAlerts?: {
         status: string;
@@ -32,14 +33,17 @@ export declare class DeviceCheckerService {
     private allowedAmbient;
     private allowedPositionFace;
     private allowedMicrophone;
+    private allowedSpyScan;
     private readonly backend;
     private readonly context;
     private noiseLimit;
     private onUpdateCb;
+    private spycam;
+    private spydevices;
     constructor(context: ProctoringContext);
     runCheckDevicesFlow(options: ProctoringSessionOptions, _videoOptions: Partial<ProctoringVideoOptions>, onModalConfirm: (resolve: (cameraId: string, microphoneId: string) => void) => void, onModalCancel: (reject: (error: Error) => void) => void, onUpdate: (feedback: any) => void): Promise<any>;
     private onUpdateCallback;
-    checkDevices(options: ProctoringSessionOptions | undefined, _videoOptions: ProctoringVideoOptions): Promise<checkDevicesReturn>;
+    checkDevices(options?: ProctoringSessionOptions, _videoOptions?: ProctoringVideoOptions): Promise<checkDevicesReturn>;
     private isUnderResolution;
     private realtimeAlerts;
     private videoDeviceInterface;
@@ -51,4 +55,5 @@ export declare class DeviceCheckerService {
         cameraStream: MediaStream;
     }>;
     closeCheckDevices(): Promise<void>;
+    private checkSpyScan;
 }

package/new-flow/checkers/DeviceCheckerUI.d.ts

@@ -38,6 +38,8 @@ export declare class DeviceCheckerUI {
         description: string;
         type?: string;
     }): void;
+    waitingSpyDevices(waiting: boolean): void;
+    isSpyDevicesUI(allowedDevices: boolean): void;
     isUnderResolutionUI(allowedResolution: boolean): void;
     videoDeviceInterfaceUI(stream: MediaStream): void;
     audioDeviceInterfaceUIAllowedAmbient(allowedAmbient: boolean): void;

package/new-flow/proctoring/ProctoringSession.d.ts

@@ -15,13 +15,23 @@ export declare enum RecordingOrigin {
     Mic = "Mic",
     Camera = "Camera"
 }
+export declare enum AlertCategory {
+    LostFocus = 25,
+    PotentialCamera = 32,
+    SpyDeviceDisconnected = 33
+}
 export declare enum AlertType {
-    LostFocus = 25
+    Audio = 1,
+    Video = 2,
+    Screen = 3,
+    Image = 4,
+    Environment = 5
 }
 export interface Alert {
     begin: number;
     end: number;
-    alert: AlertType;
+    alert: AlertCategory;
+    type: AlertType;
 }
 export interface Recording {
     origin: RecordingOrigin;

package/new-flow/recorders/CameraRecorder.d.ts

@@ -23,6 +23,7 @@ export declare class CameraRecorder implements IRecorder {
     backend: BackendService | undefined;
     backendToken: string | undefined;
     proctoringId: string | undefined;
+    private recorderOptions;
     upload: UploadService | undefined;
     video: HTMLVideoElement;
     canvas: HTMLCanvasElement;
@@ -35,7 +36,7 @@ export declare class CameraRecorder implements IRecorder {
         cameraId?: string;
         microphoneId?: string;
         onBufferSizeError?: boolean;
-        onBufferSizeErrorCallback: () => void;
+        onBufferSizeErrorCallback: (cameraStream?: any) => void;
         proctoringType?: "VIDEO" | "IMAGE" | "REALTIME";
         onChangeDevicesCallback?: (devices: DevicesChanged) => void;
         onRealtimeAlertsCallback?: (response: any) => void;
@@ -45,10 +46,15 @@ export declare class CameraRecorder implements IRecorder {
     recordingStop: () => any;
     recordingPause: () => any;
     recordingResume: () => any;
+    getBufferSize: () => any;
     setProctoringId(proctoringId: string): void;
     initializeDetectors(): Promise<void>;
     configImageCapture(): void;
-    startRecording(): Promise<void>;
+    currentRetries: number;
+    bufferError(e: any): Promise<void>;
+    startRecording(options?: {
+        retry?: boolean;
+    }): Promise<void>;
     stopRecording(): Promise<void>;
     pauseRecording(): Promise<void>;
     resumeRecording(): Promise<void>;

package/new-flow/recorders/IRecorder.d.ts

@@ -2,7 +2,9 @@ import { ProctoringSession } from "../proctoring/ProctoringSession";
 export declare enum RecordingType {
 }
 export interface IRecorder {
-    startRecording(): Promise<void>;
+    startRecording(options?: {
+        retry?: boolean;
+    }): Promise<void>;
     pauseRecording(): Promise<void>;
     resumeRecording(): Promise<void>;
     stopRecording(): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "easyproctor",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Modulo web de gravação do EasyProctor",
   "main": "./index.js",
   "module": "./esm/index.js",
@@ -19,7 +19,7 @@
     "dev": "node scripts/serve.js -w",
     "publish": "npm publish ./dist"
   },
-  "author": "Igor Dantas",
+  "author": "IARIS",
   "license": "ISC",
   "devDependencies": {
     "@types/dom-mediacapture-record": "^1.0.11",

package/plugins/insights.d.ts

@@ -1,4 +1,3 @@
-import { DevicesChanged } from '../interfaces/Devices';
 import { ServiceType } from '../proctoring/proctoring';
 import { BackendService } from '../new-flow/backend/BackendService';
 declare const init: (backend: BackendService) => BackendService;
@@ -9,10 +8,12 @@ declare const trackers: {
     registerBrowserNotSupported: (proctoringId: string, description: string) => Promise<string>;
     registerUpload: (proctoringId: string, success: boolean, description: string, serviceType: ServiceType, uploadTime?: number) => Promise<string>;
     registerUploadFile: (proctoringId: string, description: string, fileType: string) => Promise<string>;
-    registerChangeDevice: (proctoringId: string, inOrOut: string, devicesChanged: DevicesChanged) => Promise<string>;
+    registerChangeDevice: (proctoringId: string, inOrOut: string, description: string) => Promise<string>;
     registerStopSharingScreen: (proctoringId: string, description: string) => Promise<string>;
     registerErrorRecorderRTC: (proctoringId: string, description: string) => Promise<string>;
+    registerDownloadFile: (proctoringId: string, description: string) => Promise<string>;
     registerOnBufferSizeError: (proctoringId: string, description: string) => Promise<string>;
     registerAnotherStream: (proctoringId: string, description: string) => Promise<string>;
+    registerSaveOnSession: (proctoringId: string, description: string) => Promise<string>;
 };
 export { trackers, init };

package/plugins/recorder.d.ts

@@ -1,6 +1,9 @@
-export default function recorder(stream: MediaStream, buffer: Blob[], proctoringId?: string, onBufferSizeError?: boolean, onBufferSizeErrorCallback?: () => void, audio?: boolean): {
+export declare function setRecorderProctoringId(id: string): void;
+export default function recorder(stream: MediaStream, buffer: Blob[], onBufferSizeError?: boolean, onBufferSizeErrorCallback?: (e?: any) => void, audio?: boolean): {
     startRecording: () => Promise<void>;
     stopRecording: () => Promise<void>;
     pauseRecording: () => Promise<void>;
     resumeRecording: () => Promise<void>;
+    recorderOptions: MediaRecorderOptions;
+    getBufferSize: () => number;
 };

package/proctoring/SignTerm.d.ts

@@ -0,0 +1,15 @@
+import { ProctoringContext } from "./proctoring";
+export interface SignTermInterface {
+    cameraId: string;
+    microphoneId: string;
+    result: boolean;
+}
+export declare class SignTerm {
+    private static isModalOpen;
+    private readonly backend;
+    constructor(context: ProctoringContext);
+    signInTerms(): Promise<any>;
+    private openModal;
+    closeModal(): Promise<void>;
+    applyStyles(element: any, styles: any): void;
+}

package/proctoring/options/ProctoringOptions.d.ts

@@ -9,5 +9,6 @@ export interface ProctoringSessionOptions {
     insights: string;
     onBufferSizeError?: boolean;
     useGeolocation?: boolean;
+    useSpyScan?: boolean;
 }
 export declare const getDefaultProctoringOptions: ProctoringSessionOptions;

package/proctoring/options/ProctoringVideoOptions.d.ts

@@ -5,3 +5,4 @@ export interface ProctoringVideoOptions {
     minHeight?: number;
 }
 export declare function validatePartialVideoOptions(options: Partial<ProctoringVideoOptions>): ProctoringVideoOptions;
+export declare const getDefaultProctoringVideoOptions: ProctoringVideoOptions;

package/proctoring/proctoring.d.ts

@@ -50,6 +50,7 @@ export declare class Proctoring {
     private serviceType;
     private recorder;
     private allRecorders;
+    private spyCam;
     private onStopSharingScreenCallback;
     setOnStopSharingScreenCallback(cb: () => void): void;
     private onLostFocusCallback;
@@ -61,7 +62,7 @@ export declare class Proctoring {
     private onRealtimeAlertsCallback;
     onRealtimeAlerts(options?: ProctoringRealtimeAlertsOptions): Promise<void>;
     private onBufferSizeErrorCallback;
-    setOnBufferSizeErrorCallback(cb: () => void): void;
+    setOnBufferSizeErrorCallback(cb: (cameraStream?: any) => void): void;
     constructor(context: ProctoringContext);
     private createRecorders;
     login(): Promise<void>;

package/proctoring/useProctoring.d.ts

@@ -8,9 +8,9 @@ export declare function useProctoring(proctoringOptions: ProctoringContext, envi
     onFocus: (cb: () => void) => void;
     onLostFocus: (cb: () => void) => void;
     onChangeDevices: (options?: import("./proctoring").ProctoringChangeDevicesOptions) => Promise<void>;
-    onBufferSizeError: (cb: () => void) => void;
+    onBufferSizeError: (cb: (cameraStream?: any) => void) => void;
     onRealtimeAlerts: (options?: import("./proctoring").ProctoringRealtimeAlertsOptions) => Promise<void>;
-    checkDevices: (options: import("./options/ProctoringOptions").ProctoringSessionOptions | undefined, _videoOptions: import("./options/ProctoringVideoOptions").ProctoringVideoOptions) => Promise<import("../new-flow/checkers/DeviceCheckerService").checkDevicesReturn>;
+    checkDevices: (options?: import("./options/ProctoringOptions").ProctoringSessionOptions, _videoOptions?: import("./options/ProctoringVideoOptions").ProctoringVideoOptions) => Promise<import("../new-flow/checkers/DeviceCheckerService").checkDevicesReturn>;
     runCheckDevicesFlow: (options: import("./options/ProctoringOptions").ProctoringSessionOptions, _videoOptions: Partial<import("./options/ProctoringVideoOptions").ProctoringVideoOptions>, onModalConfirm: (resolve: (cameraId: string, microphoneId: string) => void) => void, onModalCancel: (reject: (error: Error) => void) => void, onUpdate: (feedback: any) => void) => Promise<any>;
     changeSelectedDevice: ({ cameraId, microphoneId }: any) => Promise<{
         cameraStream: MediaStream;
@@ -20,4 +20,5 @@ export declare function useProctoring(proctoringOptions: ProctoringContext, envi
     checkPermissions: typeof checkPermissions;
     checkIfhasMultipleMonitors: typeof checkIfhasMultipleMonitors;
     onStopSharingScreen: (cb: () => void) => void;
+    signInTerms: () => Promise<any>;
 };