@capillarytech/cap-ui-utils 0.0.1 → 1.0.0

package/auth/AccessForbidden.js

@@ -0,0 +1,9 @@
+import React from 'react';
+
+const AccessForbidden = props => {
+  return (
+    <div>AccessForbidden AccessForbidden</div>
+  );
+};
+
+export default AccessForbidden;

package/auth/authHoc.js

@@ -0,0 +1,54 @@
+import React from 'react';
+import AccessForbidden from './AccessForbidden'
+import hasAccess from './hasAccess';
+import log from '../utils/console/log'
+
+const AUTHORIZE_OVERRIDE = 'capAuthAuthorized';
+
+const getPermissionToBeVerified = (options, props) => {
+    const { permission, permissionParamMatch, paramToBeAssessed } = options;
+    const { match = {} } = props;
+    const { params = {}} = match;
+    const param = params[paramToBeAssessed];
+    if (permission) {
+        return permission;
+    }
+    if (permissionParamMatch) {
+        return permissionParamMatch[param] || AUTHORIZE_OVERRIDE;
+    }
+    return undefined;
+}
+/**
+ * HOC to verify the authorize the component
+ * Authorization of a component can happen in two ways
+ * 1) By passing the permission option. If this value is passed, the entired component is accessed irrespective of location params
+ * 2) By passing permissionParamMatch and paramToBeAssessed, here you can authorize the component based on specific param value
+ * ex. Auth.authHoc(CampaignMessage, {
+ *      RedirectComponent: CampaignHomePage,
+ *      redirectPath: `${rootPath}/list`,
+ *      paramToBeAssessed: 'mode',
+ *      permissionParamMatch: {
+ *        create: 'somethig',
+ *      },
+ *   })
+ * @param {*} ComponentToBeVerified 
+ * @param {*} options 
+ */
+const withAuth = (ComponentToBeVerified, options = {}) => {
+    const getComponent = (permissionToBeVerified) => {
+        const { RedirectComponent } = options;
+        return (hasAccess(permissionToBeVerified) 
+                || permissionToBeVerified === AUTHORIZE_OVERRIDE) ? 
+                ComponentToBeVerified 
+                : 
+                (RedirectComponent || AccessForbidden);
+    }
+    const HOC = props => {
+      const permissionToBeVerified = getPermissionToBeVerified(options, props);
+      const VerifiedComponent = getComponent(permissionToBeVerified);
+      return <VerifiedComponent {...props} />;
+    };
+    return HOC;
+  };
+  
+  export default withAuth;

package/auth/hasAccess.js

@@ -0,0 +1,18 @@
+import warn from '../utils/console/warn';
+
+/**
+ * Function to check if the user has access to the permission
+ * @param {*} permission 
+ */
+export default function hasAccess(permission) {
+    if(!window.capAuth) {
+      warn("Cap auth not initialized. Please initialize cap auth to use this method");
+      return;
+    }
+    const { permissions } = window.capAuth;
+    //AOM is a universal action permission. 
+    // if (permissions.includes('AOM')) {
+    //   return true;
+    // }
+    return permissions.includes(permission);
+  }

package/auth/index.js

@@ -0,0 +1,68 @@
+/**
+ * UI Auth Module
+ * 
+ * @package @capillarytech/cap-ui-utils
+ * @author Rajshekar <rajshekar.venkatesh@capillarytech.com>
+ */
+
+import warn from '../utils/console/warn';
+import log from '../utils/console/log';
+import isEmpty from '../utils/isEmpty';
+import hasAccess from './hasAccess';
+import authHoc from './authHoc';
+
+/**
+ * Function to initialize the capAuth configurations to the document
+ * @param {*} authConfigs 
+ */
+function _initialize(authConfigs) {
+  const capAuth = {};
+  if (!authConfigs.permissions) {
+    warn("Cannot initialize auth without permissions");
+    return;
+  }
+  if(authConfigs.permissions) {
+    capAuth.permissions = Object.freeze(authConfigs.permissions);
+  }
+  if(authConfigs.orgFeatures) {
+    capAuth.orgFeatures = Object.freeze(authConfigs.orgFeatures);
+  }
+  log("Cap auth initialized");
+  window.capAuth = Object.freeze(capAuth);
+}
+
+/**
+ * Function to initialize Auth
+ * @param {
+ *  permissions, // Array of user permission
+ *  orgFeatures, // Array of org Features
+ * } authConfigs 
+ * @param authOptions
+ */
+function initialize(authConfigs, authOptions) {
+  log("Before initialize 1")
+  if (isEmpty(authConfigs)) {
+    warn("Cannot initialize empty object");
+    return;
+  }
+  for ( const config in authConfigs) {
+    if(typeof authConfigs[config] !== "object") {
+      warn("Config must be an object");
+      return;
+    }
+    if (isEmpty(authConfigs[config])) {
+      warn("Config is empty");
+      return;
+    }
+  }
+  log("Before initialize")
+  _initialize(authConfigs);
+  return true;
+}
+
+export default {
+  initialize,
+  hasAccess,
+  authHoc,
+}
+

package/index.js

@@ -1,3 +1 @@
-exports.testMsg = function() {
-    console.log("This is a message from the cap ui util library");
-  }
+export { default as Auth } from './auth';

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@capillarytech/cap-ui-utils",
-  "version": "0.0.1",
+  "version": "1.0.0",
   "description": "Utility functions shared accross all the modules",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "author": "Rajshekar"
+  "author": "Rajshekar",
+  "dependencies": {
+    "react": "^16.13.0"
+  }
 }

package/utils/console/log.js

@@ -0,0 +1,3 @@
+export default function log(msg) {
+    console.log('[cap-ui-utils]', msg);
+  }

package/utils/console/warn.js

@@ -0,0 +1,3 @@
+export default function log(msg) {
+    console.warn('[cap-ui-utils]', msg);
+  }

package/utils/isEmpty.js

@@ -0,0 +1,7 @@
+export default function isEmpty(obj) {
+    for(const key in obj) {
+        if(obj.hasOwnProperty(key))
+            return false;
+    }
+    return true;
+}