feat(es6): Module upgraded to now use babel to transpile files that have the.es6 extensions

models/PermissionModel.js → models/PermissionModel.es6

@@ -1,11 +1,12 @@
-module.exports = function(Model, config, async, utils, Exceptions, UserModel, AccountModel) {
+export default function(Model, Exceptions, config, async, utils) {
+
   return Model.extend('Permission',
   {
-    type            : config['clever-roles'].driver || 'ORM',
-    timeStampable   : true,
-    softDeleteable  : false,
+    type           : config['clever-roles'].driver || 'ORM',
+    timeStampable  : true,
+    softDeleteable : false,
 
-    beforeCreate: function(values, queryOptions, callback) {
+    beforeCreate(values, queryOptions, callback) {
       if (!values.action) {
         callback(new Exceptions.InvalidData('You must provide an action name'));
       } else {
@@ -19,7 +20,7 @@ module.exports = function(Model, config, async, utils, Exceptions, UserModel, Ac
       }
     },
 
-    beforeUpdate: function() {
+    beforeUpdate() {
       return this.beforeCreate.apply(this, [].slice.call(arguments));
     }
   },
@@ -42,4 +43,5 @@ module.exports = function(Model, config, async, utils, Exceptions, UserModel, Ac
       default       : false
     }
   });
+
 };

models/RoleModel.js → models/RoleModel.es6

@@ -1,19 +1,22 @@
-module.exports = function(Model, config, utils, Exceptions, PermissionModel, UserModel) {
+export default function(Model, Exceptions, config, utils, PermissionModel, UserModel) {
+
   return Model.extend('Role',
   {
-    type            : config['clever-roles'].driver || 'ORM',
-    timeStampable   : true,
-    softDeleteable  : false,
+    type           : config['clever-roles'].driver || 'ORM',
+    timeStampable  : true,
+    softDeleteable : false,
 
-    'PermissionModel beforeAllFindersOptions': function(findOptions, queryOptions, callback) {
-      utils.helpers
+    'PermissionModel beforeAllFindersOptions'(findOptions, queryOptions, callback) {
+      utils
+        .helpers
         .includeModel(findOptions, this, 'Roles');
 
       callback(null, findOptions);
     },
 
-    'UserModel beforeAllFindersOptions': function(findOptions, queryOptions, callback) {
-      utils.helpers
+    'UserModel beforeAllFindersOptions'(findOptions, queryOptions, callback) {
+      utils
+        .helpers
         .includeModel(findOptions, this, 'Role', {
           as: 'Permissions',
           model: PermissionModel.entity
@@ -22,15 +25,16 @@ module.exports = function(Model, config, utils, Exceptions, PermissionModel, Use
       callback(null, findOptions);
     },
 
-    beforeAllFindersOptions: function(findOptions, queryOptions, callback) {
-      utils.helpers
+    beforeAllFindersOptions(findOptions, queryOptions, callback) {
+      utils
+        .helpers
         .includeModel(findOptions, PermissionModel, 'Permissions')
         .includeModel(findOptions, UserModel, 'Users');
 
       callback(null, findOptions);
     },
 
-    beforeCreate: function(values, queryOptions, callback) {
+    beforeCreate(values, queryOptions, callback) {
       if (!values.name) {
         callback(new Exceptions.InvalidData('You must provide a name'));
       } else {
@@ -44,7 +48,7 @@ module.exports = function(Model, config, utils, Exceptions, PermissionModel, Use
       }
     },
 
-    beforeUpdate: function() {
+    beforeUpdate() {
       return this.beforeCreate.apply(this, [].slice.call(arguments));
     }
   },

services/PermissionService.es6

@@ -0,0 +1,63 @@
+export default function(Service, Promise, PermissionModel, async) {
+
+  return Service.extend({
+    model: PermissionModel,
+
+    findDefaultPermissions(queryOptions = {}) {
+      let findOptions = {where: {
+        AccountId: null,
+        systemPermission: true
+      }};
+      return this.findAll(findOptions, queryOptions);
+    },
+
+    createAccountDefaultPermissions(account, values, queryOptions = {}) {
+      return new Promise((resolve, reject) => {
+        this
+          .findDefaultPermissions(queryOptions)
+          .then(this.proxy('createDefaultPermissions', queryOptions, account, resolve, reject))
+          .catch(reject);
+      });
+    },
+
+    createDefaultPermissions(queryOptions = {}, account, resolve, reject, defaultPermissions) {
+      if (!defaultPermissions.length) {
+        return resolve([]);
+      }
+
+      async.map(
+        defaultPermissions,
+        this.proxy('createDefaultPermission', queryOptions, account),
+        (error, permissions) => {
+          if (error !== undefined && error !== null) {
+            reject(error);
+          } else {
+            if (permissions && permissions.length) {
+              account.entity.Permissions = account.entity.values.Permissions = permissions;
+
+              resolve(permissions);
+            } else {
+              resolve([]);
+            }
+          }
+        }
+      );
+    },
+
+    createDefaultPermission(queryOptions = {}, account, defaultPermission, callback) {
+      let values = {
+        AccountId        : account.id,
+        action           : defaultPermission.action,
+        description      : defaultPermission.description,
+        systemPermission : true
+      };
+
+      this
+        .create(values, queryOptions)
+        .then(callback.bind(null, null))
+        .catch(callback);
+    }
+
+  });
+
+}

services/RoleService.es6

@@ -0,0 +1,72 @@
+export default function(Service, Promise, RoleModel, PermissionService, underscore, async) {
+
+  return Service.extend({
+    model: RoleModel,
+
+    'AccountModel afterCreate'(account, values, queryOptions = {}, callback) {
+      Promise.all([
+        this.findDefaultRoles(queryOptions),
+        PermissionService.createAccountDefaultPermissions(account, values, queryOptions)
+      ])
+      .spread((defaultRoles, defaultPermissions) => {
+        if (!defaultRoles.length) {
+          if (this.debug.enabled) {
+            this.debug('found no default roles for an account!');
+          }
+          return callback(null);
+        } else if (this.debug.enabled) {
+          this.debug('creating %s default roles for new account...', defaultRoles.length);
+        }
+
+        async.map(
+          defaultRoles,
+          (defaultRole, createCallback) => {
+            let Permissions = [];
+
+            if (defaultRole.Permissions) {
+              defaultRole.Permissions.forEach((rolePermission) => {
+                let permission;
+                if (!!(permission = underscore.findWhere(defaultPermissions, { action: rolePermission.action }))) {
+                  Permissions.push(permission.entity);
+                }
+              });
+            }
+
+            this.
+              create({
+                AccountId   : account.id,
+                systemRole  : true,
+                name        : defaultRole.name,
+                description : defaultRole.description,
+                Permissions : Permissions
+              }, queryOptions )
+              .then(createCallback.bind(null, null))
+              .catch(createCallback)
+          },
+          (error, roles) => {
+            if (error === undefined || error === null) {
+              if (roles) {
+                account.entity.Roles        = roles;
+                account.entity.values.Roles = roles;
+              }
+              callback(null, values);
+            } else {
+              callback(error);
+            }
+          }
+        );
+      })
+      .catch(callback);
+    },
+
+    findDefaultRoles(queryOptions = {}) {
+      let findOptions = {where: {
+        AccountId  : null,
+        systemRole : true
+      }};
+      return this.findAll(findOptions, queryOptions);
+    }
+
+  });
+
+};