add system into applicaton

app/core/applications/persistenceApplication.js

@@ -74,7 +74,7 @@ const PersistenceApp = (Entity, PersistenceServices = DPersistenceServices) => {
         create (req, res, next) {
 
             _.defaults(req.body, Entity.defaults || {});
-            
+
             const bodyWithOwner = Object.assign(
                 {},
                 req.body,

app/core/libs/in_maker.js

@@ -0,0 +1,10 @@
+"use strict";
+
+const _ = require('lodash');
+const {ObjectId} = require('mongorito');
+
+module.exports = (_id) => {
+  return _.isArray(_id)
+  ? {$in: _.map(_id, e=>ObjectId(e))}
+  : ObjectId(_id);
+};

app/core/repositories/DBRepository.js

@@ -28,8 +28,6 @@ const DBRepository = (Entity, options={}) => {
 
                 const filter = findFilledFormat(query, Entity.singleFilled);
 
-                          console.log(filter);
-
                 return DB
                     .limit(limit)
                     .skip(skip)
@@ -90,7 +88,6 @@ const DBRepository = (Entity, options={}) => {
         updateByPushUnique(filter, post, fill = Entity.filled, resFilled = Entity.singleFilled) {
 
             return new Promise((resolve, reject) => {
-
                 const data = _.pick(post, fill);
 
                 return new DB(data)

app/core/repositories/daos/DBConnector.js

@@ -38,12 +38,16 @@ class Dao extends Model {
     }
 
     updateByPushUnique(filter, options) {
+        const {oUpdater} = options;
+        const opp = `update${oUpdater||''}Factory`;
 
-        return this.updateFactory(filter, '$addToSet', options);
+        return this[opp](filter, '$addToSet', options);
     }
 
-    updateByPull(filter, options) {
-        return this.updateFactory(filter, '$pull', options);
+    updateByPull(filter, options, many = '') {
+        const opp = `update${many}Factory`;
+
+        return this[opp](filter, '$pull', options);
     }
 
     updateFactory(entity, entry, options) {
@@ -61,6 +65,21 @@ class Dao extends Model {
             .return(this);
     }
 
+    updateManyFactory(entity, entry, options) {
+
+        return this._collection()
+            .tap(() => {
+                return this._runHooks('before', 'update');
+            })
+            .then((collection) => {
+                return collection.updateMany(entity, {[entry]: this.get()}, options);
+            })
+            .then((e) => {
+                return this.isUpdater = e.result;
+            })
+            .return(this);
+    }
+
 }
 
 module.exports = Dao;

app/core/services/transforms/accessMergeTransform.js

@@ -1,7 +1,7 @@
 'use strict';
-const _ = require('lodash');
 const {ObjectId} = require('mongorito');
 const Access = require('core/entities/accessRole');
+const in_maker = require('core/libs/in_maker');
 
 function makeAccess(owner, fielder, access) {
     const {_id} = owner;
@@ -29,11 +29,9 @@ module.exports = function (owner, fielder, trans = {}, access = Access.ROLE_READ
 
     if (trans.hasOwnProperty('_id')) {
        const {_id} = trans;
-       trans._id = _.isArray(_id)
-       ? {$in: _.map(_id, e=>ObjectId(e))}
-       : ObjectId(_id);
+       trans._id = in_maker(_id);
     }
-
+    
     if (Array.isArray(owner)) {
         const roles = owner.map((e) => makeAccess(e, fielder, access));
         merge = {$or: roles};

app/inventory/applications/PersistenceServices.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const _ = require('lodash');
+
+const DFactoryDBRepository = require('core/repositories/DBRepository');
+
+const Access = require('core/entities/accessRole');
+const accessMergeTransform = require('./transforms/accessMergeTransform');
+const regexFilterQuery = require('./transforms/regexFilterQuery');
+
+
+const Persistence = (Entity, FactoryDBRepository = DFactoryDBRepository) => {
+
+    const DBRepository = FactoryDBRepository(Entity);
+
+    return {
+
+        find (query, owner, access = Access.ROLE_READ) {
+            return new Promise((resolve, reject) => {
+
+                const prepared = _.assign({},
+                  query,
+                  accessMergeTransform(owner, Entity.access, query, access),
+                  ...regexFilterQuery(_.get(query, 'query'))
+                );
+
+                return Promise.all([
+                          DBRepository.find(prepared),
+                          DBRepository.count(prepared)
+                        ])
+                        .then(resolve)
+                        .catch(reject);
+            });
+        },
+
+        findOne (_id, owner, access = Access.ROLE_READ) {
+
+            return new Promise((resolve, reject) => {
+
+                const prepared = accessMergeTransform(owner, Entity.access, {_id}, access);
+
+                return DBRepository
+                    .findOne(prepared)
+                    .then(resolve)
+                    .catch(reject);
+            });
+        },
+
+        update (_id, post, owner, access = Access.ROLE_WRITER) {
+
+            return new Promise((resolve, reject) => {
+
+                const fill = _.difference(Entity.filled, ['owner', Entity.access, 'password', '_id']);
+
+                const prepared = accessMergeTransform(owner, Entity.access, {_id}, access);
+
+                return DBRepository
+                    .update(prepared, post, fill)
+                    .then(resolve)
+                    .catch(reject);
+            });
+        },
+
+        create (post) {
+            return new Promise((resolve, reject) => {
+                return DBRepository
+                    .create(post)
+                    .then(resolve)
+                    .catch(reject);
+            });
+        },
+
+        remove(_id, owner, access = Access.ROLE_ADMIN) {
+
+            return new Promise((resolve, reject) => {
+                const prepared = accessMergeTransform(owner, Entity.access, {_id}, access);
+
+                return DBRepository
+                    .remove(prepared)
+                    .then(resolve)
+                    .catch(reject);
+            });
+        }
+
+    };
+};
+
+module.exports = _.curry(Persistence);

app/inventory/applications/persistenceSystem.js

@@ -2,31 +2,29 @@
 
 const _ = require('lodash');
 
-const DPersistenceServices = require('core/services/PersistenceServices');
-const PersistenceApplication = require('core/applications/persistenceApplication');
+const PersistenceServices = require('core/services/PersistenceServices');
+const PersistenceSystem = require('../services/PersistenceServices');
+const notExist = require('core/applications/validator/validNotExist');
 
-const jsonParser = require('core/applications/transforms/jsonParser');
-const filterHooks = require('./transforms/filterHooks');
-
-const persistenceApplications = (Entity, PersistenceServices = DPersistenceServices) => {
+const persistenceSystem = (Entity) => (IEntity) => {
 
     return {
-      findApplications(req, res, next) {
-          const field = 'query';
-          let query = _.clone(req.query);
-
-          query = jsonParser(query, field);
-
-          query = filterHooks(query, field, [
-            {dest: 'system.name', source: 'lsystem'},
-            {dest: 'family', source: 'family'}
-          ]);
-
-          Object.assign(req, {query});
-          PersistenceApplication(Entity, PersistenceServices)
-            .find(req, res, next);
+      insertApp(req, res, next) {
+
+        PersistenceServices(Entity)
+            .findOne(req.params.id, req.user)
+            .then(notExist)
+            .then((e) => {
+              const ids = _.isArray(_.get(req, 'body.id')) ? req.body.id : [];
+              const system = _.pick(e, 'name', '_id');
+
+              PersistenceSystem(IEntity)
+                .addList(ids, {system}, req.user);
+            })
+            .then(e => res.json(e))
+            .catch(next);
       }
     };
 };
 
-module.exports = _.curry(persistenceApplications);
+module.exports = _.curry(persistenceSystem);

app/inventory/routers/system/system.js

@@ -2,7 +2,11 @@
 
 const authenticate = require('identity/profile/middlewares/authenticate');
 const System = require('../../entities/System');
+const Application = require('../../entities/Application');
+
 const PersistenceApp = require('core/applications/persistenceApplication')(System);
+const PersistenceSystem = require('../../applications/persistenceSystem')(System)(Application);
+
 const AccessApp = require('core/applications/accessApplication')(System);
 
 module.exports = function (router) {
@@ -25,5 +29,10 @@ module.exports = function (router) {
 
         .put('/:id/roles/:idu', authenticate(), AccessApp.update)
 
-        .delete('/:id/roles/:idu', authenticate(), AccessApp.remove);
+        .delete('/:id/roles/:idu', authenticate(), AccessApp.remove)
+
+        /**
+         * Applications
+         */
+        .patch('/:id/applications', authenticate(), PersistenceSystem.insertApp);
 };

app/inventory/services/PersistenceServices.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const _ = require('lodash');
+
+const DFactoryDBRepository = require('core/repositories/DBRepository');
+
+const Access = require('core/entities/accessRole');
+const accessMergeTransform = require('core/services/transforms/accessMergeTransform');
+
+const Persistence = (Entity, FactoryDBRepository = DFactoryDBRepository) => {
+
+    const DBRepository = FactoryDBRepository(Entity, {oUpdater: 'Many'});
+
+    return {
+      addList (_id, post, owner, access = Access.ROLE_WRITER) {
+
+          return new Promise((resolve, reject) => {
+
+              const prepared = _.assign({},
+                accessMergeTransform(owner, Entity.access, {_id}, access)
+              );
+
+              return DBRepository
+                  .updateByPushUnique(prepared, post)
+                  .then(resolve)
+                  .catch(reject);
+          });
+
+              },
+
+
+    };
+};
+
+module.exports = _.curry(Persistence);