Name

sn_collab_request.CollabTaskServiceV2

Description

No description available

Script

var CollabTaskServiceV2 = (function() {
  return {
      /*
      	Generates collaboration task record for the passed user or group data
      */
      inviteCollaborators: function(usersIds, groupsIds, appId, descriptorId) {
          var statusCodes = CollabTaskConstants.statusCodes;

          var appManagementData = AppManagementDataUtil.getCurrentUserData(appId);
          var validDescriptor = appManagementData.inviteDescriptorsFilter.length === 0 || appManagementData.inviteDescriptorsFilter.indexOf(descriptorId) > -1;

          if ((appManagementData.canUserManageCollaborators || appManagementData.canUserInviteCollaborators) && validDescriptor) {
              // for each of the collaborator create collaboration task
              try {
                  var collabControllerUtils = new CollabControllerUtils();
              } catch (e) {
                  throw new sn_ws_err.ServiceError()
                      .setStatus(404)
                      .setMessage(gs.getMessage("Valid controller is not found"))
                      .setDetail(e);
              }

              var collabRequestUtils = new CollabReqUtils();
              var redirectToController = !collabControllerUtils.isCurrentInstanceController() && collabControllerUtils.isControllerConfigured;
              var collabTaskRecords = [];
              var userInsertResponse = [];

              (usersIds || []).forEach(function(userId) {
                  if (redirectToController) {
                      // generate collaboration task record for user by sending the second param as false into the util
                      var userCollabTaskResponse = CollabTaskUtils.generateCollaborationTaskRecord(userId, false, appId, descriptorId, false);
                      var collabTaskObject = collabRequestUtils.getObjectFromGlideRecord(userCollabTaskResponse.collaborationTaskRecord);
                      collabTaskRecords.push(collabTaskObject);
                  } else {
                      var insertResponse = CollabTaskUtils.generateCollaborationTaskRecord(userId, false, appId, descriptorId, true);

                      userInsertResponse.push(insertResponse);
                  }
              });

              var groupInsertResponse = [];

              (groupsIds || []).forEach(function(groupId) {
                  if (redirectToController) {
                      // genrate collaboration task record for group by sending the second param as true into the util
                      var groupCollabTaskResponse = CollabTaskUtils.generateCollaborationTaskRecord(groupId, true, appId, descriptorId, false);
                      var collabTaskObject = collabRequestUtils.getObjectFromGlideRecord(groupCollabTaskResponse.collaborationTaskRecord);
                      collabTaskRecords.push(collabTaskObject);
                  } else {
                      var insertResponse = CollabTaskUtils.generateCollaborationTaskRecord(groupId, true, appId, descriptorId, true);

                      groupInsertResponse.push(insertResponse);
                  }
              });

              if (collabTaskRecords.length) {
                  try {
                      var controllerResult = CollabTaskUtils
                          .createCollaborationTaskRecordsInController(collabTaskRecords, collabControllerUtils.getControllerRecord());
                      userInsertResponse = controllerResult.users;
                      groupInsertResponse = controllerResult.groups;

                  } catch (e) {
                      throw new sn_ws_err.ServiceError()
                          .setStatus(500)
                          .setMessage(gs.getMessage("Something went wrong when creating collaboration requests in controller"))
                          .setDetail(e.message || gs.getMessage("Unknown error when posting task records to controller environment"));
                  }
              }

              return {
                  body: {
                      descriptorId: descriptorId,
                      appId: appId,
                      users: userInsertResponse,
                      groups: groupInsertResponse
                  },
                  status: statusCodes.SUCCESS
              };
          } else {
              throw new sn_ws_err.ServiceError()
                  .setStatus(statusCodes.FORBIDDEN)
                  .setMessage(gs.getMessage('User does not have permission to invite collaborators to app with Id {0}.', appId));
          }
      },

      getPendingCollaborators: function(appId) {
          var statusCodes = CollabTaskConstants.statusCodes;

          if (!UserDelegatedDevPermissions.canUserReadApp(appId)) {
              throw new sn_ws_err.ServiceError()
                  .setStatus(statusCodes.FORBIDDEN)
                  .setMessage(gs.getMessage('403 Forbidden: User does not have access to app with id {0}.', appId));
          }

          var appManagementData = AppManagementDataUtil.getCurrentUserData(appId);

          if (appManagementData.readOnlyMode) {
              throw new sn_ws_err.ServiceError()
                  .setStatus(statusCodes.FORBIDDEN)
                  .setMessage(gs.getMessage('403 Forbidden: User does not have permission to read pending collaboration tasks for the app with id {0}.', appId));
          }

          try {
              var collabControllerUtils = new CollabControllerUtils();
          } catch (e) {
              throw new sn_ws_err.ServiceError()
                  .setStatus(404)
                  .setMessage(gs.getMessage("Valid controller is not found"))
                  .setDetail(e);
          }

          var redirectToController = !collabControllerUtils.isCurrentInstanceController() && collabControllerUtils.isControllerConfigured;
          var recordState = CollabTaskConstants.collabTaskStates;
          var collabTasksInScope = [];

          if (redirectToController) {
              try {
                  var getCollabTasksOutput = CollabTaskUtils.getCollaborationTaskRecordsFromController(appId, recordState.NEW, collabControllerUtils.getControllerRecord());

              } catch (e) {
                  throw new sn_ws_err.ServiceError()
                      .setStatus(500)
                      .setMessage(gs.getMessage("Something went wrong when fetching collaboration requests from controller"))
                      .setDetail(e.message || e || gs.getMessage("Unknown error when fetching task records from controller environment"));
              }

              if (getCollabTasksOutput.hasError) {
                  throw new sn_ws_err.ServiceError()
                      .setStatus(getCollabTasksOutput.statusCode)
                      .setMessage(gs.getMessage("Something went wrong when fetching collaboration requests from controller"))
                      .setDetail(getCollabTasksOutput.errorMessage);
              }

              collabTasksInScope = getCollabTasksOutput.collabTasksInScope;
          } else {
              collabTasksInScope = CollabTaskUtils.getCollaborationRequestsInScope(appId, recordState.NEW);
          }

          return {
              body: {
                  appId: appId,
                  collabTasks: collabTasksInScope
              },
              status: statusCodes.SUCCESS
          };
      }
  };
})();

Sys ID

97af8a5dc7f33010408bc8d6f2c2607f

Offical Documentation

Official Docs: