@nomad-media/public 1.1.4

package/dist/nomad-media-sdk-debug.js

@@ -0,0 +1,1702 @@
+// account
+
+
+
+
+
+
+// admin
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// common
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// portal
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// helpers
+
+
+
+
+import { promises as fs } from 'fs';
+import path from 'path';
+
+/**
+ * @class NomadSDK
+ * @classdesc This class is used to interact with the Nomad API.
+ */
+
+class NomadMediaSDK {
+    constructor(config = {}) {
+        if (NomadMediaSDK.instance) 
+        {
+            return NomadMediaSDK.instance;
+        }
+
+        this.config = config;
+        this.token = null;
+        this.refreshTokenVal = null;
+        this.expirationSeconds = null;
+        this.userSessionId = null;
+        this.id = null
+        this.debugMode = config.debugMode || false;
+
+        NomadMediaSDK.instance = this;
+        
+        return this;
+    } 
+
+    /**
+     * @function init
+     * @async
+     * @private
+     * @description Initializes the SDK. Logs in using the username and password from the config. 
+     * Then schedules a token refresh for the duration set by the value returned in the login.
+     * @returns {Promise<void>} - A promise that resolves when the SDK is initialized.
+     * @throws {Error} - An error is thrown if the SDK fails to initialize.
+     */
+    async _init() 
+    {
+        await this.login();
+
+        // Schedule token refresh
+        this.__scheduleTokenRefresh();
+    }
+    
+    // account functions
+    /**
+     * @function login
+     * @async
+     * @description Logs in using the username and password from the config.
+     * @returns {Promise<void>} - A promise that resolves when the login is successful.
+     * Updates the token, refresh token, expiration seconds, and user session ID class varibles. 
+     * @throws {Error} - An error is thrown if the login fails.
+     */ 
+    async login()
+    {
+
+        _printDatetime(`Logging in as ${this.config.username}`);
+
+        try
+        {
+            const LOGIN_INFO = await _login(this.config.username, this.config.password, 
+                                            this.config.serviceApiUrl, this.debugMode);
+            this.token = LOGIN_INFO["token"];
+            this.refreshTokenVal = LOGIN_INFO["refreshToken"];
+            this.expirationSeconds = Date.now() + LOGIN_INFO["expirationSeconds"] * 1000;
+            this.userSessionId = LOGIN_INFO["userSessionId"];
+            this.id = LOGIN_INFO["id"];
+            _printDatetime(`Login successful`);
+        }
+        catch (error) 
+        {
+            _printDatetime(`Login failed`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function logout
+     * @async
+     * @description Logs out the current user.
+     * @returns {Promise<null>} - A promise that resolves when the logout is successful.
+     * @throws {Error} - An error is thrown if the logout fails.
+     */
+    async logout()
+    {
+        if (this.token === null)
+        {
+            await this._init();
+        }
+
+        _printDatetime(`Logging out`);
+
+        try
+        {
+            await _logout(this.token, this.config.serviceApiUrl, this.debugMode);
+            this.token = null;
+            this.refreshTokenVal = null;
+            this.expirationSeconds = null;
+            this.userSessionId = null;
+            this.id = null;
+            
+            _printDatetime(`Logout successful`);
+        }
+        catch (error)
+        {
+            _printDatetime("Loggout failed");
+            throw error;
+        }
+    }
+
+    /**
+     * @function refreshToken
+     * @async
+     * @description Refreshes the current token.
+     * @returns {Promise<void>} - A promise that resolves when the token is refreshed.
+     * Updates the token class variable.
+     * @throws {Error} - An error is thrown if the token refresh fails.
+     */ 
+    async refreshToken()
+    {
+        _printDatetime(`Refreshing token`);
+
+        try
+        {
+            const TOKEN_INFO = await _refreshToken(this.token, this.config.serviceApiUrl, 
+                this.refreshTokenVal, this.debugMode);
+            this.token = TOKEN_INFO["token"];
+            _printDatetime(`Token refresh successful`);
+        }
+        catch (error)
+        {
+            _printDatetime(`Token refresh failed`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function scheduleTokenRefresh
+     * @private
+     * @description Schedules a token refresh for the duration set by the value returned in the login.
+     * @returns {Promise<void>} - A promise that resolves when the token is refreshed.
+     * Updates the token class variable.
+     * @throws {Error} - An error is thrown if the token refresh fails.
+     */ 
+    __scheduleTokenRefresh() {
+        if (this.token && this.expirationSeconds) {
+            const remainingTime = this.expirationSeconds - Date.now();
+            if (remainingTime > 0) {
+                // Clear existing timer (if any)
+                if (this.refreshTimer) {
+                    clearTimeout(this.refreshTimer);
+                }
+                // Schedule a refresh slightly before token expiration
+                this.refreshTimer = setTimeout(async () => {
+                    await this.refreshToken();
+                    this.__scheduleTokenRefresh();
+                }, remainingTime - 5000); // Refresh 5 seconds before expiration
+            }
+        }
+    }
+
+    /**
+     * @function forgotPassword
+     * @async
+     * @description Sends a code to the email to the user to be used 
+     * be used to reset the password.
+     * @returns {Promise<void>}
+     * Sends email with code to reset password.
+     * @throws {Error} - An error is thrown if the code fails to send.
+     */  
+    async forgotPassword()
+    {
+        const USERNAME = this.config.username;
+
+         _printDatetime(`Sending code to ${USERNAME}`);
+
+        try
+        {
+            await _forgotPassword(this.config.serviceApiUrl, USERNAME, this.debugMode);
+            _printDatetime(`Code sent to ${USERNAME}`);
+        }
+        catch (error)
+        {
+            _printDatetime(`Code failed to send to ${USERNAME}`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function resetPassword
+     * @async
+     * @description Resets the password for the specified username.
+     * @param {string} CODE - The code to use to reset the password. Sent to the user's email
+     * by calling forgotPassword().
+     * @param {string} NEW_PASSWORD - The new password to set.
+     * @returns {Promise<void>}
+     * Resets the password for the specified username.
+     * @throws {Error} - An error is thrown if the password fails to reset.
+     */ 
+    async resetPassword(CODE, NEW_PASSWORD)
+    {
+        const USERNAME = this.config.username;
+
+        _printDatetime(`Resetting password for ${USERNAME}`);
+
+        try
+        {
+            await _resetPassword(this.config.serviceApiUrl, USERNAME, CODE, NEW_PASSWORD,  
+                this.debugMode);
+            _printDatetime(`Password reset for ${USERNAME}`);
+        }
+        catch (error)
+        {
+            _printDatetime(`Password failed to reset for ${USERNAME}`);
+            throw error;
+        }
+    }
+
+    // media functions
+    /**
+     * @function clearContinueWatching
+     * @async
+     * @description Delete continue watching markers.
+     * @param {string | null} USER_ID - The user ID of the user to clear the continue watching list.
+     * If not user Id is passed it clears the markers of the logged in user.
+     * @param {string | null} ASSET_ID - The asset ID of the asset to clear the continue watching
+     * list. If not asset Id is passed it clears the markers of all assets.
+     * @returns {Promise<void>} - A promise that resolves when the continue watching list is cleared.
+     * @throws {Error} - An error is thrown if the continue watching list fails to clear.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */
+    async clearContinueWatching(USER_ID, ASSET_ID)
+    {
+        if (this.token === null)
+        {
+            await this._init();
+        }
+
+        if (this.config.apiType !== "portal") 
+        {
+            throw new Error("This function is only available for portal API type.");
+        }
+
+        _printDatetime(`Clearing continue watching`);
+
+        try
+        {
+            await _clearContinueWatching(this.token, this.config.serviceApiUrl, USER_ID, ASSET_ID, 
+                this.debugMode);
+            _printDatetime(`Continue watching cleared`);
+        }
+        catch (error)
+        {
+            _printDatetime(`Continue watching failed to clear`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function clearWatchlist
+     * @async
+     * @description Clears the watchlist.
+     * @param {string | null} USER_ID - The user ID of the user to clear the watchlist.
+     * If not user Id is passed it clears the watchlist of the logged in user.
+     * @returns {Promise<void>} - A promise that resolves when the watchlist is cleared.
+     * @throws {Error} - An error is thrown if the watchlist fails to clear.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */
+    async clearWatchlist(USER_ID)
+    {
+        if (this.token === null)
+        {
+            await this._init();
+        }
+
+        if (this.config.apiType !== "portal")
+        {   
+            throw new Error("This function is only available for portal API type.");
+        }
+
+        _printDatetime(`Clearing watchlist`);
+
+        try
+        {
+            USER_ID = USER_ID || this.id;
+
+            await _clearWatchlist(this.token, this.config.serviceApiUrl, USER_ID, this.debugMode);
+            _printDatetime(`Watchlist cleared`);
+        }
+        catch (error)
+        {
+            _printDatetime(`Watchlist failed to clear`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function createForm
+     * @async
+     * @description Gets media.
+     * @param {string} CONTENT_DEFINITION_ID - The ID of the content definition the form
+     * is going in.
+     * @param {JSON} FORM_INFO - The information of the form.
+     * JSON format: whatever key value pairs you want to add to the form.
+     * @returns {Promise<JSON>} - A promise that resolves when the from is created.
+     * Returns the id of the form.
+     * @throws {Error} - An error is thrown if the media fails to get.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */ 
+    async createForm(CONTENT_DEFINITION_ID, FORM_INFO)
+    {
+        if (this.token === null)
+        {
+            await this._init();
+        }
+
+        if (this.config.apiType !== "portal")
+        {
+            throw new Error("This function is only available for portal API type.");
+        }
+
+        _printDatetime(`Creating form`);
+
+        try
+        {
+            const GET_FORMS_INFO = await _createForm(this.token, this.config.serviceApiUrl, 
+                CONTENT_DEFINITION_ID, FORM_INFO, this.debugMode);
+            _printDatetime(`Form created`);
+            return GET_FORMS_INFO;
+        }
+        catch (error)
+        {
+            _printDatetime(`Form failed to create`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function getContentCookies
+     * @async
+     * @description Gets content cookies.
+     * @param {string} CONTENT_ID - The Id of the content to retrieve the cookies for. 
+     * This can be the ID for the content definition of the LiveChannel, or a folder asset 
+     * ID or a specific Asset ID.
+     * @returns {Promise<JSON>} - A promise that resolves when the content cookies are gotten.
+     * Returns the information of the gotten content cookies.
+     * @throws {Error} - An error is thrown if the content cookies fail to get.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */
+    async getContentCookies(CONTENT_ID)
+    {
+        if (this.token === null)
+        {
+            await this._init();
+        }
+
+        if (this.config.apiType !== "portal")
+        {
+              throw new Error("This function is only available for portal API type.");
+        }
+
+        _printDatetime(`Getting content cookies`);
+
+        try
+        {
+            const GET_CONTENT_COOKIES_INFO = await _getContentCookies(this.token, 
+                this.config.serviceApiUrl, CONTENT_ID, this.debugMode);
+            _printDatetime(`Content cookies gotten`);
+            return GET_CONTENT_COOKIES_INFO;
+        }
+        catch (error)
+        {
+            _printDatetime(`Content cookies failed to get`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function getDefaultSiteConfig
+     * @async
+     * @description Gets default site config.
+     * @returns {Promise<Array<JSON>>} - A promise that resolves when the default site config is gotten.
+     * Returns the information of the gotten dynamic content.
+     * @throws {Error} - An error is thrown if the dynamic content fails to get.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */
+    async getDefaultSiteConfig()
+    {
+        if (this.token === null)
+        {
+            await this._init();
+        }
+
+        if (this.config.apiType !== "portal")
+        {
+            throw new Error("This function is only available for portal API type.");
+        }
+
+        _printDatetime(`Getting default site config`);
+
+        try
+        {
+            const GET_DYNAMIC_CONTENTS_INFO = await _getDefaultSiteConfig(this.token, 
+                this.config.serviceApiUrl, this.debugMode);
+            _printDatetime(`Default site config gotten`);
+            return GET_DYNAMIC_CONTENTS_INFO;
+        }
+        catch (error)
+        {
+            _printDatetime(`Default site config failed to get`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function getDynamicContent
+     * @async
+     * @description Gets dynamic content.
+     * @param {string} DYNAMIC_CONTENT_RECORD_ID - The dynamic content record ID.
+     * @returns {Promise<JSON>} - A promise that resolves when the dynamic content is gotten.
+     * Returns the information of the gotten dynamic content.
+     * @throws {Error} - An error is thrown if the dynamic content fails to get.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */
+    async getDynamicContent(DYNAMIC_CONTENT_RECORD_ID)
+    {
+        if (this.token === null)
+        {
+            await this._init();
+        }
+
+        _printDatetime(`Getting dynamic content: ${DYNAMIC_CONTENT_RECORD_ID}`);
+
+        try
+        {
+            const GET_DYNAMIC_CONTENT_INFO = await _getDynamicContent(this.token, 
+                this.config.serviceApiUrl, DYNAMIC_CONTENT_RECORD_ID, this.debugMode);
+            _printDatetime(`Dynamic content gotten: ${DYNAMIC_CONTENT_RECORD_ID}`);
+            return GET_DYNAMIC_CONTENT_INFO;
+        }
+        catch (error)
+        {
+            _printDatetime(`Dynamic content failed to get: ${DYNAMIC_CONTENT_RECORD_ID}`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function getDynamicContents
+     * @async
+     * @description Gets dynamic contents.
+     * @returns {Promise<Array<JSON>>} - A promise that resolves when the dynamic contents is gotten.
+     * Returns the information of the gotten dynamic content.
+     * @throws {Error} - An error is thrown if the dynamic content fails to get.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */
+    async getDynamicContents()
+    {
+        if (this.token === null)
+        {
+            await this._init();
+        }
+
+        if (this.config.apiType !== "portal")
+        {
+            throw new Error("This function is only available for portal API type.");
+        }
+
+        _printDatetime(`Getting dynamic contents`);
+
+        try
+        {
+            const GET_DYNAMIC_CONTENTS_INFO = await _getDynamicContents(this.token, 
+                this.config.serviceApiUrl, this.debugMode);
+            _printDatetime(`Dynamic contents gotten`);
+            return GET_DYNAMIC_CONTENTS_INFO;
+        }
+        catch (error)
+        {
+            _printDatetime(`Dynamic contents failed to get`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function getMediaGroup
+     * @async
+     * @description Gets media group.
+     * @param {string} MEDIA_GROUP_ID - The ID of the media group.
+     * @returns {Promise<JSON>} - A promise that resolves when the media group is gotten.
+     * Returns the information of the gotten media group.
+     * @throws {Error} - An error is thrown if the media group fails to get.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */
+    async getMediaGroup(MEDIA_GROUP_ID)
+    {
+        if (this.token === null)
+        {
+            await this._init();
+        }
+
+        if (this.config.apiType !== "portal")
+        {
+            throw new Error("This function is only available for portal API type.");
+        }
+
+        _printDatetime(`Getting media group: ${MEDIA_GROUP_ID}`);
+
+        try
+        {
+            const GET_MEDIA_GROUP_INFO = await _getMediaGroup(this.token, this.config.serviceApiUrl, 
+                MEDIA_GROUP_ID, this.debugMode);
+            _printDatetime(`Media group gotten: ${MEDIA_GROUP_ID}`);
+            return GET_MEDIA_GROUP_INFO;
+        }
+        catch (error)
+        {
+            _printDatetime(`Media group failed to get: ${MEDIA_GROUP_ID}`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function getMediaItem
+     * @async
+     * @description Gets media item.
+     * @param {string} MEDIA_ITEM_ID - The ID of the media item.
+     * @returns {Promise<JSON>} - A promise that resolves when the media item is gotten.
+     * Returns the information of the gotten media item.
+     * @throws {Error} - An error is thrown if the media item fails to get.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */
+    async getMediaItem(MEDIA_ITEM_ID)
+    {
+        if (this.token === null)
+        {
+            await this._init();
+        }
+
+        if (this.config.apiType !== "portal")
+        {
+            throw new Error("This function is only available for portal API type.");
+        }
+
+        _printDatetime(`Getting media item: ${MEDIA_ITEM_ID}`);
+
+        try
+        {
+            const GET_MEDIA_ITEM_INFO = await _getMediaItem(this.token, this.config.serviceApiUrl, 
+                MEDIA_ITEM_ID, this.debugMode);
+            _printDatetime(`Media item gotten: ${MEDIA_ITEM_ID}`);
+            return GET_MEDIA_ITEM_INFO;
+        }
+        catch (error)
+        {
+            _printDatetime(`Media item failed to get: ${MEDIA_ITEM_ID}`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function getMyContent
+     * @async
+     * @description Gets favorites and continue watching lists of IDs for the logged in user.
+     * @returns {Promise<JSON>} - A promise that resolves when the favorites and continue watching
+     * lists of IDs are gotten.
+     * Returns the information of the gotten favorites and continue watching lists of IDs.
+     * @throws {Error} - An error is thrown if the favorites and continue watching lists of IDs fail
+     * to get.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */
+    async getMyContent()
+    {
+        if (this.token === null)
+        {
+            await this._init();
+        }
+
+        if (this.config.apiType !== "portal")
+        {
+            throw new Error("This function is not available for portal API type.");
+        }
+
+        _printDatetime(`Getting my content`);
+
+        try
+        {
+            const GET_MY_CONTENT_INFO = await _getMyContent(this.token, this.config.serviceApiUrl, 
+                this.debugMode);
+            _printDatetime(`My content gotten`);
+            return GET_MY_CONTENT_INFO;
+        }
+        catch (error)
+        {
+            _printDatetime(`My content failed to get`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function getMyGroup
+     * @async
+     * @description Gets user's group.
+     * @param {string} GROUP_ID - The ID of the group.
+     * @returns {Promise<JSON>} - A promise that resolves when the user's group is gotten.
+     * Returns the information of the gotten user's group.
+     * @throws {Error} - An error is thrown if the user's group fails to get.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */
+    async getMyGroup(GROUP_ID)
+    {
+        if (this.token === null)
+        {
+            await this._init();
+        }
+
+        _printDatetime(`Getting my group: ${GROUP_ID}`);
+
+        try
+        {
+            const GET_MY_GROUP_INFO = await _getMyGroup(this.token, this.config.serviceApiUrl, 
+                GROUP_ID, this.debugMode);
+            _printDatetime(`My group gotten: ${GROUP_ID}`);
+            return GET_MY_GROUP_INFO;
+        }
+        catch (error)
+        {
+            _printDatetime(`My group failed to get: ${GROUP_ID}`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function getSiteConfig
+     * @async
+     * @description Gets site config.
+     * @param {string} SITE_CONFIG_RECORD_ID - The site config record ID.
+     * @returns {Promise<JSON>} - A promise that resolves when the site config is gotten.
+     * Returns the information of the gotten site config.
+     * @throws {Error} - An error is thrown if the site config fails to get.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */
+    async getSiteConfig(SITE_CONFIG_RECORD_ID)
+    {
+        if (this.token === null)
+        {
+            await this._init();
+        }
+
+        _printDatetime(`Getting site config: ${SITE_CONFIG_RECORD_ID}`);
+
+        try
+        {
+            const GET_DYNAMIC_CONTENT_INFO = await _getSiteConfig(this.token, 
+                this.config.serviceApiUrl, SITE_CONFIG_RECORD_ID, this.debugMode);
+            _printDatetime(`Site config gotten: ${SITE_CONFIG_RECORD_ID}`);
+            return GET_DYNAMIC_CONTENT_INFO;
+        }
+        catch (error)
+        {
+            _printDatetime(`Site config failed to get: ${SITE_CONFIG_RECORD_ID}`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function mediaSearch
+     * @async
+     * @description Searches for media.
+     * @param {string | null} QUERY - The query of the search.
+     * @param {Array<string> | null} IDS - The IDs of the media to be searched.
+     * @param {Array<JSON> | null} SORT_FIELDS - The sort fields of the search.
+     * JSON format: [{"fieldName": "string", "sortType": ("Ascending" | "Descending")} ...]
+     * @param {number | null} OFFSET - The page offset of the search.
+     * @param {number | null} SIZE - The page size of the search.
+     * @returns {Promise<JSON>} - A promise that resolves when the media are searched.
+     * Returns the information of the searched media.
+     * @throws {Error} - An error is thrown if the media fail to search.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */ 
+    async mediaSearch(QUERY, IDS, SORT_FIELDS, OFFSET, SIZE)
+    {
+        if (this.token === null)
+        {
+            await this._init();
+        }
+
+        if (this.config.apiType !== "portal")
+        {
+            throw new Error("This function is only available for portal API type.");
+        }
+
+        _printDatetime(`Searching media...`);
+
+        try
+        {
+            const MEDIA_SEARCH_INFO = await _mediaSearch(this.token, this.config.serviceApiUrl, 
+                QUERY, IDS, SORT_FIELDS, OFFSET, SIZE, this.debugMode);
+            _printDatetime(`Media search complete`);
+            return MEDIA_SEARCH_INFO;
+        }
+        catch (error)
+        {
+            _printDatetime(`Media search failed`);
+            throw error;
+        }
+    }
+
+}
+
+export default NomadMediaSDK;
+
+
+async function _forgotPassword(URL, USERNAME, DEBUG_MODE) 
+{
+	const API_URL = `${URL}/api/account/forgot-password`;
+
+	const HEADERS = new Headers();
+	HEADERS.append("Content-Type", "application/json");
+	
+	const BODY = {
+		username: USERNAME
+	};
+
+	if (DEBUG_MODE) console.log(`URL: ${API_URL}\nMETHOD: POST\nBODY: ${JSON.stringify(BODY, null, 4 )}`);
+	
+	try 
+	{
+		const RESPONSE = await fetch(API_URL, {
+			method: "POST",
+			headers: HEADERS,
+			body: JSON.stringify(BODY)
+		}).catch((exception) => {
+			throw exception;
+		});
+
+		
+		if (!RESPONSE.ok) {
+			throw await RESPONSE.json()
+		}
+	}
+	catch (error)
+	{
+		_apiExceptionHandler(error, "Forgot Password Failed");
+	}
+}
+
+
+
+
+async function _login(USERNAME, PASSWORD, URL, DEBUG_MODE)
+{
+    const API_URL = `${URL}/api/account/login`;
+
+    const HEADERS = {
+        "Content-Type": "application/json"
+    };
+
+    const BODY = {
+        "userName": USERNAME,
+        "password": PASSWORD
+    };
+
+    if (DEBUG_MODE) console.log(`URL: ${API_URL}\nMETHOD: POST\nBODY: ${JSON.stringify(BODY, null, 4 )}`);
+
+    try
+    {  
+        const RESPONSE = await fetch(API_URL, {
+            method: "POST",
+            headers: HEADERS,
+            body: JSON.stringify(BODY)
+        })
+
+        if (!RESPONSE.ok)
+        {
+            throw await RESPONSE.json()
+        }
+
+        return await RESPONSE.json();
+    }
+    catch (error)
+    {
+        _apiExceptionHandler(error, "Login Failed");
+    }
+}
+
+
+
+
+
+
+async function _logout(AUTH_TOKEN, URL, DEBUG_MODE)
+{
+    const API_URL = `${URL}/api/account/logout`;
+
+    // Create header for the request
+    const HEADERS = new Headers();
+    HEADERS.append("Content-Type", "application/json");
+    HEADERS.append("Authorization", `Bearer ${AUTH_TOKEN}`);
+
+    // Build the POST payload body
+
+    if (DEBUG_MODE) console.log(`URL: ${API_URL}\nMETHOD: POST`);
+
+    try
+    {
+        const RESPONSE = await fetch(API_URL, {
+            method: "POST",
+            headers: HEADERS
+        });
+
+        if (!RESPONSE.ok) {
+            throw await RESPONSE.json()
+        }
+    }
+    catch (error)
+    {
+        _apiExceptionHandler(error, "Logout Failed");
+    }
+
+}
+
+
+
+
+
+
+async function _refreshToken(AUTH_TOKEN, URL, REFRESH_TOKEN, DEBUG_MODE) 
+{
+    const API_URL = `${URL}/api/account/refresh-token`;
+
+    // Create header for the request
+    const HEADERS = new Headers();
+    HEADERS.append("Content-Type", "application/json");
+    HEADERS.append("Authorization", `Bearer ${AUTH_TOKEN}`);
+
+    // Build the payload body
+    const BODY = {
+        refreshToken: REFRESH_TOKEN
+    };
+
+    if (DEBUG_MODE) console.log(`URL: ${API_URL}\nMETHOD: POST\nBODY: ${JSON.stringify(BODY, null, 4 )}`);
+
+    try
+    {
+        const RESPONSE = await fetch(API_URL, {
+            method: "POST",
+            headers: HEADERS,
+            body: JSON.stringify(BODY)
+        });
+
+        if (!RESPONSE.ok) {
+            throw await RESPONSE.json()
+        }
+
+        return await RESPONSE.json();
+
+    }
+    catch (error)
+    {
+        _apiExceptionHandler(error, "Refreshing Token Failed");
+    }
+}
+
+
+
+
+
+async function _resetPassword(URL, USERNAME, TOKEN, NEW_PASSWORD, DEBUG_MODE) 
+{
+	const API_URL = `${URL}/api/account/reset-password`;
+
+	// Create header for the request
+    const HEADERS = new Headers();
+    HEADERS.append("Content-Type", "application/json");
+  
+  	const BODY = {
+        userName: USERNAME,
+        TOKEN: TOKEN,
+        newPassword: NEW_PASSWORD
+    };
+
+	if (DEBUG_MODE) console.log(`URL: ${API_URL}\nMETHOD: POST\nBODY: ${JSON.stringify(BODY, null, 4 )}`);
+  
+  	try
+	{
+    	const RESPONSE = await fetch(API_URL, {
+    	    method: "POST",
+    	    headers: HEADERS,
+    	    body: JSON.stringify(BODY)
+    	});
+
+		
+    	if (!RESPONSE.ok) {
+			throw await RESPONSE.json();
+    	}
+	}
+	catch (error)
+	{
+		_apiExceptionHandler(error, "Reset Password Failed");
+	}
+    
+}
+
+
+function _apiExceptionHandler(error, message) {
+    // Check if we have a response object and error message
+    if (!error) {
+        throw new Error(message);
+    }
+
+    // Check if error is a string
+    if (typeof error === "string") {
+        throw new Error(`${message}: ${error}`);
+    }
+    else if (error.errors)
+    {
+        if (Array.isArray(error.errors)) {
+            let errorString = "";
+            for (let errorIdx = 0; errorIdx < error.errors.length; errorIdx++) 
+            {
+                errorString += `${error.errors[errorIdx].code}: ${error.errors[errorIdx].field}: ${error.errors[errorIdx].message}\n`; 
+            }
+            throw new Error(`${message}: ${errorString}`);
+        } 
+        else if (typeof error.errors === "object") {
+            let errorString = "";
+            for (let key in error.errors) {
+                if (Object.prototype.hasOwnProperty.call(error.errors, key)) {
+                    errorString += `${key}: ${error.errors[key]}\n`;
+                }
+            }
+            throw new Error(`${message}: ${errorString}`);
+        }
+    }
+    else
+    {
+        throw new Error(`${message}: ${error.message}`);
+    }
+}
+
+
+/**
+ * New GUID
+ *
+ * @returns UUID v4 GUID
+ */
+
+import { getRandomValues } from 'crypto';
+
+function _newGuid() {
+    return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, (c) =>
+        (c ^ (getRandomValues(new Uint8Array(1))[0] & (15 >> (c / 4)))).toString(16)
+    );
+}
+
+
+
+function _printDatetime(msg)
+{
+    const NOW = new Date();
+    const FORMATTED_TIME = NOW.toLocaleTimeString();
+    console.log(`${FORMATTED_TIME}: ${msg}`);
+}
+
+
+async function _sleep(duration) {
+    // Check for valid duration
+    if (!duration || duration === 0) {
+        // Ignore
+        return;
+    }
+
+    // Sleep
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve();
+        }, duration * 1000);
+    });
+}
+
+
+
+function _slugify(text) {
+    if (!text || text.trim().length === 0) return "";
+    return text
+        .toString()
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .trim()
+        .replace(/\s+/g, "-")
+        .replace(/[^\w-]+/g, "")
+        .replace(/--+/g, "-");
+}
+
+
+
+
+
+async function _clearContinueWatching(AUTH_TOKEN, URL, USER_ID, ASSET_ID, DEBUG_MODE) 
+{
+    let apiUrl = `${URL}/api/media/clear-watching`;
+
+    let params = [];
+    if (USER_ID) params.push(`userId=${USER_ID}`);
+    if (ASSET_ID) params.push(`assetId=${ASSET_ID}`);
+    apiUrl += params.length ? `?${params.join('&')}` : '';
+
+    // Create header for the request
+    const HEADERS = new Headers();
+    HEADERS.append("Content-Type", "application/json");
+    HEADERS.append("Authorization", `Bearer ${AUTH_TOKEN}`);
+
+    if (DEBUG_MODE) console.log(`URL: ${apiUrl}\nMETHOD: POST`);
+
+    try
+    {
+        const RESPONSE = await fetch(`${apiUrl}`, {
+            method: "POST",
+            headers: HEADERS
+        });
+
+        if (!RESPONSE.ok) {
+            throw await RESPONSE.json()
+        }
+    }
+    catch (error)
+    {
+        _apiExceptionHandler(error, "Clear Continue Watching Failed");
+    }
+}
+
+
+
+
+async function _clearWatchlist(AUTH_TOKEN, URL, USER_ID, DEBUG_MODE) 
+{
+    const API_URL = `${URL}/api/media/clear-watchlist?userId=${USER_ID}`;
+
+    // Create header for the request
+    const HEADERS = new Headers();
+    HEADERS.append("Content-Type", "application/json");
+    HEADERS.append("Authorization", `Bearer ${AUTH_TOKEN}`);
+
+    if (DEBUG_MODE) console.log(`URL: ${API_URL}\nMETHOD: POST`);
+
+    try
+    {
+        const RESPONSE = await fetch(`${API_URL}`, {
+            method: "POST",
+            headers: HEADERS
+        });
+
+        if (!RESPONSE.ok) {
+            throw await RESPONSE.json()
+        }
+    }
+    catch (error)
+    {
+        _apiExceptionHandler(error, "Clear Watchlist Failed");
+    }
+}
+
+
+
+
+async function _createForm(AUTH_TOKEN, URL, CONTENT_DEFINITION_ID, FORM_INFO, DEBUG_MODE) 
+{
+    const API_URL = `${URL}/api/media/form/${CONTENT_DEFINITION_ID}`;
+
+    // Create header for the request
+    const HEADERS = new Headers();
+    HEADERS.append("Content-Type", "application/json");
+    HEADERS.append("Authorization", `Bearer ${AUTH_TOKEN}`);
+  
+    const BODY = FORM_INFO;
+
+    if (DEBUG_MODE) console.log(`URL: ${API_URL}\nMETHOD: POST\nBODY: ${JSON.stringify(BODY, null, 4 )}`);
+
+    try
+    {
+        const RESPONSE = await fetch(API_URL, {
+            method: "POST",
+            headers: HEADERS,
+            body: JSON.stringify(BODY)
+        });
+
+        if (!RESPONSE.ok) {
+            throw await RESPONSE.json()
+        }
+    
+  	    return await RESPONSE.json();
+    }
+    catch (error)
+    {
+        _apiExceptionHandler(error, "Creating Form Failed");
+    }
+}
+
+
+
+
+async function _getContentCookies(AUTH_TOKEN, URL, ID, DEBUG_MODE) 
+{
+    const API_URL = `${URL}/api/media/set-cookies/${ID}`;
+
+    // Create header for the request
+    const HEADERS = new Headers();
+    HEADERS.append("Content-Type", "application/json");
+    HEADERS.append("Authorization", `Bearer ${AUTH_TOKEN}`);
+
+    if (DEBUG_MODE) console.log(`URL: ${API_URL}\nMETHOD: GET`);
+
+    try
+    {
+        const RESPONSE = await fetch(`${API_URL}`, {
+            method: "GET",
+            headers: HEADERS
+        });
+
+        if (!RESPONSE.ok) {
+            throw await RESPONSE.json()
+        }
+    
+  	    return await RESPONSE.json();
+    }
+    catch (error)
+    {
+        _apiExceptionHandler(error, "Get Content Cookies Failed");
+    }
+}
+
+
+
+
+async function _getDefaultSiteConfig(AUTH_TOKEN, URL, DEBUG_MODE) 
+{
+    const API_URL = `${URL}/api/media/config`;
+
+    // Create header for the request
+    const HEADERS = new Headers();
+    HEADERS.append("Content-Type", "application/json");
+    HEADERS.append("Authorization", `Bearer ${AUTH_TOKEN}`);
+
+    if (DEBUG_MODE) console.log(`URL: ${API_URL}\nMETHOD: GET`);
+
+    try
+    {
+        const RESPONSE = await fetch(`${API_URL}`, {
+            method: "GET",
+            headers: HEADERS
+        });
+
+        if (!RESPONSE.ok) {
+            throw await RESPONSE.json()
+        }
+    
+  	    return await RESPONSE.json();
+    }
+    catch (error)
+    {
+        _apiExceptionHandler(error, "Get Default Site Config Failed");
+    }
+}
+
+
+
+
+async function _getDynamicContent(AUTH_TOKEN, URL, ID, DEBUG_MODE) 
+{
+    const API_URL = `${URL}/api/media/content/${ID}`;
+
+    // Create header for the request
+    const HEADERS = new Headers();
+    HEADERS.append("Content-Type", "application/json");
+    HEADERS.append("Authorization", `Bearer ${AUTH_TOKEN}`);
+
+    if (DEBUG_MODE) console.log(`URL: ${API_URL}\nMETHOD: GET`);
+
+    try
+    {
+        const RESPONSE = await fetch(`${API_URL}`, {
+            method: "GET",
+            headers: HEADERS
+        });
+
+        if (!RESPONSE.ok) {
+            throw await RESPONSE.json()
+        }
+    
+  	    return await RESPONSE.json();
+    }
+    catch (error)
+    {
+        _apiExceptionHandler(error, "Get Dynamic Content Failed");
+    }
+}
+
+
+
+
+async function _getDynamicContents(AUTH_TOKEN, URL, DEBUG_MODE) 
+{
+    const API_URL = `${URL}/api/media/content`;
+
+    // Create header for the request
+    const HEADERS = new Headers();
+    HEADERS.append("Content-Type", "application/json");
+    HEADERS.append("Authorization", `Bearer ${AUTH_TOKEN}`);
+
+    if (DEBUG_MODE) console.log(`URL: ${API_URL}\nMETHOD: GET`);
+
+    try
+    {
+        const RESPONSE = await fetch(`${API_URL}`, {
+            method: "GET",
+            headers: HEADERS
+        });
+
+        if (!RESPONSE.ok) {
+            throw await RESPONSE.json()
+        }
+    
+  	    return await RESPONSE.json();
+    }
+    catch (error)
+    {
+        _apiExceptionHandler(error, "Get Dynamic Contents Failed");
+    }
+}
+
+
+
+
+async function _getMediaGroup(AUTH_TOKEN, URL, ID, DEBUG_MODE) 
+{
+    const API_URL = `${URL}/api/media/group/${ID}`;
+
+    // Create header for the request
+    const HEADERS = new Headers();
+    HEADERS.append("Content-Type", "application/json");
+    HEADERS.append("Authorization", `Bearer ${AUTH_TOKEN}`);
+
+    if (DEBUG_MODE) console.log(`URL: ${API_URL}\nMETHOD: GET`);
+
+    try
+    {
+        const RESPONSE = await fetch(`${API_URL}`, {
+            method: "GET",
+            headers: HEADERS
+        });
+
+        if (!RESPONSE.ok) {
+            throw await RESPONSE.json()
+        }
+    
+  	    return await RESPONSE.json();
+    }
+    catch (error)
+    {
+        _apiExceptionHandler(error, "Get Media Group Failed");
+    }
+}
+
+
+
+
+async function _getMediaItem(AUTH_TOKEN, URL, ID, DEBUG_MODE) 
+{
+    const API_URL = `${URL}/api/media/item/${ID}`;
+
+    // Create header for the request
+    const HEADERS = new Headers();
+    HEADERS.append("Content-Type", "application/json");
+    HEADERS.append("Authorization", `Bearer ${AUTH_TOKEN}`);
+
+    if (DEBUG_MODE) console.log(`URL: ${API_URL}\nMETHOD: GET`);
+
+    try
+    {
+        const RESPONSE = await fetch(`${API_URL}`, {
+            method: "GET",
+            headers: HEADERS
+        });
+
+        if (!RESPONSE.ok) {
+            throw await RESPONSE.json()
+        }
+    
+  	    return await RESPONSE.json();
+    }
+    catch (error)
+    {
+        _apiExceptionHandler(error, "Get Media Item Failed");
+    }
+}
+
+
+
+
+async function _getMyContent(AUTH_TOKEN, URL, DEBUG_MODE) 
+{
+    const API_URL = `${URL}/api/media/my-content`;
+
+    // Create header for the request
+    const HEADERS = new Headers();
+    HEADERS.append("Content-Type", "application/json");
+    HEADERS.append("Authorization", `Bearer ${AUTH_TOKEN}`);
+
+    if (DEBUG_MODE) console.log(`URL: ${API_URL}\nMETHOD: GET`);
+
+    try
+    {
+        const RESPONSE = await fetch(`${API_URL}`, {
+            method: "GET",
+            headers: HEADERS
+        });
+
+        if (!RESPONSE.ok) {
+            throw await RESPONSE.json()
+        }
+    
+  	    return await RESPONSE.json();
+    }
+    catch (error)
+    {
+        _apiExceptionHandler(error, "Get My Content Failed");
+    }
+}
+
+
+
+
+async function _getMyGroup(AUTH_TOKEN, URL, ID, DEBUG_MODE) 
+{
+    const API_URL = `${URL}/api/media/my-group/${ID}`;
+
+    // Create header for the request
+    const HEADERS = new Headers();
+    HEADERS.append("Content-Type", "application/json");
+    HEADERS.append("Authorization", `Bearer ${AUTH_TOKEN}`);
+
+    if (DEBUG_MODE) console.log(`URL: ${API_URL}\nMETHOD: GET`);
+
+    try
+    {
+        const RESPONSE = await fetch(`${API_URL}`, {
+            method: "GET",
+            headers: HEADERS
+        });
+
+        if (!RESPONSE.ok) {
+            throw await RESPONSE.json()
+        }
+    
+  	    return await RESPONSE.json();
+    }
+    catch (error)
+    {
+        _apiExceptionHandler(error, "Get My Group Failed");
+    }
+}
+
+
+
+
+async function _getSiteConfig(AUTH_TOKEN, URL, ID, DEBUG_MODE) 
+{
+    const API_URL = `${URL}/api/media/config/${ID}`;
+
+    // Create header for the request
+    const HEADERS = new Headers();
+    HEADERS.append("Content-Type", "application/json");
+    HEADERS.append("Authorization", `Bearer ${AUTH_TOKEN}`);
+
+    if (DEBUG_MODE) console.log(`URL: ${API_URL}\nMETHOD: GET`);
+
+    try
+    {
+        const RESPONSE = await fetch(`${API_URL}`, {
+            method: "GET",
+            headers: HEADERS
+        });
+
+        if (!RESPONSE.ok) {
+            throw await RESPONSE.json()
+        }
+    
+  	    return await RESPONSE.json();
+    }
+    catch (error)
+    {
+        _apiExceptionHandler(error, "Get Site Config Failed");
+    }
+}
+
+
+
+
+async function _mediaSearch(AUTH_TOKEN, URL, SEARCH_QUERY, IDS, SORT_FIELDS, 
+    PAGE_OFFSET, PAGE_SIZE, DEBUG_MODE) 
+{
+    const API_URL = `${URL}/api/media/search`;
+
+    // Create header for the request
+    const HEADERS = new Headers();
+    HEADERS.append("Content-Type", "application/json");
+    HEADERS.append("Authorization", `Bearer ${AUTH_TOKEN}`);
+  
+    const BODY = {  
+        searchQuery: SEARCH_QUERY,
+        ids: IDS,
+        sortFields: SORT_FIELDS
+    };
+
+    PAGE_OFFSET ? BODY["pageOffset"] = PAGE_OFFSET : BODY["pageOffset"] = 0;
+    PAGE_SIZE ? BODY["pageSize"] = PAGE_SIZE : BODY["pageSize"] = 100;
+
+    if (DEBUG_MODE) console.log(`URL: ${API_URL}\nMETHOD: POST\nBODY: ${JSON.stringify(BODY, null, 4 )}`);
+
+    try
+    {
+        const RESPONSE = await fetch(`${API_URL}`, {
+            method: "POST",
+            headers: HEADERS,
+            body: JSON.stringify(BODY)
+        });
+
+        if (!RESPONSE.ok) {
+            throw await RESPONSE.json()
+        }
+    
+  	    return await RESPONSE.json();
+    }
+    catch (error)
+    {
+        _apiExceptionHandler(error, "Media Search Failed");
+    }
+}
+