easyproctor 0.0.9 → 0.0.13

package/index.js

@@ -1,56 +1,335 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
 var __export = (target, all) => {
+  __markAsModule(target);
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __reExport = (target, module2, copyDefault, desc) => {
+var __reExport = (target, module2, desc) => {
   if (module2 && typeof module2 === "object" || typeof module2 === "function") {
     for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
         __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
   }
   return target;
 };
-var __toCommonJS = /* @__PURE__ */ ((cache) => {
-  return (module2, temp) => {
-    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
-  };
-})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+__export(exports, {
   useProctoring: () => useProctoring
 });
-function useProctoring(key) {
-  const start = () => {
-    return new Promise((resolve, reject) => resolve());
+
+// src/modules/database.ts
+var databaseName = "EasyProctorPlugin";
+var databaseVersion = 1;
+function initializeDatabase(table) {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(databaseName, databaseVersion);
+    request.onupgradeneeded = () => {
+      request.result.createObjectStore("cameraBuffers", { keyPath: "id", autoIncrement: true });
+      request.result.createObjectStore("screenBuffers", { keyPath: "id", autoIncrement: true });
+    };
+    request.onerror = (e) => {
+      console.log(e);
+      reject("N\xE3o foi poss\xEDvel inicializar a biblioteca, por favor, entre em contato com o suporte e informe o erro acima");
+    };
+    request.onsuccess = () => {
+      const db = request.result;
+      const tableRef = db.transaction(table, "readwrite");
+      const store = tableRef.objectStore(table);
+      resolve(store);
+    };
+  });
+}
+async function getBuffers(table) {
+  const store = await initializeDatabase(table);
+  return new Promise((resolve, reject) => {
+    const request = store.getAll();
+    request.onsuccess = () => {
+      const data = request.result;
+      const blobs = data.reduce((acc, el) => [...acc, ...el.data], []);
+      resolve(blobs);
+    };
+    request.onerror = (e) => reject(e);
+  });
+}
+async function clearBuffers(table) {
+  const store = await initializeDatabase(table);
+  return new Promise((resolve, reject) => {
+    const request = store.clear();
+    request.onsuccess = () => resolve();
+    request.onerror = (e) => reject(e);
+  });
+}
+
+// src/modules/recorder.ts
+function recorder(stream, buffer) {
+  let resolvePromise;
+  const options = {
+    mimeType: "video/webm; codecs=vp9",
+    videoBitsPerSecond: 128e3,
+    audioBitsPerSecond: 64 * 1e3
+  };
+  const mediaRecorder = new MediaRecorder(stream, options);
+  mediaRecorder.ondataavailable = (e) => {
+    if (e.data.size > 0) {
+      buffer.push(e.data);
+    }
+    resolvePromise && resolvePromise();
   };
-  const finish = () => {
+  mediaRecorder.start();
+  function stopRecording() {
     return new Promise((resolve) => {
-      const cameraFile = new File([], `${Date.now()}.webm`, { type: "video/webm" });
-      const screenFile = new File([], `${Date.now()}.webm`, { type: "video/webm" });
-      resolve([cameraFile, screenFile]);
+      resolvePromise = resolve;
+      mediaRecorder.stop();
+      stream.getTracks().forEach((el) => {
+        el.stop();
+      });
     });
+  }
+  return stopRecording;
+}
+
+// src/modules/startCameraCapture.ts
+async function startCameraCapture(buffer) {
+  const constraints = {
+    audio: true,
+    video: {
+      width: { max: 1280, ideal: 640 },
+      height: { max: 720, ideal: 480 },
+      frameRate: 15
+    }
   };
-  const pause = () => {
-    return new Promise((resolve) => resolve());
+  const stream = await navigator.mediaDevices.getUserMedia(constraints);
+  const stopRecording = recorder(stream, buffer);
+  return stopRecording;
+}
+
+// src/modules/startScreenCapture.ts
+async function startScreenCapture(buffer) {
+  const displayMediaStreamConstraints = {
+    video: {
+      cursor: "always"
+    },
+    audio: false
   };
-  const resume = () => {
-    return new Promise((resolve) => resolve());
+  const stream = await navigator.mediaDevices.getDisplayMedia(displayMediaStreamConstraints);
+  const stopRecording = recorder(stream, buffer);
+  return stopRecording;
+}
+
+// src/modules/upload.ts
+var import_storage_blob = __toModule(require("@azure/storage-blob"));
+var account = "iarisprod";
+var containerName = "iaris";
+var sas = "?sv=2020-08-04&ss=bfqt&srt=sco&sp=rwdlacupitfx&se=2025-12-28T06:34:02Z&st=2021-12-27T22:34:02Z&spr=https&sig=1rsgx389pHZCnJYd44peuWSfeCUdN8bQ9EfcLoMOdDc%3D";
+var blobServiceClient = new import_storage_blob.BlobServiceClient(`https://${account}.blob.core.windows.net${sas}`);
+async function upload(data) {
+  const { file, onProgress } = data;
+  const containerClient = blobServiceClient.getContainerClient(containerName);
+  const blockBlobClient = containerClient.getBlockBlobClient(file.name);
+  const progressCallback = (e) => {
+    const progress = e.loadedBytes / file.size * 100;
+    onProgress && onProgress(Math.round(progress));
   };
+  await blockBlobClient.upload(file, file.size, { onProgress: progressCallback });
+}
+var upload_default = upload;
+
+// src/modules/http.ts
+var baseUrl = "https://iaris.easyproctor.tech/api";
+async function makeRequest(data) {
+  var _a;
+  const { url, method, body, jwt } = data;
+  const resp = await fetch(baseUrl + url, {
+    method,
+    body: body != null ? JSON.stringify(body) : void 0,
+    headers: {
+      "Authorization": `Bearer ${jwt}`,
+      "Content-Type": "application/json"
+    }
+  });
+  if (resp.status >= 400) {
+    throw "N\xE3o foi poss\xEDvel realizar a requisi\xE7\xE3o, tente novamente mais tarde";
+  }
+  const isJson = (_a = resp.headers.get("content-type")) == null ? void 0 : _a.includes("application/json");
+  const responseData = isJson ? await resp.json() : null;
+  return responseData;
+}
+
+// src/index.ts
+var azureBlobUrl = "https://iarisprod.azureedge.net/iaris";
+function useProctoring(proctoringOptions) {
+  ["examId", "clientId", "token"].forEach((el) => {
+    const key = el;
+    if (!proctoringOptions[key]) {
+      throw `O campo ${key} \xE9 obrigat\xF3rio`;
+    }
+  });
+  let focusCallback;
+  let lostFocusCallback;
+  if (!navigator.mediaDevices.getDisplayMedia) {
+    throw "Voc\xEA est\xE1 utilizando uma vers\xE3o muito antiga do navegador, por favor, atualize a vers\xE3o";
+  }
+  if (!window.indexedDB) {
+    throw "Voc\xEA est\xE1 usando uma vers\xE3o muito antiga do navegador, n\xE3o \xE9 poss\xEDvel relizar a requisi\xE7\xE3o";
+  }
+  function download(file) {
+    const url = URL.createObjectURL(file);
+    const a = document.createElement("a");
+    document.body.appendChild(a);
+    a.style.display = "none";
+    a.href = url;
+    a.download = file.name;
+    a.click();
+    window.URL.revokeObjectURL(url);
+  }
+  let cameraBuffer = [];
+  let screenBuffer = [];
+  let proctoringId = "";
+  let cancelCallback = null;
+  async function _startCapture() {
+    if (!document.body) {
+      throw "A execu\xE7\xE3o do script deve ser feita por algum elemento dentro do <body> da p\xE1gina html";
+    }
+    if (cancelCallback != null) {
+      throw "Uma grava\xE7\xE3o ja est\xE1 em andamento";
+    }
+    let cancelCameraCapture = null;
+    let cancelScreenCapture = null;
+    try {
+      if (focusCallback)
+        window.removeEventListener("focus", focusCallback);
+      if (lostFocusCallback)
+        window.removeEventListener("blur", lostFocusCallback);
+      cancelScreenCapture = await startScreenCapture(screenBuffer);
+      if (focusCallback)
+        window.addEventListener("focus", () => window.addEventListener("focus", focusCallback), { once: true });
+      if (lostFocusCallback)
+        window.addEventListener("blur", lostFocusCallback);
+      cancelCameraCapture = await startCameraCapture(cameraBuffer);
+      cancelCallback = async function() {
+        await Promise.all([cancelCameraCapture(), cancelScreenCapture()]);
+      };
+    } catch (error) {
+      cancelCallback = null;
+      cancelScreenCapture && await cancelScreenCapture();
+      cancelCameraCapture && await cancelCameraCapture();
+      cameraBuffer = [];
+      screenBuffer = [];
+      throw "N\xE3o foi poss\xEDvel iniciar a captura, por favor, verifique as permiss\xF5es de camera e microfone";
+    }
+  }
+  async function start(options = { override: false }) {
+    const { override } = options;
+    if (override) {
+      await Promise.all([clearBuffers("cameraBuffers"), clearBuffers("screenBuffers")]);
+    } else {
+      const [storedCameraBuffers, storedScreenBuffers] = await Promise.all([getBuffers("cameraBuffers"), getBuffers("screenBuffers")]);
+      if (storedCameraBuffers.length > 0 || storedScreenBuffers.length > 0) {
+        throw "Existe uma grava\xE7\xE3o iniciada, por favor, execute o m\xE9todo resume() para retomar, ou utilize o parametro start({ override: true }) para limpar os dados";
+      }
+    }
+    await _startCapture();
+    try {
+      const resp = await makeRequest({
+        url: `/proctoring/start/${proctoringOptions.examId}`,
+        method: "POST",
+        body: { clientId: proctoringOptions.clientId },
+        jwt: proctoringOptions.token
+      });
+      proctoringId = resp.id;
+      return resp;
+    } catch (error) {
+      cancelCallback && cancelCallback();
+      throw error;
+    }
+  }
+  async function pause() {
+    throw "Ainda n\xE3o implementado";
+  }
+  async function resume() {
+    throw "Ainda n\xE3o implementado";
+  }
+  async function finish(options = {}) {
+    const { onProgress } = options;
+    if (cancelCallback) {
+      await cancelCallback();
+    }
+    const time = new Date().toISOString();
+    const finalCameraBuffer = cameraBuffer;
+    const finalScreenBuffer = screenBuffer;
+    if (finalCameraBuffer.length == 0 || finalScreenBuffer.length == 0) {
+      throw "N\xE3o existe nenhuma grava\xE7\xE3o iniciada";
+    }
+    const cameraFileName = `EP_${proctoringOptions.examId}_${time}_camera_0.webm`;
+    const screenFIleName = `EP_${proctoringOptions.examId}_${time}_screen_0.webm`;
+    const cameraFile = new File(finalCameraBuffer, cameraFileName, { type: "video/webm" });
+    const screenFile = new File(finalScreenBuffer, screenFIleName, { type: "video/webm" });
+    let cameraProgress = 0;
+    const screenProgress = 0;
+    const handleOnProgress = () => {
+      onProgress && onProgress((cameraProgress + screenProgress) / 2);
+    };
+    await Promise.all([
+      upload_default({ file: cameraFile, onProgress: (progress) => {
+        cameraProgress = progress;
+        handleOnProgress();
+      } }),
+      upload_default({ file: screenFile, onProgress: (progress) => {
+        cameraProgress = progress;
+        handleOnProgress();
+      } })
+    ]);
+    await makeRequest({
+      url: "/proctoring/save-screen",
+      method: "POST",
+      jwt: proctoringOptions.token,
+      body: {
+        proctoringId,
+        alerts: []
+      }
+    });
+    await makeRequest({
+      url: `/proctoring/finish/${proctoringOptions.examId}`,
+      method: "POST",
+      body: {
+        endDate: time,
+        videoCameraUrl: `${azureBlobUrl}/${cameraFileName}`,
+        videoScreenUrl: `${azureBlobUrl}/${screenFIleName}`
+      },
+      jwt: proctoringOptions.token
+    });
+    await Promise.all([clearBuffers("cameraBuffers"), clearBuffers("screenBuffers")]);
+    cameraBuffer = [];
+    screenBuffer = [];
+    cancelCallback = null;
+  }
   const onLostFocus = (cb) => {
+    lostFocusCallback = cb;
+    window.addEventListener("blur", lostFocusCallback);
+    const dispose = () => window.removeEventListener("blur", lostFocusCallback);
+    return dispose;
+  };
+  const onReturnFocus = (cb) => {
+    focusCallback = cb;
+    window.addEventListener("focus", focusCallback);
+    const dispose = () => window.removeEventListener("focus", focusCallback);
+    return dispose;
   };
-  return { start, finish, pause, resume, onLostFocus };
+  return { start, finish, pause, resume, onLostFocus, download, onReturnFocus };
 }
 if (typeof window !== "undefined") {
   window.useProctoring = useProctoring;
 }
-module.exports = __toCommonJS(src_exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   useProctoring

package/modules/database.d.ts

@@ -0,0 +1,6 @@
+declare type Tables = "cameraBuffers" | "screenBuffers";
+export declare function initializeDatabase(table: string): Promise<IDBObjectStore>;
+export declare function insertBuffer(table: Tables, buffer: Blob[]): Promise<void>;
+export declare function getBuffers(table: Tables): Promise<Blob[]>;
+export declare function clearBuffers(table: Tables): Promise<void>;
+export {};

package/modules/http.d.ts

@@ -0,0 +1,6 @@
+export declare function makeRequest<R>(data: {
+    url: string;
+    method: "GET" | "POST";
+    body?: any;
+    jwt: string;
+}): Promise<R>;

package/modules/recorder.d.ts

@@ -0,0 +1 @@
+export default function recorder(stream: MediaStream, buffer: Blob[]): () => Promise<void>;

package/modules/startCameraCapture.d.ts

@@ -1 +1 @@
-export default function startCameraCapture(): void;
+export default function startCameraCapture(buffer: Blob[]): Promise<() => Promise<void>>;

package/modules/startScreenCapture.d.ts

@@ -1 +1 @@
-export default function startScreenCapture(): Promise<void>;
+export default function startScreenCapture(buffer: Blob[]): Promise<() => Promise<void>>;

package/modules/upload.d.ts

@@ -0,0 +1,6 @@
+declare type UploadData = {
+    file: File;
+    onProgress?: (progress: number) => void;
+};
+declare function upload(data: UploadData): Promise<void>;
+export default upload;

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "easyproctor",
-  "version": "0.0.9",
+  "version": "0.0.13",
   "description": "Modulo web de gravação do EasyProctor",
   "main": "./index.js",
   "module": "./esm/index.js",
   "unpkg": "./unpkg/easyproctor.min.js",
   "types": "./index.d.ts",
-  "keywords": ["proctoring"],
-  "homepage": "https://github.com/Igor4505/render-function#readme",
+  "keywords": [
+    "proctoring"
+  ],
+  "homepage": "https://vsoft1.visualstudio.com/DefaultCollection/Iaris/_git/easyproctor-proctoring-componentJs",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Igor4505/render-function.git"
+    "url": "https://vsoft1.visualstudio.com/DefaultCollection/Iaris/_git/easyproctor-proctoring-componentJs"
   },
   "scripts": {
     "build": "node scripts/build.js && tsc",
@@ -19,10 +21,15 @@
   "author": "Igor Dantas",
   "license": "ISC",
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^5.3.1",
-    "@typescript-eslint/parser": "^5.3.1",
+    "@types/dom-mediacapture-record": "^1.0.11",
+    "@typescript-eslint/eslint-plugin": "^5.8.0",
+    "@typescript-eslint/parser": "^5.8.0",
     "esbuild": "^0.13.13",
+    "esbuild-serve": "^1.0.1",
     "eslint": "^8.2.0",
-    "typescript": "^3.9.7"
+    "typescript": "^4.5.4"
+  },
+  "dependencies": {
+    "@azure/storage-blob": "^12.8.0"
   }
 }