@live-change/access-control-service 0.8.118 → 0.8.120

package/invite.js

@@ -2,6 +2,7 @@ import App from '@live-change/framework'
 const app = App.app()
 import definition from './definition.js'
 const config = definition.config
+import pluralize from 'pluralize'
 
 const inviteMessageActionByObjectType = config.inviteMessageActionByObjectType ?? {}
 
@@ -190,6 +191,9 @@ definition.action({
   }
 })
 
+import task from '@live-change/task-service/task.ts' // need to import taks.js to avoid circular dependency
+
+
 for(const contactType of config.contactTypes) {
 
   const contactTypeUpperCaseName = contactType[0].toUpperCase() + contactType.slice(1)
@@ -206,6 +210,52 @@ for(const contactType of config.contactTypes) {
     }
   }
 
+  async function doInvite(contact, objectType, object, invitationData, emit, trigger = app.trigger) {
+    const contactData = await app.viewGet('get' + contactTypeUName, { [contactType]: contact })
+    if(contactData?.user) { // user exists
+      const { user } = contactData
+      await trigger({ type: 'notify' }, {
+        sessionOrUserType: 'user_User',
+        sessionOrUser: user,
+        notificationType: 'accessControl_Invitation',
+        objectType,
+        object,
+        ...invitationData, id: undefined
+      })
+      emit({
+        type: 'userInvited',
+        user,
+        objectType, object,
+        ...invitationData, id: undefined
+      })
+      return 'userInvited'
+    } else {
+      // Authenticate with message because we will create account later
+      const messageData = {
+        objectType, object,
+        ...invitationData, id: undefined,
+        action: inviteMessageActionByObjectType[objectType] ?? 'inviteWithMessage'
+      }
+      await trigger({ type: 'authenticateWithMessage' }, {
+        contactType,
+        contact,
+        messageData,
+        action: 'inviteWithMessage',
+        actionProperties: { objectType, object },
+        targetPage: { name: 'accessControl:invitationAccepted', params: { objectType, object } },
+        fallbackPage: { name: 'accessControl:invitationFallback', params: { objectType, object } }
+      })
+      emit({
+        type: 'contactInvited',
+        contactType: contactTypeName + '_' + contactTypeUName,
+        contact,
+        objectType, object,
+        ...invitationData, id: undefined
+      })
+      return 'contactInvited'
+    }
+  }
+
   definition.action({
     name: 'invite' + contactTypeUpperCaseName,
     waitForEvents: true,
@@ -221,9 +271,9 @@ for(const contactType of config.contactTypes) {
       ...contactTypeProperties,
       ...invitationProperties
     },
-    access: (params, { client, context, visibilityTest }) =>
+    access: (params, { client, context, visibilityTest}) =>
         visibilityTest || access.clientCanInvite(client, params),
-    async execute(params, { client, service }, emit) {
+    async execute(params, { client, service, trigger  }, emit) {
       const { [contactTypeName]: contact } = params
       const { objectType, object } = params
       const { roles } = params
@@ -236,52 +286,131 @@ for(const contactType of config.contactTypes) {
       }
 
       const [ fromType, from ] = client.user ? ['user_User', client.user] : ['session_Session', client.session]
-      const invitationData = { fromType, from }
+      const invitationData = { fromType, from, roles }
+      for(const propertyName in invitationProperties) invitationData[propertyName] = params[propertyName]
+      await doInvite(contact, objectType, object, invitationData, emit, trigger)
+    }
+  })
+
+  const inviteOneTask = task({
+    name: "invite" + contactTypeUpperCaseName,
+    properties: {
+      objectType: {
+        type: String,
+        validation: ['nonEmpty']
+      },
+      object: {
+        type: String,
+        validation: ['nonEmpty']
+      },
+      fromType: {
+        type: String,
+        validation: ['nonEmpty']
+      },
+      from: {
+        type: String,
+        validation: ['nonEmpty']
+      },
+      ...contactTypeProperties,
+      ...invitationProperties
+    },
+    maxRetries: 1,
+    async execute(params, { service, task }, emit) {
+      const { [contactTypeName]: contact } = params
+      const { objectType, object } = params
+      const { roles } = params
+      const { fromType, from } = params
+      const invitationData = { fromType, from, roles }
+      return await doInvite(contact, objectType, object, invitationData, emit, trigger)
+    }
+  }, definition)
+
+  const inviteManyTask = task({
+    name: "inviteMany" + contactTypeUpperCaseName,
+    properties: {
+      objectType: {
+        type: String,
+        validation: ['nonEmpty']
+      },
+      object: {
+        type: String,
+        validation: ['nonEmpty']
+      },
+      fromType: {
+        type: String,
+        validation: ['nonEmpty']
+      },
+      from: {
+        type: String,
+        validation: ['nonEmpty']
+      },
+      ...invitationProperties,
+      contacts: {
+        type: Array,
+        of: {
+          type: Object,
+          properties: contactTypeProperties
+        }
+      }
+    },
+    async execute(params, { service, task }, emit) {
+      const { objectType, object } = params
+      const { roles } = params
+      const { fromType, from } = params
+      const invitationData = { fromType, from, roles }
       for(const propertyName in invitationProperties) invitationData[propertyName] = params[propertyName]
+      for(const contact of params.contacts) {
+        try {
+          await doInvite(contact[contactTypeName], objectType, object, invitationData, emit, trigger)
+        } catch(e) {
+          // ignore errors
+        }
+      }
+    }
+  }, definition)
 
-      const contactData = (await service.trigger({ type: 'get' + contactTypeUName + 'OrNull'  }, {
-        [contactType]: contact,
-      }))[0]
-      if(contactData?.user) { // user exists
-        const { user } = contactData
-        await service.trigger({ type: 'notify'  }, {
-          sessionOrUserType: 'user_User',
-          sessionOrUser: user,
-          notificationType: 'accessControl_Invitation',
-          objectType,
-          object,
-          ...invitationData, id: undefined
-        })
-        emit({
-          type: 'userInvited',
-          user,
-          objectType, object,
-          ...invitationData, id: undefined
-        })
-      } else {
-        // Authenticate with message because we will create account later
-        const messageData = {
-          objectType, object,
-          ...invitationData, id: undefined,
-          action: inviteMessageActionByObjectType[objectType] ?? 'inviteWithMessage',
+  definition.action({
+    name: 'inviteMany' + pluralize(contactTypeUpperCaseName),
+    waitForEvents: true,
+    properties: {
+      objectType: {
+        type: String,
+        validation: ['nonEmpty']
+      },
+      object: {
+        type: String,
+        validation: ['nonEmpty']
+      },
+      ...invitationProperties,
+      contacts: {
+        type: Array,
+        of: {
+          type: Object,
+          properties: contactTypeProperties
         }
-        await service.trigger({ type: 'authenticateWithMessage'  }, {
-          contactType,
-          contact,
-          messageData,
-          action: 'inviteWithMessage',
-          actionProperties: { objectType, object },
-          targetPage: { name: 'accessControl:invitationAccepted', params: { objectType, object } },
-          fallbackPage: { name: 'accessControl:invitationFallback', params: { objectType, object } }
-        })
-        emit({
-          type: 'contactInvited',
-          contactType: contactTypeName + '_' + contactTypeUName,
-          contact,
-          objectType, object,
-          ...invitationData, id: undefined
-        })
       }
+    },
+    access: (params, { client, context, visibilityTest}) =>
+      visibilityTest || access.clientCanInvite(client, params),
+    async execute(params, { client, service, trigger, command  }, emit) {
+      const { [contactTypeName]: contact } = params
+      const { objectType, object } = params
+
+      const myRoles = await access.getClientObjectRoles(client, { objectType, object }, true)
+      if(!myRoles.includes('admin')) {
+        for(const requestedRole of roles) {
+          if(!myRoles.includes(requestedRole)) throw 'notAuthorized'
+        }
+      }
+
+      const [ fromType, from ] = client.user ? ['user_User', client.user] : ['session_Session', client.session]
+
+      await inviteManyTask.start({
+        ...params,
+        fromType, from,
+        ownerType: objectType,
+        owner: object,
+      }, 'action', command.id )
     }
   })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/access-control-service",
-  "version": "0.8.118",
+  "version": "0.8.120",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -21,8 +21,8 @@
     "url": "https://www.viamage.com/"
   },
   "dependencies": {
-    "@live-change/framework": "^0.8.118"
+    "@live-change/framework": "^0.8.120"
   },
-  "gitHead": "cfccde9b1d340cbb23df96a2f0fba72da0a6e3ab",
+  "gitHead": "adf31fd8365df0655d88293f96a93734058d3dd4",
   "type": "module"
 }