@live-change/access-control-service 0.2.24 → 0.2.27

package/access.js

@@ -4,16 +4,26 @@ module.exports = (definition) => {
   const Access = definition.foreignModel('access-control', 'Access')
   const PublicAccess = definition.foreignModel('access-control', 'PublicAccess')
 
-  function clientHasAnyAccess(client, toType, toId) {
+  function clientHasAnyAccess(client, { objectType, object }) {
     /// TODO: access control
     return true
   }
 
-  function clientHasAdminAccess(client, toType, toId) {
+  function clientHasAdminAccess(client, { objectType, object }) {
     /// TODO: access control
     return true
   }
 
-  return {clientHasAnyAccess, clientHasAdminAccess }
+  function clientCanInvite(client, { roles, objectType, object }) {
+    /// TODO: access control
+    return true
+  }
+
+  function clientCanRequest(client, { roles, objectType, object }) {
+    /// TODO: access control
+    return true
+  }
+
+  return { clientHasAnyAccess, clientHasAdminAccess, clientCanInvite, clientCanRequest }
 
 }

package/index.js

@@ -3,5 +3,6 @@ const app = require("@live-change/framework").app()
 const definition = require('./definition.js')
 
 require('./model.js')
+require('./invite.js')
 
 module.exports = definition

package/invite.js

@@ -0,0 +1,72 @@
+const app = require("@live-change/framework").app()
+const definition = require('./definition.js')
+const config = definition.config
+
+const { Invite, invitationProperties } = require('./model.js')
+const access = require('./access.js')(definition)
+
+for(const contactType of config.contactTypes) {
+
+  const contactTypeUpperCaseName = contactType[0].toUpperCase() + contactType.slice(1)
+
+  const contactConfig = (typeof contactType == "string") ? { name: contactType } : contactType
+
+  const contactTypeName = contactConfig.name
+  const contactTypeUName = contactTypeName[0].toUpperCase() + contactTypeName.slice(1)
+
+  const contactTypeProperties = {
+    [contactType]: {
+      type: String,
+      validation: ['nonEmpty', contactTypeName]
+    }
+  }
+
+  definition.action({
+    name: 'invite' + contactTypeUpperCaseName,
+    waitForEvents: true,
+    properties: {
+      objectType: {
+        type: String,
+        validation: ['nonEmpty']
+      },
+      object: {
+        type: String,
+        validation: ['nonEmpty']
+      },
+      ...contactTypeProperties,
+      ...invitationProperties
+    },
+    access: (params, { client, context, visibilityTest }) =>
+        visibilityTest || access.clientCanInvite(client, params),
+    async execute(params, { client, service }, emit) {
+      const { [contactTypeName]: contact } = params
+      const { objectType, object } = params
+      const invitationData = { }
+      for(const propertyName in invitationProperties) invitationData[propertyName] = params[propertyName]
+
+      const contactData = (await service.trigger({
+        type: 'get' + contactTypeUName + 'OrNull',
+        [contactType]: contact,
+      }))[0]
+      if(contactData?.user) { // user exists
+        /// TODO: Trigger notification
+        emit({
+          type: 'userInvited',
+          user: contactData.user,
+          objectType, object,
+          ...invitationData
+        })
+      } else {
+        /// TODO: Send message to contact
+        emit({
+          type: 'contactInvited',
+          contactType: contactTypeName + '_' + contactTypeUName,
+          contact,
+          objectType, object,
+          ...invitationData
+        })
+      }
+    }
+  })
+
+}

package/model.js

@@ -1,18 +1,20 @@
+const App = require("@live-change/framework")
+const app = App.app()
 const definition = require('./definition.js')
 const config = definition.config
 const access = require('./access.js')(definition)
 
 const Access = definition.model({
   name: 'Access',
-  sessionOrUserItem: {
-    ownerReadAccess: () => true
-  },
-  relatedToAny: {
-    to: 'object',
+  sessionOrUserProperty: {
+    extendedWith: ['object'],
+    ownerReadAccess: () => true,
     readAccess: (params, { client, context, visibilityTest }) =>
-        visibilityTest || access.clientHasAnyAccess(client, params.ownerType, params.owner),
-    writeAccess: (params, { client, context, visibilityTest }) =>
-        visibilityTest || access.clientHasAdminAccess(client, params.ownerType, params.owner)
+        visibilityTest || access.clientHasAnyAccess(client, params),
+    updateAccess: (params, { client, context, visibilityTest }) =>
+        visibilityTest || access.clientHasAdminAccess(client, params),
+    resetAccess: (params, { client, context, visibilityTest }) =>
+        visibilityTest || access.clientHasAdminAccess(client, params)
   },
   properties: {
     roles: {
@@ -34,9 +36,9 @@ const PublicAccess = definition.model({
   propertyOfAny: {
     to: 'object',
     readAccess: (params, { client, context, visibilityTest }) =>
-        visibilityTest || access.clientHasAnyAccess(client, params.ownerType, params.owner),
+        visibilityTest || access.clientHasAnyAccess(client, params),
     writeAccess: (params, { client, context, visibilityTest }) =>
-        visibilityTest || access.clientHasAdminAccess(client, params.ownerType, params.owner)
+        visibilityTest || access.clientHasAdminAccess(client, params)
   },
   properties: {
     userRoles: {
@@ -55,6 +57,14 @@ const PublicAccess = definition.model({
       },
       validation: ['elementsNonEmpty']
     },
+    availableRoles: {
+      type: Array,
+      of: {
+        type: String,
+        validation: ['nonEmpty']
+      },
+      validation: ['elementsNonEmpty']
+    },
     lastUpdate: {
       type: Date
     }
@@ -65,12 +75,16 @@ const PublicAccess = definition.model({
 
 const AccessRequest = definition.model({
   name: 'AccessRequest',
-  sessionOrUserItem: {
-  },
-  relatedToAny: {
-    to: 'object',
+  sessionOrUserProperty: {
+    extendedWith: ['object'],
+    ownerReadAccess: () => true,
+    ownerResetAccess: () => true,
     readAccess: (params, { client, context, visibilityTest }) =>
-        visibilityTest || access.clientHasAdminAccess(client, params.ownerType, params.owner)
+        visibilityTest || access.clientHasAnyAccess(client, params),
+    updateAccess: (params, { client, context, visibilityTest }) =>
+        visibilityTest || access.clientHasAdminAccess(client, params),
+    resetAccess: (params, { client, context, visibilityTest }) =>
+        visibilityTest || access.clientHasAdminAccess(client, params)
   },
   properties: {
     roles: {
@@ -90,33 +104,64 @@ const AccessRequest = definition.model({
   }
 })
 
-/*
-const AccessInvite = definition.model({
-  name: 'AccessInvite',
-  userOrContactItem: {},
-  relatedToAny: {
-    to: 'object',
-    readAccess: (params, {client, context, visibilityTest}) =>
-        visibilityTest || access.clientHasAdminAccess(client, params.ownerType, params.owner)
+const invitationProperties = {
+  roles: {
+    type: Array,
+    of: {
+      type: String,
+      validation: ['nonEmpty']
+    },
+    validation: ['elementsNonEmpty']
+  },
+  message: {
+    type: String,
+    validation: []
+  }
+}
+
+const AccessInvitation = definition.model({
+  name: 'AccessInvitation',
+  contactOrUserProperty: {
+    extendedWith: ['object'],
+    ownerReadAccess: () => true,
+    ownerResetAccess: () => true,
+    readAccess: (params, { client, context, visibilityTest }) =>
+        visibilityTest || access.clientHasAnyAccess(client, params),
+    updateAccess: (params, { client, context, visibilityTest }) =>
+        visibilityTest || access.clientHasAdminAccess(client, params),
+    resetAccess: (params, { client, context, visibilityTest }) =>
+        visibilityTest || access.clientHasAdminAccess(client, params)
   },
   properties: {
-    roles: {
-      type: Array,
-      of: {
-        type: String,
-        validation: ['nonEmpty']
-      },
-      validation: ['elementsNonEmpty']
-    },
-    message: {
-      type: String,
-      validation: []
-    }
+    ...invitationProperties
   },
   indexes: {
 
   }
 })
-*/
 
-module.exports = { Access, PublicAccess, AccessRequest }
+definition.event({
+  name: 'userInvited',
+  async execute({ user, objectType, object, roles, message }) {
+    await AccessInvitation.create({
+      id: App.encodeIdentifier(['user_User', user, objectType, object]),
+      contactOrUserType: 'user_User', contactOrUser: user,
+      objectType, object,
+      roles, message
+    })
+  }
+})
+
+definition.event({
+  name: 'contactInvited',
+  async execute({ contactType, contact, objectType, object, roles, message }) {
+    await AccessInvitation.create({
+      id: App.encodeIdentifier([contactType, contact, objectType, object]),
+      contactOrUserType: contactType, contactOrUser: contact,
+      objectType, object,
+      roles, message
+    })
+  }
+})
+
+module.exports = { Access, PublicAccess, AccessRequest, AccessInvitation, invitationProperties }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/access-control-service",
-  "version": "0.2.24",
+  "version": "0.2.27",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -21,7 +21,7 @@
     "url": "https://www.viamage.com/"
   },
   "dependencies": {
-    "@live-change/framework": "0.5.27"
+    "@live-change/framework": "0.6.0"
   },
-  "gitHead": "2ccfeae4613bf874d5bfc215a71c98e57b3eb0e5"
+  "gitHead": "9a82ff0e7a7003d5b4e34ef9aef1ad4d7d8605dd"
 }