dce-reactkit 3.9.0-beta-loading-modal.2 → 3.9.0-beta-loading-modal.3

package/src/helpers/validators/validURL.test.ts

@@ -0,0 +1,90 @@
+
+// Import the function to be tested
+// import isValid from './validURL';
+
+// // Import constants
+// import { INVALID_STRING_ERRORS, INVALID_REGEX_ERROR } from './shared/constants/ERROR_MESSAGES';
+
+// /*------------------------------------------------------------------------*/
+// /* ---------------------------- Valid Tests --------------------------- */
+// /*------------------------------------------------------------------------*/
+
+// const validUrls: string[] = [
+//   'http://example.com',
+//   'https://example.com',
+//   'http://www.example.com',
+//   'https://www.example.com',
+//   'https://example.com/path',
+//   'http://example.com/path',
+//   'https://example.com?query=string',
+//   'http://example.com?query=string',
+//   'https://example.com#fragment',
+//   'http://example.com#fragment',
+//   'http://localhost',
+//   'https://localhost:3000',
+//   'http://localhost:3000',
+//   'http://127.0.0.1',
+//   'http://127.0.0.1:3000',
+//   'ftp://example.com/path',
+//   'ftp://example.com',
+//   'https://127.0.0.1:3000',
+//   'file:///C:/path/to/file'
+// ];
+
+// test(
+//   'Returns true for a given valid URL.',
+//   async () => {
+//     validUrls.forEach((url) => {
+//       expect(isValid(url)).toBe(true);
+//     });
+//   },
+// );
+
+// /*------------------------------------------------------------------------*/
+// /* ---------------------------- Invalid Tests --------------------------- */
+// /*------------------------------------------------------------------------*/
+
+// const invalidUrls: string[] = [
+//   '',
+//   ' ',
+//   'example',
+//   'http://',
+//   'http://.',
+//   'http://..',
+//   'http://##/',
+//   'http://../',
+//   'http://??/',
+//   'http://#',
+//   'http://##',
+//   '//',
+//   '//a',
+//   '///a',
+//   '///',
+//   'http:///a',
+//   'http://www.foo.bar./',
+//   'http://foo.bar/foo(bar)baz quux',
+//   'http://3628126748',
+//   'http://.www.foo.bar/',
+//   'http://.www.foo.bar./',
+//   'http://123.123.123',
+//   'http://1.1.1.1.1',
+//   'http://example.com:99999',
+//   'http://example.com:80:80',
+//   'http://example.com::80',
+//   'http://example.com:-80',
+//   'http://-example.com',
+//   'http://example.com-',
+//   'http://example.com_',
+//   'http://example..com',
+//   'http://example.com.',
+//   'http://.example.com'
+// ];
+
+// test(
+//   'Returns false for a given invalid URL.',
+//   async () => {
+//     invalidUrls.forEach((url) => {
+//       expect(isValid(url)).toBe(false);
+//     });
+//   },
+// );

package/src/helpers/validators/validURL.ts

@@ -0,0 +1,18 @@
+/**
+ * This function checks if a given input string is a valid URL.
+ * @author Leisha Bhandari
+ * @param URL: The input string that needs checked as a URL or not.
+ * @returns A true boolean value if the input string is a valid URL, and a false
+ *          boolean value if the input string is a invalid URL
+ */
+function isValid(url: string): boolean {
+  // Uses the input URL to create a URL object
+  try {
+    new URL(url);
+    // URL constructor does not throw an error, so input URL is valid
+    return true;
+  } catch (err) {
+    // URL constructor throws an error, so input URL is invalid
+    return false;
+  }
+}

package/src/helpers/visitEndpointOnAnotherServer/index.ts

@@ -0,0 +1,93 @@
+// Import custom error
+import ErrorWithCode from '../../errors/ErrorWithCode';
+
+// Import shared types
+import ReactKitErrorCode from '../../types/ReactKitErrorCode';
+
+// Import other helpers
+import sendServerToServerRequest from './sendServerToServerRequest';
+
+/**
+ * Send a server-to-server request from this sever to another server that uses
+ *   dce-reactkit [for server only]
+ * @author Gabe Abrams
+ * @param opts object containing all arguments
+ * @param opts.host - the host of the other server
+ * @param opts.path - the path of the other server's endpoint
+ * @param [opts.method=GET] - the method of the endpoint
+ * @param [opts.params] - query/body parameters to include
+ * @param [opts.headers] - headers to include
+ * @returns response from server
+ */
+const visitEndpointOnAnotherServer = async (
+  opts: {
+    host: string,
+    path: string,
+    method?: ('GET' | 'POST' | 'DELETE' | 'PUT'),
+    params?: { [key in string]: any },
+    headers?: { [k in string]: any },
+  },
+): Promise<any> => {
+  // Remove properties with undefined values
+  let params: { [key in string]: any } | undefined;
+  if (opts.params) {
+    params = Object.fromEntries(
+      Object
+        .entries(opts.params)
+        .filter(([, value]) => {
+          return value !== undefined;
+        }),
+    );
+  }
+
+  // Automatically JSONify arrays and objects
+  if (params) {
+    params = Object.fromEntries(
+      Object
+        .entries(params)
+        .map(([key, value]) => {
+          if (Array.isArray(value) || typeof value === 'object') {
+            return [key, JSON.stringify(value)];
+          }
+          return [key, value];
+        }),
+    );
+  }
+
+  // Send the request
+  const response = await sendServerToServerRequest({
+    host: opts.host,
+    path: opts.path,
+    method: opts.method ?? 'GET',
+    params,
+  });
+
+  // Check for failure
+  if (!response || !response.body) {
+    throw new ErrorWithCode(
+      'We didn\'t get a response from the server. Please check your internet connection.',
+      ReactKitErrorCode.NoResponse,
+    );
+  }
+  if (!response.body.success) {
+    // Other errors
+    throw new ErrorWithCode(
+      (
+        response.body.message
+        || 'An unknown error occurred. Please contact an admin.'
+      ),
+      (
+        response.body.code
+        || ReactKitErrorCode.NoCode
+      ),
+    );
+  }
+
+  // Success! Extract the body
+  const { body } = response.body;
+
+  // Return
+  return body;
+};
+
+export default visitEndpointOnAnotherServer;

package/src/helpers/visitEndpointOnAnotherServer/sendServerToServerRequest.ts

@@ -0,0 +1,164 @@
+// Import libs
+import qs from 'qs';
+
+// Import shared types
+import ReactKitErrorCode from '../../types/ReactKitErrorCode';
+
+// Import custom error
+import ErrorWithCode from '../../errors/ErrorWithCode';
+
+/**
+ * Sends and retries an http request
+ * @author Gabriel Abrams
+ * @param opts object containing all arguments
+ * @param opts.path path to send request to
+ * @param [opts.host] host to send request to
+ * @param [opts.method=GET] http method to use
+ * @param [opts.params] body/data to include in the request
+ * @param [opts.headers] headers to include in the request
+ * @param [opts.sendCrossDomainCredentials=true if in development mode] if true,
+ *   send cross-domain credentials even if not in dev mode
+ * @param [opts.responseType=JSON] expected response type
+ * @returns { body, status, headers } on success
+ */
+const sendServerToServerRequest = async (
+  opts: {
+    path: string,
+    host?: string,
+    method?: ('GET' | 'POST' | 'PUT' | 'DELETE'),
+    params?: { [k in string]: any },
+    headers?: { [k in string]: any },
+    responseType?: 'Text' | 'JSON',
+  },
+): Promise<{
+  body: any,
+  status: number,
+  headers: { [k in string]: any },
+}> => {
+  // Process method
+  const method: ('GET' | 'POST' | 'PUT' | 'DELETE') = (opts.method || 'GET');
+
+  // Encode objects within params
+  let params: {
+    [k in string]: any
+  } | undefined;
+  if (opts.params) {
+    params = {};
+    Object.entries(opts.params).forEach(([key, val]) => {
+      if (typeof val === 'object' && !Array.isArray(val)) {
+        (params as any)[key] = JSON.stringify(val);
+      } else {
+        (params as any)[key] = val;
+      }
+    });
+  }
+
+  // Stringify parameters
+  const stringifiedParams = qs.stringify(params || {}, {
+    encodeValuesOnly: true,
+    arrayFormat: 'brackets',
+  });
+
+  // Create url (include query if GET)
+  const query = (method === 'GET' ? `?${stringifiedParams}` : '');
+  let url;
+  if (!opts.host) {
+    // No host included at all. Just send to a path
+    url = `${opts.path}${query}`;
+  } else {
+    url = `https://${opts.host}${opts.path}${query}`;
+  }
+
+  // Update headers
+  const headers = opts.headers || {};
+  let data: string | null | { [k: string]: any } | undefined = null;
+  if (!headers['Content-Type']) {
+    // Form encoded
+    headers['Content-Type'] = 'application/x-www-form-urlencoded';
+    // Add data if applicable
+    data = (method !== 'GET' ? stringifiedParams : null);
+  } else {
+    // JSON encode
+    data = params;
+  }
+
+  // Encode data
+  let encodedData: URLSearchParams | string | undefined;
+  if (data) {
+    if (headers['Content-Type'] === 'application/x-www-form-urlencoded') {
+      encodedData = new URLSearchParams(params);
+    } else {
+      encodedData = JSON.stringify(data);
+    }
+  }
+
+  // Send request
+  try {
+    const response = await fetch(
+      url,
+      {
+        method,
+        mode: 'cors',
+        headers: headers ?? {},
+        body: (
+          (method !== 'GET' && encodedData)
+            ? encodedData
+            : undefined
+        ),
+        redirect: 'follow',
+      },
+    );
+
+    // Get headers map
+    const responseHeaders: {
+      [k in string]: string
+    } = {};
+    response.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
+    });
+
+    // Process response based on responseType
+    try {
+      // Parse response
+      let responseBody: any;
+      if (
+        opts.responseType
+        && opts.responseType === 'Text'
+      ) {
+        // Response type is text
+        responseBody = await response.text();
+      } else {
+        // Response type is JSON
+        responseBody = await response.json();
+      }
+
+      // Return response
+      return {
+        body: responseBody,
+        status: response.status,
+        headers: responseHeaders,
+      };
+    } catch (err) {
+      throw new ErrorWithCode(
+        `Failed to parse response as ${opts.responseType}: ${(err as any)?.message}`,
+        ReactKitErrorCode.ResponseParseError,
+      );
+    }
+  } catch (err) {
+    // Self-signed certificate error:
+    if ((err as any)?.message?.includes('self signed certificate')) {
+      throw new ErrorWithCode(
+        'We refused to send a request because the receiver has self-signed certificates.',
+        ReactKitErrorCode.SelfSigned,
+      );
+    }
+
+    // No tries left
+    throw new ErrorWithCode(
+      `We encountered an error when trying to send a network request. If this issue persists, contact an admin. Error: ${(err as any)?.message}`,
+      ReactKitErrorCode.NotConnected,
+    );
+  }
+};
+
+export default sendServerToServerRequest;

package/src/helpers/visitServerEndpoint.tsx

@@ -102,6 +102,7 @@ const visitServerEndpoint = async (
     params?: { [key in string]: any },
   },
 ): Promise<any> => {
+  // Set default method
   const method = (opts.method ?? 'GET');
   // Handle stubs
   const stubResponse = stubResponses[method]?.[opts.path];

package/src/index.ts

@@ -1,6 +1,7 @@
 // Import components
 import AppWrapper, {
   alert,
+  prompt,
   confirm,
   showFatalError,
   addFatalErrorHandler,
@@ -28,6 +29,7 @@ import Tooltip from './components/Tooltip';
 import ToggleSwitch from './components/ToggleSwitch';
 import AutoscrollToBottomContainer from './components/AutoscrollToBottomContainer';
 import MultiSwitch from './components/MultiSwitch';
+import Dropdown from './components/Dropdown';
 
 // Import errors
 import ErrorWithCode from './errors/ErrorWithCode';
@@ -92,6 +94,7 @@ import mapAsync from './helpers/asyncArrayFunctions/mapAsync';
 import someAsync from './helpers/asyncArrayFunctions/someAsync';
 import capitalize from './helpers/capitalize';
 import shuffleArray from './helpers/shuffleArray';
+import visitEndpointOnAnotherServer from './helpers/visitEndpointOnAnotherServer';
 
 // Import types
 import ModalButtonType from './types/ModalButtonType';
@@ -109,6 +112,7 @@ import LogBuiltInMetadata from './types/LogBuiltInMetadata';
 import LogMetadataType from './types/LogMetadataType';
 import LogFunction from './types/LogFunction';
 import IntelliTableColumn from './types/IntelliTableColumn';
+import DropdownItemType from './types/DropdownItemType';
 
 // Component-specific-types
 import PickableItem from './components/ItemPicker/types/PickableItem';
@@ -142,8 +146,10 @@ export {
   ToggleSwitch,
   AutoscrollToBottomContainer,
   MultiSwitch,
+  Dropdown,
   // Global functions
   alert,
+  prompt,
   confirm,
   showFatalError,
   // Errors
@@ -211,6 +217,7 @@ export {
   handleSuccess,
   initLogCollection,
   addDBEditorEndpoints,
+  visitEndpointOnAnotherServer,
   // Types
   ModalButtonType,
   ModalSize,
@@ -226,6 +233,7 @@ export {
   LogMetadataType,
   LogFunction,
   IntelliTableColumn,
+  DropdownItemType,
   // Component-specific-types
   PickableItem,
   DBEntry,

package/src/server/initLogCollection.ts

@@ -14,6 +14,11 @@ const initLogCollection = (Collection: any) => {
         'context',
         'subcontext',
         'tags',
+        'year',
+        'month',
+        'day',
+        'hour',
+        'type',
       ],
     },
   );

package/src/server/initServer.ts

@@ -246,12 +246,14 @@ const initServer = (
       paramTypes: {
         year: ParamType.Int,
         month: ParamType.Int,
+        pageNumber: ParamType.Int,
       },
       handler: async ({ params }) => {
         // Get user info
         const {
           year,
           month,
+          pageNumber,
           userId,
           isAdmin,
         } = params;
@@ -266,13 +268,17 @@ const initServer = (
         }
 
         // Query for logs
-        const logs: Log[] = await _logCollection.find({
-          year,
-          month,
+        const response = await _logCollection.findPaged({
+          query: {
+            year,
+            month,
+          },
+          perPage: 1000,
+          pageNumber,
         });
 
-        // Return logs
-        return logs;
+        // Return response
+        return response;
       },
     }),
   );

package/src/types/DropdownItemType.ts

@@ -0,0 +1,11 @@
+// Types of dropdown items
+enum DropdownItemType {
+  // Dropdown header
+  Header = 'Header',
+  // Dropdown divider
+  Divider = 'Divider',
+  // Dropdown item
+  Item = 'Item',
+}
+
+export default DropdownItemType;

package/src/types/ModalType.tsx

@@ -4,6 +4,7 @@
  */
 enum ModalType {
   Okay = 'okay', // [Okay]
+  Cancel = 'cancel', // [Cancel]
   OkayCancel = 'okay-cancel', // [Okay] [Cancel]
   YesNo = 'yes-no', // [Yes] [No]
   YesNoCancel = 'yes-no-cancel', // [Yes] [No] [Cancel]

package/src/types/ReactKitErrorCode.tsx

@@ -1,4 +1,4 @@
-// Highest error code = DRK13
+// Highest error code = DRK18
 
 /**
  * List of error codes built into the react kit
@@ -10,6 +10,8 @@ enum ReactKitErrorCode {
   SessionExpired = 'DRK3',
   MissingParameter = 'DRK4',
   InvalidParameter = 'DRK5',
+  HostNotAllowed = 'DRK17',
+  HostBanned = 'DRK18',
   WrongCourse = 'DRK6',
   NoCACCLSendRequestFunction = 'DRK7',
   NoCACCLGetLaunchInfoFunction = 'DRK8',
@@ -18,6 +20,11 @@ enum ReactKitErrorCode {
   NotAllowedToReviewLogs = 'DRK11',
   ThemeCheckedBeforeReactKitReady = 'DRK12',
   SessionExpiredMessageGottenBeforeReactKitReady = 'DRK13',
+
+  // Server-to-server requests
+  NotConnected = 'DRK14',
+  SelfSigned = 'DRK15',
+  ResponseParseError = 'DRK16',
 }
 
 export default ReactKitErrorCode;