@availity/api-core - npm Package Compare versions

Comparing version 6.2.6 to 6.3.0

CHANGELOG.md

@@ -6,2 +6,13 @@ # Change Log
 
+# [6.3.0](https://github.com/Availity/sdk-js/compare/@availity/api-core@6.2.6...@availity/api-core@6.3.0) (2020-05-11)
+
+
+### Features
+
+* **api-core:** add support for filtering organizations by permission and resource ([b607943](https://github.com/Availity/sdk-js/commit/b607943c9908d7d684013ec18678a1c05b9f1baf))
+
+
+
+
+
 ## 6.2.6 (2020-05-01)
@@ -8,0 +19,0 @@

lib/resources/organizations.js

@@ -10,2 +10,8 @@ "use strict";
 
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
@@ -17,2 +23,6 @@
 
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+
 var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
@@ -36,2 +46,3 @@
         avUsers = _ref.avUsers,
+        avUserPermissions = _ref.avUserPermissions,
         config = _ref.config;
@@ -49,6 +60,11 @@ (0, _classCallCheck2["default"])(this, AvOrganizations);
     });
+    _this.previousPermissionIds = [];
+    _this.previousRegionId = '';
+    _this.userPermissions = [];
     _this.avUsers = avUsers;
+    _this.avUserPermissions = avUserPermissions;
     return _this;
-  }
+  } // Instance variables to help with caching for filtered organizations
 
+
   (0, _createClass2["default"])(AvOrganizations, [{
@@ -79,2 +95,180 @@ key: "queryOrganizations",
     }
+  }, {
+    key: "postGet",
+    value: function () {
+      var _postGet = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(data, config, additionalPostGetArgs) {
+        var _yield$_get$call, organizationsData;
+
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (!additionalPostGetArgs) {
+                  _context.next = 6;
+                  break;
+                }
+
+                _context.next = 3;
+                return (0, _get2["default"])((0, _getPrototypeOf2["default"])(AvOrganizations.prototype), "postGet", this).call(this, data, config);
+
+              case 3:
+                _yield$_get$call = _context.sent;
+                organizationsData = _yield$_get$call.data;
+                return _context.abrupt("return", this.getFilteredOrganizations(organizationsData, additionalPostGetArgs, data));
+
+              case 6:
+                return _context.abrupt("return", (0, _get2["default"])((0, _getPrototypeOf2["default"])(AvOrganizations.prototype), "postGet", this).call(this, data, config));
+
+              case 7:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function postGet(_x, _x2, _x3) {
+        return _postGet.apply(this, arguments);
+      }
+
+      return postGet;
+    }()
+  }, {
+    key: "getFilteredOrganizations",
+    value: function () {
+      var _getFilteredOrganizations = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(organizationsData, additionalPostGetArgs, data) {
+        var resourceIds, permissionId, region, organizations, orgLimit, orgOffset, totalOrgCount, resourceIdsArray, _yield$this$avUserPer, userPermissions, authorizedOrgs, authorizedFilteredOrgs;
+
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                resourceIds = additionalPostGetArgs.resourceIds;
+                permissionId = data.permissionId, region = data.region;
+                organizations = organizationsData.organizations, orgLimit = organizationsData.limit, orgOffset = organizationsData.offset, totalOrgCount = organizationsData.totalCount;
+
+                if (!(typeof permissionId !== 'string' && !Array.isArray(permissionId))) {
+                  _context2.next = 5;
+                  break;
+                }
+
+                throw new TypeError('permissionId must be either an array of ids or a string');
+
+              case 5:
+                if (!(typeof resourceIds !== 'string' && !Array.isArray(resourceIds))) {
+                  _context2.next = 7;
+                  break;
+                }
+
+                throw new TypeError('resourceIds must be either an array of ids or a string');
+
+              case 7:
+                // resourceIds is passed as readOnly, convert so that we can use Array methods on it
+                resourceIdsArray = typeof resourceIds === 'string' ? [resourceIds] : resourceIds;
+
+                if (!(region !== this.previousRegionId || !this.arePermissionsEqual(permissionId))) {
+                  _context2.next = 20;
+                  break;
+                }
+
+                _context2.next = 11;
+                return this.avUserPermissions.postGet({
+                  permissionId: permissionId,
+                  region: region,
+                  limit: permissionId.length
+                });
+
+              case 11:
+                _yield$this$avUserPer = _context2.sent;
+                userPermissions = _yield$this$avUserPer.data.axiUserPermissions;
+
+                if (!userPermissions) {
+                  _context2.next = 19;
+                  break;
+                }
+
+                this.userPermissions = userPermissions;
+                this.previousPermissionIds = permissionId;
+                this.previousRegionId = region;
+                _context2.next = 20;
+                break;
+
+              case 19:
+                throw new Error('avUserPermissions call failed');
+
+              case 20:
+                // Reduce the userPermissions result into a collection of orgs that contain a valid resource
+                authorizedOrgs = this.userPermissions.reduce(function (accum, userPermission) {
+                  userPermission.organizations.forEach(function (userOrg) {
+                    var isDuplicate = accum.some(function (item) {
+                      return item.id === userOrg.id;
+                    });
+
+                    if (!isDuplicate) {
+                      // If this org contains one of the passed in resourceIds, it is an authorized org
+                      var match = userOrg.resources.some(function (userResource) {
+                        return resourceIdsArray.some(function (resource) {
+                          return Number(resource) === Number(userResource.id);
+                        });
+                      });
+
+                      if (match) {
+                        accum.push({
+                          id: userOrg.id
+                        });
+                      }
+                    }
+                  });
+                  return accum;
+                }, []); // avUserPermissions call doesn't return much useful organization data
+                // but we can match valid ids to useful data returned from avOrganizations
+
+                authorizedFilteredOrgs = organizations.filter(function (org) {
+                  return authorizedOrgs.some(function (authorizedOrg) {
+                    return authorizedOrg.id === org.id;
+                  });
+                }); // Transform back into data object that ResourceSelect can use and paginate
+
+                return _context2.abrupt("return", {
+                  data: {
+                    authorizedFilteredOrgs: authorizedFilteredOrgs,
+                    totalCount: totalOrgCount,
+                    limit: orgLimit,
+                    offset: orgOffset
+                  }
+                });
+
+              case 23:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function getFilteredOrganizations(_x4, _x5, _x6) {
+        return _getFilteredOrganizations.apply(this, arguments);
+      }
+
+      return getFilteredOrganizations;
+    }()
+  }, {
+    key: "arePermissionsEqual",
+    value: function arePermissionsEqual(permissionId) {
+      if (typeof permissionId !== typeof this.previousPermissionIds) return false;
+      if (typeof permissionId === 'string') return permissionId === this.previousPermissionIds;
+
+      if (Array.isArray(permissionId) && Array.isArray(this.previousPermissionIds)) {
+        if (permissionId.length !== this.previousPermissionIds.length) return false; // if lengths are equal, need a way to check if values are the same or not
+        // Sets won't allow duplicate values
+        // if size of Set is greater than length of original arrays
+        // then a different value was inserted and they are not equal
+
+        var idSet = new Set((0, _toConsumableArray2["default"])(permissionId), (0, _toConsumableArray2["default"])(this.previousPermissionIds));
+        if (idSet.size !== permissionId.length) return false;
+        return true;
+      }
+
+      return false;
+    }
   }]);
@@ -81,0 +275,0 @@ return AvOrganizations;

package.json

 {
   "name": "@availity/api-core",
-  "version": "6.2.6",
+  "version": "6.3.0",
   "description": "Base API definitions for the Availity REST API",
@@ -24,3 +24,3 @@ "keywords": [
   },
-  "gitHead": "a15f93a4b6ffb150feddcbb0ea1113b9ade628bb"
+  "gitHead": "f6de97e3e88bc33e29ffd2fba2d78f6d144a02a2"
 }

src/resources/organizations.js

 import AvApi from '../api';
 
 export default class AvOrganizations extends AvApi {
-  constructor({ http, promise, merge, avUsers, config }) {
+  constructor({ http, promise, merge, avUsers, avUserPermissions, config }) {
     const options = {
@@ -18,4 +18,12 @@ path: 'api/sdk/platform',
     this.avUsers = avUsers;
+    this.avUserPermissions = avUserPermissions;
   }
 
+  // Instance variables to help with caching for filtered organizations
+  previousPermissionIds = [];
+
+  previousRegionId = '';
+
+  userPermissions = [];
+
   queryOrganizations(user, config) {
@@ -39,2 +47,137 @@ const queryConfig = this.addParams({ userId: user.id }, config);
   }
+
+  async postGet(data, config, additionalPostGetArgs) {
+    if (additionalPostGetArgs) {
+      const { data: organizationsData } = await super.postGet(data, config);
+
+      return this.getFilteredOrganizations(
+        organizationsData,
+        additionalPostGetArgs,
+        data
+      );
+    }
+
+    // Else return normal organizations call
+    return super.postGet(data, config);
+  }
+
+  async getFilteredOrganizations(
+    organizationsData,
+    additionalPostGetArgs,
+    data
+  ) {
+    const { resourceIds } = additionalPostGetArgs;
+    const { permissionId, region } = data;
+    const {
+      organizations,
+      limit: orgLimit,
+      offset: orgOffset,
+      totalCount: totalOrgCount,
+    } = organizationsData;
+
+    if (typeof permissionId !== 'string' && !Array.isArray(permissionId)) {
+      throw new TypeError(
+        'permissionId must be either an array of ids or a string'
+      );
+    }
+    if (typeof resourceIds !== 'string' && !Array.isArray(resourceIds)) {
+      throw new TypeError(
+        'resourceIds must be either an array of ids or a string'
+      );
+    }
+
+    // resourceIds is passed as readOnly, convert so that we can use Array methods on it
+    const resourceIdsArray =
+      typeof resourceIds === 'string' ? [resourceIds] : resourceIds;
+
+    if (
+      region !== this.previousRegionId ||
+      !this.arePermissionsEqual(permissionId)
+    ) {
+      // avUserPermissions will return a list of user organizations that match given permission and region
+      // This call does not need to be paginated and
+      // we should not need to call it every time we paginate orgs if region and permissions are the same
+      // Limit is set to permissionId.length because that represents maximum results we can get back
+      const {
+        data: { axiUserPermissions: userPermissions },
+      } = await this.avUserPermissions.postGet({
+        permissionId,
+        region,
+        limit: permissionId.length,
+      });
+
+      if (userPermissions) {
+        this.userPermissions = userPermissions;
+        this.previousPermissionIds = permissionId;
+        this.previousRegionId = region;
+      } else {
+        throw new Error('avUserPermissions call failed');
+      }
+    }
+
+    // Reduce the userPermissions result into a collection of orgs that contain a valid resource
+    const authorizedOrgs = this.userPermissions.reduce(
+      (accum, userPermission) => {
+        userPermission.organizations.forEach(userOrg => {
+          const isDuplicate = accum.some(item => item.id === userOrg.id);
+          if (!isDuplicate) {
+            // If this org contains one of the passed in resourceIds, it is an authorized org
+            const match = userOrg.resources.some(userResource => {
+              return resourceIdsArray.some(
+                resource => Number(resource) === Number(userResource.id)
+              );
+            });
+            if (match) {
+              accum.push({ id: userOrg.id });
+            }
+          }
+        });
+
+        return accum;
+      },
+      []
+    );
+
+    // avUserPermissions call doesn't return much useful organization data
+    // but we can match valid ids to useful data returned from avOrganizations
+    const authorizedFilteredOrgs = organizations.filter(org =>
+      authorizedOrgs.some(authorizedOrg => authorizedOrg.id === org.id)
+    );
+
+    // Transform back into data object that ResourceSelect can use and paginate
+    return {
+      data: {
+        authorizedFilteredOrgs,
+        totalCount: totalOrgCount,
+        limit: orgLimit,
+        offset: orgOffset,
+      },
+    };
+  }
+
+  arePermissionsEqual(permissionId) {
+    if (typeof permissionId !== typeof this.previousPermissionIds) return false;
+
+    if (typeof permissionId === 'string')
+      return permissionId === this.previousPermissionIds;
+
+    if (
+      Array.isArray(permissionId) &&
+      Array.isArray(this.previousPermissionIds)
+    ) {
+      if (permissionId.length !== this.previousPermissionIds.length)
+        return false;
+
+      // if lengths are equal, need a way to check if values are the same or not
+      // Sets won't allow duplicate values
+      // if size of Set is greater than length of original arrays
+      // then a different value was inserted and they are not equal
+      const idSet = new Set([...permissionId], [...this.previousPermissionIds]);
+      if (idSet.size !== permissionId.length) return false;
+
+      return true;
+    }
+
+    return false;
+  }
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

136475

increased by10.7%

Lines of code

3057

increased by10.08%

No dependency changes