isomorfeus-data 1.0.0.zeta12 → 1.0.0.zeta13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e5ee58b1f8f38aef39dbcdf8a8d19449a6dc2935355568f5e09bd2cc8e667be
-  data.tar.gz: 3eaa2d3558298f3b82e0dec47076a0662353e8fb679f6fd56979f6db91ff24c2
+  metadata.gz: 5cee3d71649477f132cee03fd570b5fc5c4ef9430ccad0d40daab90e05525eff
+  data.tar.gz: 6839dfeb7ceebc8f7311073c31d69f11d73265ab0689d798d2c60754f4e65b72
 SHA512:
-  metadata.gz: bc4f6bcce18fcaf860603bdc6d1e454883a681d8db6b1a543ec36de56b797a6c658ab42c607e06ae67643b4b6544abc226488de56cdd1f42ac6ee6b68ea0af4a
-  data.tar.gz: d295afbea8c6223cd4c38a62f3f19630a869e02165eb6e1ee26dee38b3535609db3e938b4d5d036bad7eded951e47a9d59c9c57175ee37803d546f5793115231
+  metadata.gz: 189425d916a46bda087d17a9d49afe58bf6334446605a0d631032aff08b44f0b651acad2dea727ca6499e170d602bfe6cc1dccd31eaf5172ad3b9e737bf6399f
+  data.tar.gz: bb087ac1acdf8887b28bea4b5c997c2fac9263c500c7e88d18a3ef66115bde41a93bdf2955ac1546bc85e947405720f4e22d36d19abf26dd9388c3956e518dbf

data/README.md

@@ -36,4 +36,10 @@ All classes follow the common principles and the common API above.
 - [LucidData::Graph](https://github.com/isomorfeus/isomorfeus-project/blob/master/ruby/isomorfeus-data/docs/data_graph.md) - A graph, which can be build from several LucidData::Collection objects and LucidData::EdgeCollection objects
 - [LucidData::Hash](https://github.com/isomorfeus/isomorfeus-project/blob/master/ruby/isomorfeus-data/docs/data_hash.md) - A hash, easily accessible on client and server
 
+For convenience the following generic classes are provided. They can be used when creating a separate class wouldn't be useful:
+- LucidData::GenericCollection
+- LucidData::GenericEdgeCollection 
+- LucidData::GenericNode
+- LucidData::GenericEdge
+
 (more to come soon)

data/lib/isomorfeus-data.rb

@@ -44,6 +44,8 @@ else
   require 'isomorfeus_data/lucid_data/graph/base'
   require 'isomorfeus_data/lucid_data/composition/mixin'
   require 'isomorfeus_data/lucid_data/composition/base'
+  require 'isomorfeus_data/lucid_data/query/mixin'
+  require 'isomorfeus_data/lucid_data/query/base'
 
   require 'isomorfeus_data/lucid_data/generic_collection'
   require 'isomorfeus_data/lucid_data/generic_edge'

data/lib/isomorfeus/data/attribute_support.rb

@@ -18,14 +18,14 @@ module Isomorfeus
           end
 
           def _validate_attribute(attr_name, attr_val)
-            raise "#{self.name}: No such attribute declared: '#{attr_name}'!" unless attribute_conditions.key?(attr_name)
+            Isomorfeus.raise_error(message: "#{self.name}: No such attribute declared: '#{attr_name}'!") unless attribute_conditions.key?(attr_name)
             Isomorfeus::Props::Validator.new(self.name, attr_name, attr_val, attribute_conditions[attr_name]).validate!
           end
 
           def _validate_attributes(attrs)
             attribute_conditions.each_key do |attr|
               if attribute_conditions[attr].key?(:required) && attribute_conditions[attr][:required] && !attrs.key?(attr)
-                raise "Required attribute #{attr} not given!"
+                Isomorfeus.raise_error(message: "Required attribute #{attr} not given!")
               end
             end
             attrs.each { |attr, val| _validate_attribute(attr, val) }

data/lib/isomorfeus/data/config.rb

@@ -50,7 +50,7 @@ module Isomorfeus
         begin
           Arango.current_server.get_database(database)
         rescue Exception => e
-          raise "Can't connect to database '#{database}' (#{e.message})."
+          Isomorfeus.raise_error(message: "Can't connect to database '#{database}' (#{e.message}).")
         end
       end
 

data/lib/isomorfeus/data/element_validator.rb

@@ -33,7 +33,7 @@ module Isomorfeus
                  end
             @e = !!@e if @o[:type] == :boolean
           rescue
-            raise "#{@c}: #{@p} cast failed" unless @e.class == @o[:class]
+            Isomorfeus.raise_error(message: "#{@c}: #{@p} cast failed") unless @e.class == @o[:class]
           end
         end
       end
@@ -53,13 +53,13 @@ module Isomorfeus
       def type!
         return if @o[:allow_nil] && @e.nil?
         if @o.key?(:class)
-          raise "#{@c}: #{@p} class not #{@o[:class]}" unless @e.class == @o[:class]
+          Isomorfeus.raise_error(message: "#{@c}: #{@p} class not #{@o[:class]}") unless @e.class == @o[:class]
         elsif @o.key?(:is_a)
-          raise "#{@c}: #{@p} is not a #{@o[:is_a]}" unless @e.is_a?(@o[:is_a])
+          Isomorfeus.raise_error(message: "#{@c}: #{@p} is not a #{@o[:is_a]}") unless @e.is_a?(@o[:is_a])
         elsif @o.key?(:type)
           case @o[:type]
           when :boolean
-            raise "#{@c}: #{@p} is not a boolean" unless @e.class == TrueClass || @e.class == FalseClass
+            Isomorfeus.raise_error(message: "#{@c}: #{@p} is not a boolean") unless @e.class == TrueClass || @e.class == FalseClass
           end
         end
       end
@@ -76,48 +76,48 @@ module Isomorfeus
 
       # specific validations
       def c_gt(v)
-        raise "#{@c}: #{@p} not greater than #{v}!" unless @e > v
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} not greater than #{v}!") unless @e > v
       end
 
       def c_lt(v)
-        raise "#{@c}: #{@p} not less than #{v}!" unless @e < v
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} not less than #{v}!") unless @e < v
       end
 
       def c_keys(v)
-        raise "#{@c}: #{@p} keys dont fit!" unless @e.keys.sort == v.sort
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} keys dont fit!") unless @e.keys.sort == v.sort
       end
 
       def c_size(v)
-        raise "#{@c}: #{@p} length/size is not #{v}" unless @e.size == v
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} length/size is not #{v}") unless @e.size == v
       end
 
       def c_matches(v)
-        raise "#{@c}: #{@p} does not match #{v}" unless v.match?(@e)
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} does not match #{v}") unless v.match?(@e)
       end
 
       def c_max(v)
-        raise "#{@c}: #{@p} is larger than #{v}" unless @e <= v
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} is larger than #{v}") unless @e <= v
       end
 
       def c_min(v)
-        raise "#{@c}: #{@p} is smaller than #{v}" unless @e >= v
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} is smaller than #{v}") unless @e >= v
       end
 
       def c_max_size(v)
-        raise "#{@c}: #{@p} is larger than #{v}" unless @e.size <= v
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} is larger than #{v}") unless @e.size <= v
       end
 
       def c_min_size(v)
-        raise "#{@c}: #{@p} is smaller than #{v}" unless @e.size >= v
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} is smaller than #{v}") unless @e.size >= v
       end
 
       def c_direction(v)
-        raise "#{@c}: #{@p} is positive" if v == :negative && @e >= 0
-        raise "#{@c}: #{@p} is negative" if v == :positive && @e < 0
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} is positive") if v == :negative && @e >= 0
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} is negative") if v == :positive && @e < 0
       end
 
       def c_test
-        raise "#{@c}: #{@p} test condition check failed" unless @o[:test].call(@e)
+        Isomorfeus.raise_error(message: "#{@c}: #{@p} test condition check failed") unless @o[:test].call(@e)
       end
 
       def c_sub_type(v)

data/lib/isomorfeus/data/generic_class_api.rb

@@ -25,9 +25,9 @@ module Isomorfeus
               agent.processed = true
               if agent.response.key?(:error)
                 `console.error(#{agent.response[:error].to_n})`
-                raise agent.response[:error]
+                Isomorfeus.raise_error(message: agent.response[:error])
               end
-              Isomorfeus.store.dispatch(type: 'DATA_DESTROY', data: agent.full_response[:data])
+              Isomorfeus.store.dispatch(type: 'DATA_DESTROY', data: [self.name, key])
               agent.result = true
             end
           end
@@ -48,7 +48,7 @@ module Isomorfeus
               agent.processed = true
               if agent.response.key?(:error)
                 `console.error(#{agent.response[:error].to_n})`
-                raise agent.response[:error]
+                Isomorfeus.raise_error(message: agent.response[:error])
               end
               instance._load_from_store!
               Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: agent.full_response[:data])
@@ -57,40 +57,18 @@ module Isomorfeus
           end
         end
 
-        def query(props:)
-          query_result_instance = LucidData::QueryResult.new
-          promise_query(props: props, query_result_instance: query_result_instance) unless query_result_instance.loaded?
-          query_result_instance
+        def save(instance:)
+          instance.promise_save
+          instance
         end
 
-        def promise_query(props:, query_result_instance: nil)
-          query_result_instance = LucidData::QueryResult.new unless query_result_instance
-          props.each_key do |prop_name|
-            raise "#{self.to_s} No such query prop declared: '#{prop_name}'!" unless declared_props.key?(prop_name)
-          end
-          validate_props(props)
-          data_props = { props: props, query_result_instance_key: query_result_instance.key }
-          props_json = data_props.to_json
-          Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', self.name, :query, props_json).then do |agent|
-            if agent.processed
-              agent.result
-            else
-              agent.processed = true
-              if agent.response.key?(:error)
-                `console.error(#{agent.response[:error].to_n})`
-                raise agent.response[:error]
-              end
-              query_result_instance._load_from_store!
-              Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: agent.full_response[:data])
-              agent.result = query_result_instance
-            end
-          end
+        def promise_save(instance:)
+          instance.promise_save
         end
 
         # execute
         def execute_destroy(_); end
         def execute_load(_); end
-        def execute_query(_); end
         def execute_save(_); end
       else
         def promise_create(key:, **things)
@@ -101,14 +79,14 @@ module Isomorfeus
         end
 
         def promise_destroy(key:)
-          sid = self.destroy(key: key)
+          result = self.destroy(key: key)
           result_promise = Promise.new
-          result_promise.resolve(sid)
+          result_promise.resolve(result)
           result_promise
         end
 
-        def destroy(key:, pub_sub_client: nil, current_user: nil)
-          instance_exec(key: key, pub_sub_client: pub_sub_client, current_user: current_user, &@_destroy_block)
+        def destroy(key:)
+          !!instance_exec(key: key, &@_destroy_block)
         end
 
         def promise_load(key:)
@@ -118,22 +96,22 @@ module Isomorfeus
           result_promise
         end
 
-        def promise_query(props:)
-          instance = self.query(props: props)
-          result_promise = Promise.new
-          result_promise.resolve(instance)
-          result_promise
+        def load(key:)
+          data = instance_exec(key: key, &@_load_block)
+          return nil unless data
+          return data if data.class == self
+          Isomorfeus.raise_error "#{self.to_s}: execute_load must return a instance of #{self.to_s} or nil. Returned was: #{data.class}." if data.class != self
+          data
         end
 
-        def query(props:, query_result_instance_key: nil, pub_sub_client: nil, current_user: nil)
-          props.each_key do |prop_name|
-            raise "#{self.to_s} No such query prop declared: '#{prop_name}'!" unless declared_props.key?(prop_name)
-          end
-          validate_props(props)
-          query_result = LucidData::QueryResult.new(key: query_result_instance_key)
-          query_result.result_set = instance_exec(props: Isomorfeus::Transport::PropsProxy.new(props),
-                                                  pub_sub_client: pub_sub_client, current_user: current_user, &@_query_block)
-          query_result
+        def save(instance:)
+          previous_key = instance.key
+          data = instance_exec(instance: instance, &@_save_block)
+          return nil unless data
+          Isomorfeus.raise_error "#{self.to_s}: execute_save must return a instance of #{self.to_s} or nil. Returned was: #{data.class}." if data.class != self
+          data.instance_variable_set(:@previous_key, previous_key) if data.key != previous_key
+          data._unchange!
+          data
         end
 
         # execute
@@ -145,14 +123,18 @@ module Isomorfeus
           @_load_block = block
         end
 
-        def execute_query(&block)
-          @_query_block = block
-        end
-
         def execute_save(&block)
           @_save_block = block
         end
       end
+
+      def current_user
+        Isomorfeus.current_user
+      end
+
+      def pub_sub_client
+        Isomorfeus.pub_sub_client
+      end
     end
   end
 end

data/lib/isomorfeus/data/generic_instance_api.rb

@@ -47,30 +47,57 @@ module Isomorfeus
         alias create save
 
         def promise_save
-          data_hash = to_transport
-          if self.respond_to?(:included_changed_items)
-            data_hash.deep_merge!(self.included_changed_items)
-          end
-          Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', self.name, 'save', data_hash).then do |agent|
+          data_hash = { instance: to_transport }
+          data_hash.deep_merge!(included_items: included_items_to_transport) if respond_to?(:included_items_to_transport)
+          class_name = self.class.name
+          Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', class_name, :save, data_hash).then do |agent|
             if agent.processed
               agent.result
             else
               agent.processed = true
               if agent.response.key?(:error)
                 `console.error(#{agent.response[:error].to_n})`
-                raise agent.response[:error]
+                Isomorfeus.raise_error(message: agent.response[:error])
+              end
+              data = agent.full_response[:data]
+              if data.key?(class_name) && data[class_name].key?(@key) && data[class_name][@key].key?('new_key')
+                @key = data[class_name][@key]['new_key']
+                @revision = data[class_name][@key]['revision'] if data[class_name][@key].key?('revision')
+                _update_paths
               end
-              Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: agent.full_response[:data])
-              agent.result = true
+              _load_from_store!
+              Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: data)
+              agent.result = self
             end
           end
         end
         alias promise_create promise_save
+
+        # TODO update -> only send partial change
+        # included_changed_items
       else # RUBY_ENGINE
         def loaded?
           true
         end
+
+        def save
+          self.class.save(instance: self)
+          self
+        end
+
+        def promise_save
+          promise = Promise.new
+          promise.resolve(save)
+        end
       end # RUBY_ENGINE
+
+      def current_user
+        Isomorfeus.current_user
+      end
+
+      def pub_sub_client
+        Isomorfeus.pub_sub_client
+      end
     end
   end
 end

data/lib/isomorfeus/data/handler/arango.rb

@@ -4,7 +4,7 @@ module Isomorfeus
   module Data
     module Handler
       class Arango < LucidHandler::Base
-        on_request do |pub_sub_client, current_user, response_agent|
+        on_request do |response_agent|
           # promise_send_path('Isomorfeus::Data::Handler::Generic', action, type, self.to_s, props_hash)
           response_agent.request.each_key do |action|
             if action == 'load'
@@ -17,11 +17,10 @@ module Isomorfeus
                         props_json = response_agent.request[type_class_name]
                         begin
                           props = Oj.load(props_json, mode: :strict)
-                          props.merge!({pub_sub_client: pub_sub_client, current_user: current_user})
                           if current_user.authorized?(type_class, :load, *props)
                             loaded_type = type_class.load(props)
                             loaded_type.instance_exec do
-                              type_class.on_load_block.call(pub_sub_client, current_user) if type_class.on_load_block
+                              type_class.on_load_block.call() if type_class.on_load_block
                             end
                             response_agent.outer_result = { data: loaded_type.to_transport }
                             if %w[collection graph].include?(type)

data/lib/isomorfeus/data/handler/generic.rb

@@ -14,7 +14,7 @@ module Isomorfeus
         # LucidData::Graph
         # LucidData::Composition
 
-        def process_request(pub_sub_client, current_user, response_agent)
+        def process_request(response_agent)
           # promise_send_path('Isomorfeus::Data::Handler::Generic', self.to_s, action, props_hash)
           response_agent.request.each_key do |type_class_name|
             if Isomorfeus.valid_data_class_name?(type_class_name)
@@ -22,103 +22,92 @@ module Isomorfeus
               if type_class
                 response_agent.request[type_class_name].each_key do |action|
                   case action
-                  when 'load' then process_load(pub_sub_client, current_user, response_agent, type_class, type_class_name)
-                  when 'query' then process_query(pub_sub_client, current_user, response_agent, type_class, type_class_name)
-                  when 'save' then process_save(pub_sub_client, current_user, response_agent, type_class, type_class_name)
-                  when 'destroy' then process_destroy(pub_sub_client, current_user, response_agent, type_class, type_class_name)
+                  when 'load' then process_load(response_agent, type_class, type_class_name)
+                  when 'execute' then process_execute(response_agent, type_class, type_class_name)
+                  when 'save' then process_save(response_agent, type_class, type_class_name)
+                  when 'destroy' then process_destroy(response_agent, type_class, type_class_name)
                   else response_agent.error = { error: { action => 'No such thing!' }}
                   end
                 end
-              else response_agent.error = { error: { type_class_name => 'No such thing!' }}
+              else response_agent.error = { error: { type_class_name => 'No such class!' }}
               end
-            else response_agent.error = { error: { type_class_name => 'No such thing!' }}
+            else response_agent.error = { error: { type_class_name => 'Not a valid LucidData class!' }}
             end
           end
         rescue Exception => e
           response_agent.error = { error: "Isomorfeus::Data::Handler::Generic: #{e.message}\n#{e.backtrace.join("\n")}" }
         end
 
-        def process_load(pub_sub_client, current_user, response_agent, type_class, type_class_name)
+        def process_load(response_agent, type_class, type_class_name)
+          # 'Isomorfeus::Data::Handler::Generic', self.name, :load, key: key
           props = response_agent.request[type_class_name]['load']
           props.transform_keys!(&:to_sym)
-          props.merge!(pub_sub_client: pub_sub_client, current_user: current_user)
-          if current_user.authorized?(type_class, :load, props)
+          if Isomorfeus.current_user.authorized?(type_class, :load, props)
             loaded_type = type_class.load(**props)
             if loaded_type
-              response_agent.outer_result = { data: loaded_type.to_transport }
+              response_agent.outer_result = {} unless response_agent.outer_result
+              response_agent.outer_result.deep_merge!(data: loaded_type.to_transport)
               if loaded_type.respond_to?(:included_items_to_transport)
                 response_agent.outer_result.deep_merge!(data: loaded_type.included_items_to_transport)
               end
               response_agent.agent_result = { success: 'ok' }
-            else response_agent.error = { error: { type_class_name => 'No such thing!' }}
+            else response_agent.error = { error: { type_class_name => 'Load returned nothing!' }}
             end
           else response_agent.error = { error: 'Access denied!' }
           end
         end
 
-        def process_query(pub_sub_client, current_user, response_agent, type_class, type_class_name)
-          props_json = response_agent.request[type_class_name]['query']
+        def process_execute(response_agent, type_class, type_class_name)
+          # 'Isomorfeus::Data::Handler::Generic', self.name, :execute, props_json
+          props_json = response_agent.request[type_class_name]['execute']
           props = Oj.load(props_json, mode: :strict)
           props.transform_keys!(&:to_sym)
           props[:props].transform_keys!(&:to_sym)
-          props.deep_merge!({ pub_sub_client: pub_sub_client, current_user: current_user })
-          if current_user.authorized?(type_class, :query, props[:props])
-            queried_type = type_class.query(**props)
+          if Isomorfeus.current_user.authorized?(type_class, :execute, props[:props])
+            queried_type = type_class.execute(**props)
             if queried_type
-              response_agent.outer_result = { data: queried_type.to_transport }
+              response_agent.outer_result = {} unless response_agent.outer_result
+              response_agent.outer_result.deep_merge!(data: queried_type.to_transport)
               if queried_type.respond_to?(:included_items_to_transport)
                 response_agent.outer_result.deep_merge!(data: queried_type.included_items_to_transport)
               end
               response_agent.agent_result = { success: 'ok' }
-            else response_agent.error = { error: { type_class_name => 'No such thing!' }}
+            else response_agent.error = { error: { type_class_name => 'Query returned nothing!' }}
             end
           else response_agent.error = { error: 'Access denied!' }
           end
         end
 
-        def process_save(pub_sub_client, current_user, response_agent, type_class, type_class_name)
-          data_hash_json = response_agent.request[type_class_name]['save']
-          data_hash = Oj.load(data_hash_json, mode: :strict)
-          response_agent.outer_result = {}
-          if current_user.authorized?(type_class, :save, { pub_sub_client: pub_sub_client, current_user: current_user })
-            data_hash.each_key do |data_class_name|
-              data_hash[data_class_name].each_key do |key|
-                if Isomorfeus.valid_data_class_name?(type_class_name)
-                  data_class = Isomorfeus.cached_data_class(data_class_name)
-                  if data_class
-                    item_data_hash = data_hash[data_class_name][key]
-                    item_data_hash = item_data_hash.merge({ pub_sub_client: pub_sub_client, current_user: current_user })
-                    if current_user.authorized?(data_class, :save, item_data_hash)
-                      saved_type = data_class.save(**item_data_hash)
-                      if saved_type
-                        response_agent.outer_result.deep_merge!({ data: saved_type.to_transport })
-                      end
-                    else
-                      response_agent.error = { error: 'Access denied!' }
-                      break
-                    end
-                  else
-                    response_agent.error = { error: 'Access denied!' }
-                    break
-                  end
-                end
+        def process_save(response_agent, type_class, type_class_name)
+          # 'Isomorfeus::Data::Handler::Generic', self.name, :save, data_hash
+          data = response_agent.request[type_class_name]['save']
+          instance_data = data['instance']
+          included_items_data = data.key?('included_items') ? data['included_items'] : nil
+          if Isomorfeus.current_user.authorized?(type_class, :save, data)
+            instance = type_class.instance_from_transport(instance_data, included_items_data)
+            saved_type = type_class.save(instance: instance)
+            if saved_type
+              response_agent.outer_result = {} unless response_agent.outer_result
+              response_agent.outer_result.deep_merge!(data: saved_type.to_transport)
+              if saved_type.respond_to?(:included_items_to_transport)
+                response_agent.outer_result.deep_merge!(data: saved_type.included_items_to_transport)
               end
+              response_agent.agent_result = { success: 'ok' }
+            else response_agent.error = { error: { type_class_name => 'Save returned nothing!' }}
             end
-            response_agent.agent_result = { success: 'ok' }
           else response_agent.error = { error: 'Access denied!' }
           end
         end
 
-        def process_destroy(pub_sub_client, current_user, response_agent, type_class, type_class_name)
-          props_json = response_agent.request[type_class_name]['destroy']
-          props = Oj.load(props_json, mode: :strict)
-          props.merge!(pub_sub_client: pub_sub_client, current_user: current_user)
-          if current_user.authorized?(type_class, :destroy, props)
-            destroyed_type = type_class.destroy(**props)
-            if destroyed_type
-              response_agent.outer_result = { data: destroyed_type }
+        def process_destroy(response_agent, type_class, type_class_name)
+          props = response_agent.request[type_class_name]['destroy']
+          props.transform_keys!(&:to_sym)
+          if Isomorfeus.current_user.authorized?(type_class, :destroy, props)
+            result = type_class.destroy(**props)
+            if result
               response_agent.agent_result = { success: 'ok' }
-            else response_agent.error = { error: { type_class_name => 'No such thing!' }}
+            else
+              response_agent.error = { error: { type_class_name => 'Destroy failed!' }}
             end
           else response_agent.error = { error: 'Access denied!' }
           end