comprodls-sdk 2.36.0 → 2.37.0

package/dist/comprodls-sdk.js

@@ -4077,6 +4077,7 @@ function auth() {
     pisImport: pisImport.bind(this),
 
     getAllUsers: getAllUsers.bind(this),
+    getAllUsersV2: getAllUsersV2.bind(this),
     getUserProfile: getUserProfile.bind(this),
     deleteUserProfile: deleteUserProfile.bind(this),
     updateUserRole: updateUserRole.bind(this),
@@ -4390,6 +4391,218 @@ function getAllUsers(options) {
   return dfd.promise;
 }
 
+/**
+ * This function is used to fetch all the users of a particular org.
+ * Params:
+ * {
+ *   role: 'string'              // Optional
+ *   lookup: 'string',           // Optional. Search query (',' separated key-value pairs)
+ *   lookup-operator: 'string',  // Optional. Default - 'OR'. Permitted values - [OR]
+ *   sortField: 'string',        // Default - 'last_name'.
+ *   sortOrder: 'string',        // Default - 'desc'. Permitted values - [desc, asc]
+ *   limit: number,              // Optional. Default - 10
+ *   cursor: '<cursor>'          // Optional
+ * }
+ * @param {*} options
+ */
+function  getAllUsersV2(options) {
+  var self = this;
+
+  // Initializing promise
+  var deferred = q.defer();
+
+  // Validations
+  var error = helpers.validations.isAuthenticated(self.orgId, self.token);
+  if (error) {
+    deferred.reject(error);
+  } else {
+    // Initialize query object.
+    var queryObject = {
+      query: { bool: { must: [] } },
+      size: options.limit || 10     // (DEFAULT) ES returns only 10 elements at max.
+    };
+
+    // Prepare query_string for fetching all the users of a particular school (org).
+    var queryStr = 'orgid:"' + self.orgId + '"';
+
+    // Update the query_string to filter the users based on their user-role.
+    if (options.role) {
+      var roleNameString, roleNameArray;
+
+      roleNameString = options.role;
+      roleNameArray = roleNameString.split(',').map(function (item) {
+        return item.trim();
+      });
+
+      for (var idx in roleNameArray) {
+        roleNameArray[idx] = 'roles:' + roleNameArray[idx];
+      }
+      queryStr = queryStr + ' AND (' + roleNameArray.join(' OR ') + ')';
+    }
+
+    // Update the queryObject with the query_string.
+    queryObject.query.bool.must.push({
+      query_string: { query: queryStr }
+    });
+
+    // Update the queryObject to filter the users based on lookup's key-value pairs.
+    if (options.lookup && options['lookup-operator']) {
+      var lookupString, lookupArray;
+
+      // Update the 'lookupString' to remove the prefix 'ext_' from keys of the key-value pairs.
+      lookupString = options.lookup.replace(/ext_/ig, '');
+      lookupArray = lookupString.split(',');
+
+      // Iterate over all the key-value pairs and prepare lookupOptions.
+      var lookupOptions = { bool: {} };
+      for (var index in lookupArray) {
+        var lookupItem = lookupArray[index].trim(),
+          tempArr = lookupItem.split(':'),
+          lookupObject = { wildcard: {} },
+          lookupKey, lookupValue;
+
+        /**
+         * The suffix '.keyword' is ONLY required for fields of type 'string'.
+         * Note: Currently lookup is ONLY supported for fields of type 'string'.
+         */
+        lookupKey = tempArr[0] + '.keyword';
+        lookupValue = tempArr[1];
+
+        // Case-insensitive lookup is currently ONLY SUPPORTED on the field 'ext_email'.
+        if (lookupKey === 'email.keyword') {
+          lookupObject.wildcard[lookupKey] = { value: lookupValue, case_insensitive: true };
+        } else {
+          lookupObject.wildcard[lookupKey] = { value: lookupValue, case_insensitive: false };
+        }
+
+        if (options['lookup-operator'] === 'OR') {
+          if (!lookupOptions.bool.should) { lookupOptions.bool.should = []; }
+          lookupOptions.bool.should.push(lookupObject);
+        } else {
+          /**
+           * If the 'lookup-operator' is 'AND', use the 'must' clause.
+           * Note: This value is currently NOT SUPPORTED.
+           * Prepare error and reject the request.
+           */
+          var errMsg = 'The value \'AND\' for the field \'lookup-operator\' is currently NOT supported';
+          error = {};
+          error.message = error.description = errMsg;
+          error = new DLSError(helpers.errors.ERROR_TYPES.SDK_ERROR, error);
+
+          deferred.reject(error);
+          return deferred.promise;
+        }
+      }
+      queryObject.query.bool.must.push(lookupOptions);
+    }
+
+    // Update the queryObject to sort the results based on sortField / sortOrder.
+    var sortField, sortOrder, sortObj = {}, sortArr = [];
+    sortField = options.sortField || 'last_name';
+    sortOrder = options.sortOrder || 'asc';
+
+    // Update the sortField to remove prefix: 'ext_' and trim any unnecessary whitespaces.
+    sortField = sortField.replace(/ext_/ig, '').split(',').shift().trim();
+    if (sortField !== 'created') {
+      sortField = sortField + '.keyword';
+    }
+
+    sortObj[sortField] = sortOrder;
+    sortArr.push(sortObj);
+    queryObject.sort = sortArr;
+
+    // Update the queryObject to fetch the next set of records from ES.
+    if (options.cursor) {
+      queryObject.search_after = JSON.parse(options.cursor);
+    }
+
+    // Passed all validations, Construct API URL
+    var url = self.config.DEFAULT_HOSTS.INTEGRATION + self.config.INTEGRATIONS_API_URLS.queryDataFromSearch;
+    url = helpers.api.constructAPIUrl(url, { index: 'users' });
+
+    // Setup request with URL and Params
+    var params = { query: JSON.stringify(queryObject)};
+    var requestAPI = request.get(url).query(params);
+    if (self.traceid) {
+      requestAPI.set('X-Amzn-Trace-Id', self.traceid);
+    }
+
+    // Setup token in Authorization header
+    requestAPI = helpers.api.setupAPIToken(requestAPI, self.token);
+
+    // Call the ES API to fetch users from ES.
+    requestAPI.end(function (err, response) {
+      if (err) {
+        // Prepare and send error response.
+        var esErrOptions = { type: helpers.errors.ERROR_TYPES.API_ERROR, err: err },
+          error = converter.convertElasticsearchErrResponse(esErrOptions);
+
+        deferred.reject(error);
+      } else {
+        // Prepare and send success response.
+        var responseObject = {
+          entities: [], count: response.body.hits.hits.length
+        };
+
+        if (responseObject.count && options.limit === responseObject.count) {
+          var cursor = response.body.hits.hits[response.body.hits.hits.length - 1].sort;
+          responseObject.cursor = JSON.stringify(cursor);
+        }
+
+        for (var index in response.body.hits.hits) {
+          var userEntity = response.body.hits.hits[index]._source,
+            userObj = {
+              uuid: userEntity.dls_user_id,
+              name: userEntity.first_name + ' ' + userEntity.last_name,
+              email: userEntity.email || userEntity.ext_email,
+              username: userEntity.userid + '--ACCOUNT',
+              created: userEntity.created,
+              org: { id: self.orgId }
+            };
+
+          if (userEntity.roles) {
+            userObj.roles = userEntity.roles;
+          }
+
+          if (userEntity.provision_method) {
+            userObj.provision_method = userEntity.provision_method;
+          }
+
+          if (userEntity.first_name) {
+            userObj.first_name = userEntity.first_name;
+          }
+
+          if (userEntity.last_name) {
+            userObj.last_name = userEntity.last_name;
+          }
+
+          if (userEntity.ext_parent_id) {
+            userObj.ext_parent_id = userEntity.ext_parent_id;
+          }
+
+          if (userEntity.username) {
+            userObj.ext_username = userEntity.username;
+          }
+
+          if (userEntity.userid) {
+            userObj.ext_user_id = userEntity.userid;
+          }
+
+          if (userEntity.address) {
+            userObj.address = userEntity.address;
+          }
+
+          responseObject.entities.push(userObj);
+        }
+
+        deferred.resolve(responseObject);
+      }
+    });
+  }
+
+  return deferred.promise;
+}
+
 //options = {
 //    userid: 'dlsUserId',  //mandatory
 //    target_role: 'string', //mandatory