2 files changed, 562 insertions, 0 deletions
diff --git a/moon_gui/static/app/services/moon/rule/metadata.service.js b/moon_gui/static/app/services/moon/rule/metadata.service.js
new file mode 100755
index 00000000..8c68b2ef
--- /dev/null
+++ b/moon_gui/static/app/services/moon/rule/metadata.service.js
@@ -0,0 +1,354 @@
+/**
+ * @author Samy Abdallah
+ */
+
+(function() {
+
+    'use strict';
+
+    angular
+        .module('moon')
+        .factory('metaDataService', metaDataService);
+
+    metaDataService.$inject = ['$resource', 'REST_URI', '$q', 'utilService'];
+
+    function metaDataService($resource, REST_URI, $q, utilService) {
+
+        var data =  {
+
+            subject: $resource(REST_URI.METADATA.subject + ':subject_id', {}, {
+                get: {method: 'GET', isArray: false},
+                create: {method: 'POST'},
+                remove: {method: 'DELETE'}
+            }),
+
+
+            object:  $resource(REST_URI.METADATA.object + ':object_id', {}, {
+                get: {method: 'GET', isArray: false},
+                create: {method: 'POST'},
+                remove: {method: 'DELETE'}
+            }),
+
+            action: $resource(REST_URI.METADATA.action + ':action_id', {}, {
+                get: {method: 'GET', isArray: false},
+                create: {method: 'POST'},
+                remove: {method: 'DELETE'}
+            })
+
+        };
+
+        return {
+
+            subject : {
+
+                findOne: function(subjectId, callback){
+
+                    data.subject.get({subject_id: subjectId}).$promise.then(function(data) {
+
+                        callback(utilService.transformOne(data, 'subject_categories'));
+
+                    });
+
+                },
+
+                findOneReturningPromise: function (subjectId){
+
+                    return  data.subject.get({subject_id: subjectId}).$promise;
+
+                },
+
+                findSome: function(subjectListId) {
+
+                    var _self = this;
+
+                    if(subjectListId.length === 0){
+                        return [];
+                    }
+
+                    var promises = _(subjectListId).map( function(subjectId) {
+
+                        return _self.findOneReturningPromise(subjectId);
+
+                    });
+
+                    return $q.all(promises).then( function(result) {
+
+                        return _(result).map( function(resource) {
+
+                            return utilService.transformOne(resource, 'subject_categories');
+
+                        });
+
+                    });
+
+                },
+
+                findSomeWithCallback: function(subjectListId, callback){
+
+                    var _self = this;
+
+                    if(subjectListId.length === 0){
+                        callback([]);
+                    }
+
+                    var promises = _(subjectListId).map( function(subjectId) {
+
+                        return _self.findOneReturningPromise(subjectId);
+
+                    });
+
+                    $q.all(promises).then( function(result) {
+
+                        callback( _(result).map( function(resource) {
+
+                            return utilService.transformOne(resource, 'subject_categories');
+
+                        }));
+
+                    });
+
+                },
+
+                findAll: function(){
+
+                    return data.subject.get().$promise.then(function(data) {
+
+                        return utilService.transform(data, 'subject_categories');
+
+                    });
+                },
+
+                findAllWithCallback: function(callback){
+
+                    return data.subject.get().$promise.then(function(data) {
+
+                        callback(utilService.transform(data, 'subject_categories'));
+
+                    });
+
+                },
+                
+                delete: function (subject, callbackSuccess, callbackError ) {
+
+                    data.subject.remove({subject_id: subject.id}, subject, callbackSuccess, callbackError);
+
+                },
+
+                add: function (subject, callbackSuccess, callbackError ) {
+
+                    data.subject.create({}, subject, callbackSuccess, callbackError);
+
+                }
+            },
+
+            object : {
+
+                findOne: function(objectId, callback){
+
+                    data.object.get({object_id: objectId}).$promise.then(function(data) {
+
+                        callback(utilService.transformOne(data, 'object_categories'));
+
+                    })
+
+                },
+
+                findOneReturningPromise: function(objectId){
+
+                    return  data.object.get({object_id: objectId}).$promise;
+
+                },
+
+                findSome: function(objectListId) {
+
+
+                    var _self = this;
+
+                    if(objectListId.length === 0){
+                        return [];
+                    }
+
+                    var promises = _(objectListId).map( function(objectId) {
+
+                        return _self.findOneReturningPromise(objectId);
+
+                    });
+
+                    return $q.all(promises).then( function(result) {
+
+                        return _(result).map( function(resource) {
+
+                            return utilService.transformOne(resource, 'object_categories');
+
+                        });
+
+                    });
+
+                },
+
+                findSomeWithCallback: function(objectListId, callback){
+
+                    var _self = this;
+
+                    if(objectListId.length === 0){
+                        callback([]);
+                    }
+
+                    var promises = _(objectListId).map( function(objectId) {
+
+                        return _self.findOneReturningPromise(objectId);
+
+                    });
+
+                    $q.all(promises).then( function(result) {
+
+                        callback( _(result).map( function(resource) {
+
+                            return utilService.transformOne(resource, 'object_categories');
+
+                        }));
+
+                    });
+
+                },
+
+                findAll : function(){
+
+                    return data.object.get().$promise.then(function(data) {
+
+                        return utilService.transform(data, 'object_categories');
+
+                    });
+
+                },
+
+                findAllWithCallback: function(callback){
+
+                    return data.object.get().$promise.then(function(data) {
+
+                        callback(utilService.transform(data, 'object_categories'));
+
+                    });
+
+                },
+
+                delete: function (object, callbackSuccess, callbackError ) {
+
+                    data.object.remove({object_id: object.id}, object, callbackSuccess, callbackError);
+
+                },
+
+                add:function (object, callbackSuccess, callbackError ) {
+
+                    data.object.create({}, object, callbackSuccess, callbackError);
+
+                }
+            },
+
+            action : {
+
+                findOne: function(actionId, callback){
+
+                    data.action.get({action_id: actionId}).$promise.then(function(data) {
+
+                        callback(utilService.transformOne(data, 'action_categories'));
+
+                    })
+
+                },
+
+                findOneReturningPromise: function(actionId){
+
+                    return data.action.get({action_id: actionId}).$promise;
+
+                },
+
+                findSome: function(actionListId) {
+
+                    var _self = this;
+
+                    if(actionListId.length === 0){
+                        return [];
+                    }
+
+                    var promises = _(actionListId).map( function(actionId) {
+
+                        return _self.findOneReturningPromise(actionId);
+
+                    });
+
+                    return $q.all(promises).then( function(result) {
+
+                        return _(result).map( function(resource) {
+
+                            return utilService.transformOne(resource, 'action_categories');
+
+                        });
+
+                    });
+
+                },
+
+                findSomeWithCallback: function(actionListId, callback){
+
+                    var _self = this;
+
+                    if(actionListId.length === 0){
+                        callback([]);
+                    }
+
+                    var promises = _(actionListId).map( function(actionId) {
+
+                        return _self.findOneReturningPromise(actionId);
+
+                    });
+
+                    $q.all(promises).then( function(result) {
+
+                        callback( _(result).map( function(resource) {
+
+                            return utilService.transformOne(resource, 'action_categories');
+
+                        }));
+
+                    });
+
+                },
+
+                findAll : function(){
+
+                    return data.action.get().$promise.then(function(data) {
+
+                        return utilService.transform(data, 'action_categories');
+
+                    });
+
+                },
+
+                findAllWithCallback: function(callback){
+
+                    return data.action.get().$promise.then(function(data) {
+
+                        callback(utilService.transform(data, 'action_categories'));
+
+                    });
+
+                },
+
+                delete: function (action, callbackSuccess, callbackError ) {
+
+                    data.action.remove({action_id: action.id}, action, callbackSuccess, callbackError);
+
+                },
+
+                add:function (action, callbackSuccess, callbackError ) {
+
+                    data.action.create({}, action, callbackSuccess, callbackError);
+
+                }
+            }
+
+        };
+
+    }
+})();
+\ No newline at end of file
diff --git a/moon_gui/static/app/services/moon/rule/metarule.service.js b/moon_gui/static/app/services/moon/rule/metarule.service.js
new file mode 100755
index 00000000..2679fc5b
--- /dev/null
+++ b/moon_gui/static/app/services/moon/rule/metarule.service.js
@@ -0,0 +1,208 @@
+/**
+ * @author Samy Abdallah
+ */
+
+(function() {
+
+    'use strict';
+
+    angular
+        .module('moon')
+        .factory('metaRuleService', metaRuleService);
+
+    metaRuleService.$inject = ['$resource', 'REST_URI', 'metaDataService', '$q', 'utilService'];
+
+    function metaRuleService($resource, REST_URI, metaDataService, $q, utilService) {
+
+        return {
+
+            data: $resource(REST_URI.METARULES + ':metarule_id', {}, {
+                query: {method: 'GET' },
+                get: {method: 'GET', isArray: false},
+                update: {method: 'PATCH'},
+                create: { method: 'POST' },
+                remove: { method: 'DELETE' }
+            }),
+
+
+            findAll: function () {
+
+                return this.data.query().$promise.then(function (data) {
+
+                    return utilService.transform(data, 'meta_rules');
+
+                });
+
+            },
+
+            findAllWithCallback : function (callback) {
+
+                this.data.query().$promise.then(function (data) {
+
+                    callback(utilService.transform(data, 'meta_rules'));
+
+                });
+
+            },
+
+            findSomeWithMetaData : function(metaRuleListId){
+
+                var _self = this;
+
+                if(metaRuleListId.length === 0){
+                    return [];
+                }
+
+                var promises = _(metaRuleListId).map(function(objectId) {
+
+                    return _self.findOneReturningPromise(objectId);
+
+                });
+
+                return $q.all(promises).then(function(result) {
+
+                    return _(result).map(function(resource) {
+
+                        var metaRule = utilService.transformOne(resource, 'meta_rules');
+
+                        metaRule = _self.findMetaDataFromMetaRule(metaRule);
+
+                        return metaRule;
+
+                    });
+
+                });
+
+
+            },
+
+            findSomeWithCallback : function(metaRuleListId, callback){
+
+                var _self = this;
+
+                if(metaRuleListId.length === 0){
+                    return [];
+                }
+
+                var promises = _(metaRuleListId).map(function(objectId) {
+
+                    return _self.findOneReturningPromise(objectId);
+
+                });
+
+                return $q.all(promises).then(function(result) {
+
+                    callback( _(result).map(function(resource) {
+
+                        return utilService.transformOne(resource, 'meta_rules');
+
+                    }));
+
+                });
+
+
+            },
+
+            findOneReturningPromise: function(metaRuleId){
+
+                return this.data.get({metarule_id: metaRuleId}).$promise;
+
+            },
+
+            findOne : function(metaRuleId){
+
+                return this.data.get({metarule_id: metaRuleId}).$promise.then(function(data) {
+
+                    return utilService.transformOne(data, 'meta_rules');
+
+                });
+
+            },
+
+            findOneWithCallback: function(metaRuleId, callback){
+
+                this.data.get({metarule_id: metaRuleId}).$promise.then(function(data) {
+
+                    callback(utilService.transformOne(data, 'meta_rules'));
+
+                });
+
+            },
+
+            findOneWithMetaData: function(metaRuleId){
+
+                var _self = this;
+
+                return this.data.get({metarule_id: metaRuleId}).$promise.then(function(data) {
+
+                    var metaRule = utilService.transformOne(data, 'meta_rules');
+
+                    metaRule = _self.findMetaDataFromMetaRule(metaRule);
+
+                    return metaRule;
+
+                });
+
+            },
+
+            findMetaDataFromMetaRule : function (metaRule){
+
+                if(metaRule.subject_categories.length > 0){
+
+                    metaDataService.subject.findSome(metaRule.subject_categories).then(function(categories){
+                        metaRule.subject_categories_values = categories;
+                    });
+
+                }else{
+
+                    metaRule.subject_categories_values = [];
+
+                }
+
+                if(metaRule.object_categories.length > 0){
+
+                    metaDataService.object.findSome(metaRule.object_categories).then(function(categories){
+                        metaRule.object_categories_values = categories;
+                    });
+
+                }else{
+
+                    metaRule.object_categories_values = [];
+
+                }
+
+                if(metaRule.action_categories.length > 0){
+
+                    metaDataService.action.findSome(metaRule.action_categories).then(function(categories){
+                        metaRule.action_categories_values = categories;
+                    });
+
+
+                }else{
+
+                    metaRule.action_categories_values = [];
+
+                }
+
+                return metaRule;
+            },
+
+            delete: function (metaRule, callbackSuccess, callbackError ) {
+
+                this.data.remove({metarule_id: metaRule.id}, metaRule, callbackSuccess, callbackError);
+
+            },
+
+            update: function(metaRule, callbackSuccess, callbackError){
+
+                delete metaRule.subject_categories_values;
+                delete metaRule.object_categories_values;
+                delete metaRule.action_categories_values;
+
+                this.data.update({metarule_id: metaRule.id}, metaRule, callbackSuccess, callbackError);
+
+            }
+        };
+
+    }
+})();
+\ No newline at end of file