@libretexts/cxone-expert-node 1.0.0 → 1.1.1

package/src/modules/archive.ts

@@ -0,0 +1,186 @@
+import {
+    BaseArgs,
+    ExpertGlobalOptions,
+    GetArchiveParams,
+    GetArchiveResponse,
+    GetArchiveFilesParams,
+    GetArchiveFilesResponse,
+    GetArchiveFileParams,
+    GetArchiveFileInfoResponse,
+    GetArchivePagesParams,
+    GetArchivePagesResponse,
+    GetArchivePageParams,
+    GetArchivePageResponse,
+    GetArchivePageContentsResponse,
+    GetArchivePageInfoResponse,
+    GetArchivePageSubPagesResponse
+} from "../types";
+import { getTld } from "../utils";
+import Auth from "./auth";
+import Requests from "./requests";
+
+export default class Archive {
+    private globals: ExpertGlobalOptions;
+    private _auth?: Auth;
+
+    constructor(args: ExpertGlobalOptions, auth?: Auth) {
+        this.globals = args;
+        this._auth = auth;
+    }
+
+    private parseFileName(name: string) {
+        return `=${encodeURIComponent(encodeURIComponent(name))}`;
+    }
+
+    public async getArchive(
+        funcArgs: BaseArgs,
+        reqArgs?: GetArchiveParams
+    ) {
+        const tld = getTld(this.globals, funcArgs.tld);
+        const requests = new Requests(tld, funcArgs.auth);
+        const res = await requests.get<GetArchiveResponse>(`/archive`, {
+          params: {
+              ...reqArgs,
+          },
+        });
+        return res.data;
+    }
+
+    public async getArchiveFiles(
+        funcArgs: BaseArgs,
+        reqArgs?: GetArchiveFilesParams
+    ) {
+        const tld = getTld(this.globals, funcArgs.tld);
+        const requests = new Requests(tld, funcArgs.auth);
+        const res = await requests.get<GetArchiveFilesResponse>(`/archive/files`, {
+          params: {
+              ...reqArgs,
+          },
+        });
+        return res.data;
+    }
+
+    public async getArchiveFile(
+        fileId: number,
+        funcArgs: BaseArgs,
+        reqArgs?: GetArchiveFileParams
+    ) {
+        const tld = getTld(this.globals, funcArgs.tld);
+        const requests = new Requests(tld, funcArgs.auth);
+        const res = await requests.get(`/archive/files/${fileId}`, {
+          params: {
+              ...reqArgs,
+          },
+          responseType: "stream"
+        });
+        return res.data;
+    }
+
+    public async getArchiveFileByName(
+        fileId: number,
+        fileName: string,
+        funcArgs: BaseArgs,
+        reqArgs?: GetArchiveFileParams
+    ) {
+        const tld = getTld(this.globals, funcArgs.tld);
+        const parseFileName = this.parseFileName(fileName);
+        const requests = new Requests(tld, funcArgs.auth);
+        const res = await requests.get(`/archive/files/${fileId}/${parseFileName}`, {
+          params: {
+              ...reqArgs,
+          },
+          responseType: "stream"
+        });
+        return res.data;
+    }
+
+    public async getArchiveFileInfo(
+        fileId: number,
+        funcArgs: BaseArgs,
+        reqArgs?: GetArchiveFileParams
+    ) {
+        const tld = getTld(this.globals, funcArgs.tld);
+        const requests = new Requests(tld, funcArgs.auth);
+        const res = await requests.get<GetArchiveFileInfoResponse>(`/archive/files/${fileId}/info`, {
+          params: {
+              ...reqArgs,
+          },
+        });
+        return res.data;
+    }
+
+    public async getArchivePages(
+        funcArgs: BaseArgs,
+        reqArgs?: GetArchivePagesParams
+    ) {
+        const tld = getTld(this.globals, funcArgs.tld);
+        const requests = new Requests(tld, funcArgs.auth);
+        const res = await requests.get<GetArchivePagesResponse>(`/archive/pages`, {
+          params: {
+              ...reqArgs,
+          },
+        });
+        return res.data;
+    }
+
+    public async getArchivePage(
+        pageId: number,
+        funcArgs: BaseArgs,
+        reqArgs?: GetArchivePageParams
+    ) {
+        const tld = getTld(this.globals, funcArgs.tld);
+        const requests = new Requests(tld, funcArgs.auth);
+        const res = await requests.get<GetArchivePageResponse>(`/archive/page/${pageId}`, {
+          params: {
+              ...reqArgs,
+          },
+        });
+        return res.data;
+    }
+
+    public async getArchivePageContents(
+        pageId: number,
+        funcArgs: BaseArgs,
+        reqArgs?: GetArchivePageParams
+    ) {
+        const tld = getTld(this.globals, funcArgs.tld);
+        const requests = new Requests(tld, funcArgs.auth);
+        const res = await requests.get<GetArchivePageContentsResponse>(`/archive/page/${pageId}/contents`, {
+          params: {
+              ...reqArgs,
+          },
+        });
+        return res.data;
+    }
+
+    public async getArchivePageInfo(
+        pageId: number,
+        funcArgs: BaseArgs,
+        reqArgs?: GetArchivePageParams
+    ) {
+        const tld = getTld(this.globals, funcArgs.tld);
+        const requests = new Requests(tld, funcArgs.auth);
+        const res = await requests.get<GetArchivePageInfoResponse>(`/archive/page/${pageId}/info`, {
+          params: {
+              ...reqArgs,
+          },
+        });
+        return res.data;
+    }
+
+    public async getArchivePageSubPages(
+        pageId: number,
+        funcArgs: BaseArgs,
+        reqArgs?: GetArchivePageParams
+    ) {
+        const tld = getTld(this.globals, funcArgs.tld);
+        const requests = new Requests(tld, funcArgs.auth);
+        const res = await requests.get<GetArchivePageSubPagesResponse>(`/archive/page/${pageId}/subpages`, {
+          params: {
+              ...reqArgs,
+          },
+        });
+        return res.data;
+    }
+
+}

package/src/modules/auth.ts

@@ -1,31 +1,35 @@
-import { AuthObject, BrowserTokenParams, ServerTokenParams } from "../types";
-import { createHmac } from 'crypto';
-
-export default class Auth {
-    private token: string | null = null;
-
-    public BrowserToken({ key }: BrowserTokenParams) {
-        this.token = key;
-        return this;
-    }
-
-    public ServerToken({ key, secret, user }: ServerTokenParams) {
-        const hmac = createHmac('sha256', secret);
-        const epoch = Math.floor(Date.now() / 1000);
-        hmac.update(`${key}_${epoch}_${user}`);
-        const hash = hmac.digest('hex');
-        this.token = `tkn_${key}_${epoch}_${user}_${hash}`;
-        return this;
-    }
-
-    public getToken() {
-        return this.token;
-    }
-
-    public getHeader(): AuthObject {
-        return {
-            'X-Deki-Token': this.token
-        }
-    }
-}
-
+import { AuthObject, BrowserTokenParams, ServerTokenParams } from "../types";
+import { createHmac } from 'crypto';
+
+export default class Auth {
+    private token: string | null = null;
+
+    public BrowserToken({ key }: BrowserTokenParams) {
+        this.token = key;
+        return this;
+    }
+
+    public ServerToken({ key, secret, user }: ServerTokenParams) {
+        if(!key || !secret || !user) {
+            throw new Error("Missing required parameters: key, secret, user");
+        }
+        
+        const epoch = Math.floor(Date.now() / 1000);
+        const hmac = createHmac('sha256', secret);
+        hmac.update(`${key}${epoch}=${user}`);
+        const hash = hmac.digest('hex');
+        this.token = `${key}_${epoch}_=${user}_${hash}`;
+        return this;
+    }
+
+    public getToken() {
+        return this.token;
+    }
+
+    public getHeader(): AuthObject {
+        return {
+            'X-Deki-Token': this.token
+        }
+    }
+}
+

package/src/modules/contextMaps.ts

@@ -0,0 +1,56 @@
+import {
+    BaseArgs,
+    ExpertGlobalOptions,
+    GetContextMapParams,
+    GetContextMapResponse,
+    GetContextMapByIdParams,
+    GetContextMapByIdResponse
+} from "../types";
+import { getTld } from "../utils";
+import Auth from "./auth";
+import Requests from "./requests";
+
+export default class contextMaps {
+    private globals: ExpertGlobalOptions;
+    private _auth?: Auth;
+
+    constructor(args: ExpertGlobalOptions, auth?: Auth) {
+        this.globals = args;
+        this._auth = auth;
+    }
+
+    private parseFileName(name: string) {
+        return `=${encodeURIComponent(encodeURIComponent(name))}`;
+    }
+
+    public async getContextMaps(
+        funcArgs: BaseArgs,
+        reqArgs?: GetContextMapParams
+    ) {
+        const tld = getTld(this.globals, funcArgs.tld);
+        const requests = new Requests(tld, funcArgs.auth);
+        const res = await requests.get<GetContextMapResponse>(`/contextmaps`, {
+          params: {
+              ...reqArgs,
+          },
+        });
+        return res.data;
+    }
+
+    public async getContextMapsById(
+        language: string,
+        id: string | number,
+        funcArgs: BaseArgs,
+        reqArgs?: GetContextMapByIdParams 
+    ) {
+        const tld = getTld(this.globals, funcArgs.tld);
+        const requests = new Requests(tld, funcArgs.auth);
+        const res = await requests.get<GetContextMapByIdResponse>(`/contextmaps/${language}/${id}`, {
+          params: {
+              ...reqArgs,
+          },
+        });
+        return res.data;
+    }
+
+}

package/src/modules/events.ts

@@ -0,0 +1,140 @@
+import {
+    BaseArgs,
+    ExpertGlobalOptions,
+    GetPageHierarchyByIdParams,
+    GetPageHierarchyByIdResponse,
+    GetPageHierarchyDetailByIdParams,
+    GetPageHierarchyDetailByIdResponse,
+    GetEventPageParams,
+    GetEventPageResponse,
+    GetEventPageDetailParams,
+    GetEventPageDetailResponse,
+    GetEventUserPageParams,
+    GetEventUserPageResponse,
+    GetEventUserPageDetailParams,
+    GetEventUserPageDetailResponse
+} from "../types";
+import { getTld } from "../utils";
+import Auth from "./auth";
+import Requests from "./requests";
+
+export default class Events {
+    private globals: ExpertGlobalOptions;
+    private _auth?: Auth;
+
+    constructor(args: ExpertGlobalOptions, auth?: Auth) {
+        this.globals = args;
+        this._auth = auth;
+    }
+
+    private parsePageId(id: string | number) {
+        if (typeof id === "number") {
+          return id.toString();
+        }
+        return `=${encodeURIComponent(encodeURIComponent(id))}`;
+    }
+
+    private parseUserId(id: string | number) {
+        if (typeof id === "number") {
+          return id.toString();
+        }
+        return `=${encodeURIComponent(encodeURIComponent(id))}`;
+      }
+
+    public async getPageHierarchyById(
+        id: string | number,
+        funcArgs: BaseArgs,
+        reqArgs?: GetPageHierarchyByIdParams
+    ){
+        const pageId = this.parsePageId(id);
+        const tld = getTld(this.globals, funcArgs.tld);
+        const requests = new Requests(tld, funcArgs.auth);
+        const res = await requests.get<GetPageHierarchyByIdResponse>(`events/page-hierarchy/${pageId}`, {
+            params: {
+                ...reqArgs,
+            },
+        });
+        return res.data;
+    }
+    
+    public async getPageHierarchyDetailById(
+        id: string | number,
+        detailId: string,
+        funcArgs: BaseArgs,
+        reqArgs?: GetPageHierarchyDetailByIdParams
+    ){
+        const pageId = this.parsePageId(id);
+        const tld = getTld(this.globals, funcArgs.tld);
+        const requests = new Requests(tld, funcArgs.auth);
+        const res = await requests.get<GetPageHierarchyDetailByIdResponse>(`events/page-hierarchy/${pageId}/${detailId}`, {
+            params: {
+                ...reqArgs,
+            },
+        });
+        return res.data;
+    }
+
+    public async getEventPage(
+        id: string | number,
+        funcArgs: BaseArgs,
+        reqArgs?: GetEventPageParams
+    ){
+        const pageId = this.parsePageId(id);
+        const tld = getTld(this.globals, funcArgs.tld);
+        const requests = new Requests(tld, funcArgs.auth);
+        const res = await requests.get<GetEventPageResponse>(`events/page/${pageId}`, {
+            params: {
+                ...reqArgs,
+            },
+        });
+        return res.data;
+    }
+
+    public async getEventPageDetail(
+        id: string | number,
+        detailId: string,
+        funcArgs: BaseArgs,
+        reqArgs?: GetEventPageDetailParams
+    ){
+        const pageId = this.parsePageId(id);
+        const tld = getTld(this.globals, funcArgs.tld);
+        const requests = new Requests(tld, funcArgs.auth);
+        const res = await requests.get<GetEventPageDetailResponse>(`/events/page/${pageId}/${detailId}`, {
+            params: {
+                ...reqArgs,
+            },
+        });
+        return res.data;
+    }
+
+    public async getEventUserPage(
+        userId: string | number,
+        funcArgs: BaseArgs,
+        reqArgs?: GetEventUserPageParams 
+    ){
+        const tld = getTld(this.globals, funcArgs.tld);
+        const requests = new Requests(tld, funcArgs.auth);
+        const res = await requests.get<GetEventUserPageResponse>(`/events/user-page/${this.parseUserId(userId)}`, {
+            params: {
+                ...reqArgs,
+            },
+        });
+        return res.data;
+    }
+
+    public async getEventUserDetailPage(
+        userId: string | number,
+        detailId: string,
+        funcArgs: BaseArgs,
+        reqArgs?: GetEventUserPageDetailParams
+    ){
+        const tld = getTld(this.globals, funcArgs.tld);
+        const requests = new Requests(tld, funcArgs.auth);
+        const res = await requests.get<GetEventUserPageDetailResponse>(`/events/user-page/${this.parseUserId(userId)}/${detailId}`, {
+            params: {
+                ...reqArgs,
+            },
+        });
+        return res.data;
+    }
+};