restful_objects 0.0.1

data/lib/restful_objects/object_actions.rb

@@ -0,0 +1,134 @@
+module RestfulObjects
+  module ObjectActions
+    def actions_members
+      members = {}
+      rs_type.actions.each do |name, action|
+        members[name] = {
+          'memberType' => 'action',
+          'links' => [
+            !is_service ?
+              link_to(:details, "/objects/#{self.class.name}/#{object_id}/actions/#{name}", :object_action, action: name)
+              :
+              link_to(:details, "/services/#{self.class.name}/actions/#{name}", :object_action, action: name)
+          ],
+          'extensions' => action.metadata
+        }
+      end
+      members
+    end
+
+    def get_action(action)
+      { 'id' => action,
+        'parameters' => generate_parameters(action),
+        'links' => [ rs_action_link(action), rs_action_up_link, rs_invoke_link(action) ],
+        'extensions' => rs_type.actions[action].metadata
+      }.to_json
+    end
+
+    def generate_parameters(action)
+      parameters = Hash.new
+      rs_type.actions[action].parameters.each do |name, parameter|
+        parameters[name] = {
+          'links' => [],
+          'extensions' => parameter.metadata
+        }
+      end
+      parameters
+    end
+
+    def get_action_invoke(action, json)
+      raise 'action does not exists' if not rs_type.actions.include?(action)
+      action_description = rs_type.actions[action]
+      json == '' ? {} : arguments = JSON.parse(json)
+      parameters = []
+      action_description.parameters.each do |name, parameter|
+        case parameter.type
+          when :int
+            parameters << arguments[name]['value'].to_i
+          else
+            parameters << arguments[name]['value']
+        end
+      end
+
+      result = send(action.to_sym, *parameters)
+
+      action_link = link_to(:self, "/objects/#{self.class.name}/#{object_id}/actions/#{action}/invoke", :action_result)
+      action_link['arguments'] = arguments
+
+      response = {
+        'links' => [ action_link ],
+        'resultType' => 'scalar',
+        'result' => {
+          'links' => [],
+          'extensions' => { }
+        },
+        'extensions' => { }
+      }
+
+      response['resultType'] = action_description.kind_result_type.to_s
+      if result.nil?
+        response['result'] = nil
+      else
+        case action_description.kind_result_type
+          when :scalar
+            response['resultType'] = 'scalar'
+            response['result']['value'] = encode_value(result, action_description.result_type)
+            response['result']['links'] = [ link_to(:return_type, '/domain-types/int', :domain_type) ]
+          when :object
+            response['resultType'] = 'object'
+            response['result'] = result.representation
+          when :proto_object
+            response['resultType'] = 'object'
+            response['result'] = result
+          when :list
+            response['resultType'] = 'list'
+            response['result']['links'] =
+              [ link_to(:element_type, "/domain-types/#{action_description.result_type.to_s}", :domain_type) ]
+            list = []
+            result.each do |member|
+              member_link = link_to(:element, "/objects/#{action_description.result_type.to_s}/#{member.rs_instance_id}", :object)
+              member_link['title'] = member.title
+              list << member_link
+            end
+            response['result']['value'] = list
+        end
+      end
+
+      response.to_json
+    end
+
+    def action_return_type(action)
+      RestfulObjects::DomainModel.current.types[self.class.name].actions[action].result_type
+    end
+
+    private
+
+      def rs_invoke_link(action)
+        invoke_link = is_service ?
+          link_to(:invoke, "/services/#{rs_type.id}/actions/#{action}/invoke", :action_result, action: action)
+          :
+          link_to(:invoke, "/objects/#{rs_type.id}/#{object_id}/actions/#{action}/invoke", :action_result, action: action)
+        invoke_link['arguments'] = {}
+        rs_type.actions[action].parameters.each do |name, action|
+          invoke_link['arguments'][name] = { 'value' => nil }
+        end
+        invoke_link
+      end
+
+      def rs_action_link(action)
+        if is_service
+          link_to(:self, "/services/#{self.class.name}/actions/#{action}", :object_action)
+        else
+          link_to(:self, "/objects/#{self.class.name}/#{object_id}/actions/#{action}", :object_action)
+        end
+      end
+
+      def rs_action_up_link
+        if is_service
+          link_to(:up, "/services/#{rs_type.id}", :object)
+        else
+          link_to(:up, "/objects/#{self.class.name}/#{object_id}", :object)
+        end
+      end
+  end
+end

data/lib/restful_objects/object_collections.rb

@@ -0,0 +1,84 @@
+module RestfulObjects
+  module ObjectCollections
+    def collections_members
+      members = {}
+      rs_type.collections.each do |name, collection|
+        members[name] = {
+          'memberType' => 'collection',
+          'size' => rs_type.collections.count,
+          'links' => [
+            link_to(:details, "/objects/#{self.class.name}/#{object_id}/collections/#{name}", :object_collection, collection: name)
+          ],
+          'extensions' => collection.metadata
+        }
+      end
+      members
+    end
+
+    def get_collection_as_json(collection)
+      raise "collection not exists" if not rs_model.types[self.class.name].collections.include?(collection)
+
+      value = []
+      send(collection.to_sym).each do |object|
+        link = link_to(:value, "/objects/#{object.rs_type.id}/#{object.rs_instance_id}", :object, method: 'GET', collection: collection)
+        link['title'] = object.title
+        value << link
+      end
+
+      representation = {
+        'id' => collection,
+        'value' => value,
+        'links' => [
+            link_to(:self, "/objects/#{rs_type.id}/#{rs_instance_id}/collections/#{collection}", :object_collection),
+            link_to(:up, "/objects/#{rs_type.id}/#{rs_instance_id}", :object)
+          ],
+        'extensions' => rs_type.collections[collection].metadata
+      }
+
+      if not rs_model.types[self.class.name].collections[collection].read_only then
+        add_to_link = link_to(:add_to, "/objects/#{rs_type.id}/#{rs_instance_id}/collections/#{collection}",
+                              :object_collection, method: 'PUT', collection: collection)
+        add_to_link['arguments'] = { 'value' => nil }
+        remove_from_link = link_to(:remove_from, "/objects/#{rs_type.id}/#{rs_instance_id}/collections/#{collection}",
+                                   :object_collection, method: 'DELETE', collection: collection)
+        remove_from_link['arguments'] = { 'value' => nil }
+        representation['links'].concat [ add_to_link, remove_from_link ]
+      else
+        representation['disabledReason'] =
+          rs_model.types[self.class.name].collections[collection].disabled_reason
+      end
+
+      representation.to_json
+    end
+
+    def add_to_collection(collection, json)
+      raise "collection not exists" if not rs_model.types[self.class.name].collections.include?(collection)
+      href_value = JSON.parse(json)['value']['href']
+      match = Regexp.new(".*/objects/(?<domain-type>\\w*)/(?<object-id>\\d*)").match(href_value)
+      raise "Invalid request format" if not match
+      domain_type = match['domain-type']
+      id = match['object-id'].to_i
+      raise "Value does not exists" if not rs_model.objects.include?(id)
+      raise "Domain-type does not exists" if not rs_model.types.include?(domain_type)
+
+      send(collection.to_sym).push(rs_model.objects[id])
+
+      get_collection_as_json(collection)
+    end
+
+    def delete_from_collection(collection, json)
+      raise "collection not exists" if not rs_model.types[self.class.name].collections.include?(collection)
+      href_value = JSON.parse(json)['value']['href']
+      match = Regexp.new(".*/objects/(?<domain-type>\\w*)/(?<object-id>\\d*)").match(href_value)
+      raise "Invalid request format" if not match
+      domain_type = match['domain-type']
+      id = match['object-id'].to_i
+      raise "Value does not exists" if not rs_model.objects.include?(id)
+      raise "Domain-type does not exists" if not rs_model.types.include?(domain_type)
+
+      send(collection.to_sym).delete(rs_model.objects[id])
+
+      get_collection_as_json(collection)
+    end
+  end
+end

data/lib/restful_objects/object_list.rb

@@ -0,0 +1,16 @@
+module RestfulObjects
+  class ObjectList
+    extend Forwardable
+
+    def initialize(base_url)
+      @objects = Hash.new
+      @base_url = base_url
+    end
+
+    def register(instance, service = false)
+      @objects[instance.object_id] = instance
+    end
+
+    def_delegators :@objects, :[], :each, :include?, :count, :clear, :empty?, :keys, :values
+  end
+end

data/lib/restful_objects/object_macros.rb

@@ -0,0 +1,35 @@
+module RestfulObjects
+  module ObjectMacros
+    def property(name, type, options = {})
+      RestfulObjects::DomainModel.current.types[self.name].properties.add(name.to_s, type, options)
+      if options[:read_only]
+        self.class_eval { attr_reader name }
+      else
+        if not options[:max_length]
+          self.class_eval { attr_accessor name }
+        else
+          self.class_eval do
+            attr_reader name
+
+            define_method "#{name}=".to_sym do |value|
+              raise "string max length exceeded" if value && value.length > options[:max_length]
+              instance_variable_set("@#{name}".to_sym, value)
+            end
+          end
+        end
+      end
+    end
+
+    def collection(name, type, options = {})
+      type = type.name if type.is_a? Class
+
+      RestfulObjects::DomainModel.current.types[self.name].collections.add(name.to_s, type, options)
+
+      self.class_eval { attr_reader name }
+    end
+
+    def action(name, result_type = :void, parameters = {}, options = {})
+      RestfulObjects::DomainModel.current.types[self.name].actions.add(name.to_s, result_type, parameters, options)
+    end
+  end
+end

data/lib/restful_objects/object_properties.rb

@@ -0,0 +1,78 @@
+module RestfulObjects
+  module ObjectProperties
+    def properties_members
+      members = {}
+      rs_type.properties.each do |name, property|
+        members[name] = {
+          'memberType' => 'property',
+          'value' => get_property_value(name),
+          'links' => [
+            link_to(:details, "/objects/#{self.class.name}/#{object_id}/properties/#{name}", :object_property, property: name)
+          ],
+          'extensions' => property.metadata
+        }
+
+        members[name]['disabledReason'] = property.disabled_reason if property.read_only
+      end
+      members
+    end
+
+    def get_property_as_json(property)
+      raise "Property not exists" if not rs_model.types[self.class.name].properties.include?(property)
+
+      representation = {
+        property =>
+          { 'value' => get_property_value(property),
+            'links' => [
+              link_to(:self, "/objects/#{self.class.name}/#{object_id}/properties/#{property}", :object_property),
+              link_to(:up, "/objects/#{self.class.name}/#{object_id}", :object) ],
+            'extensions' => rs_model.types[self.class.name].properties[property].metadata
+          }
+      }
+
+      if not rs_model.types[self.class.name].properties[property].read_only then
+        representation[property]['links'].concat [
+          link_to(:modify, "/objects/#{self.class.name}/#{object_id}/properties/#{property}", :object_property,
+            { property: property, method: 'PUT', arguments: { 'value' => nil } }),
+          link_to(:clear, "/objects/#{self.class.name}/#{object_id}/properties/#{property}", :object_property,
+            { property: property, method: 'DELETE'} ) ]
+      else
+        representation[property]['disabledReason'] =
+          rs_model.types[self.class.name].properties[property].disabled_reason
+      end
+
+      representation.to_json
+    end
+
+    def put_property_as_json(property, json)
+      raise "property not exists" if not rs_model.types[self.class.name].properties.include?(property)
+      raise "read-only property" if rs_model.types[self.class.name].properties[property].read_only
+
+      value = JSON.parse(json)['value']
+      set_property_value(property, value)
+      on_after_update if respond_to? :on_after_update
+      get_property_as_json(property)
+    end
+
+    def clear_property(property)
+      raise "property not exists" if not rs_model.types[self.class.name].properties.include?(property)
+      raise "read-only property" if rs_model.types[self.class.name].properties[property].read_only
+
+      send("#{property}=".to_sym, nil)
+      on_after_update if respond_to? :on_after_update
+      get_property_as_json(property)
+    end
+
+    def property_type(property)
+      rs_model.types[self.class.name].properties[property].return_type
+    end
+
+    def get_property_value(property)
+      encode_value(send(property.to_sym), property_type(property))
+    end
+
+    def set_property_value(property, value)
+      send("#{property}=".to_sym, decode_value(value, property_type(property)))
+    end
+  end
+end

data/lib/restful_objects/parameter_description.rb

@@ -0,0 +1,60 @@
+module RestfulObjects
+  class ParameterDescription
+    include LinkGenerator
+
+    attr_reader :id, :name, :number, :kind_type, :type
+    attr_accessor :friendly_name, :description, :optional, :max_length, :pattern, :format
+
+    def initialize(id, definition, number)
+      @id = id
+      @name = id
+
+      if definition.is_a? Array # [type, options]
+        if [:string, :int, :decimal, :date, :blob].include?(definition.first) # scalar
+          @kind_type = :scalar
+          @type = definition.first
+        elsif definition.first.is_a?(Class) # object type
+          @kind_type = :object
+          @type = definition.first.name
+        elsif definition.first.is_a?(Strign) # object type
+          @kind_type = :object
+          @type = definition.first
+        else
+          raise "unssuported parameter definition type #{definition.class}"
+        end
+        options = definition.last
+      elsif definition.is_a? Symbol # scalar type
+        @kind_type = :scalar
+        @type = definition
+        raise "result type for scalar '#{@type}' unssuported" if not [:string, :int, :decimal, :date, :blob].include?(@type)
+      elsif definition.is_a? String # object type
+        @kind_type = :object
+        @type = definition
+      elsif definition.is_a? Class # object type
+        @kind_type = :object
+        @type = definition.to_s
+      else
+        raise "unssuported parameter definition type #{definition.class}"
+      end
+
+      options ||= {}
+      @number = options[:number] || number
+      @friendly_name = options[:friendly_name] || id
+      @description = options[:description] || id
+      @optional = options[:optional].nil? ? true : options[:optional]
+      @max_length = options[:max_length]
+      @pattern = options[:pattern]
+    end
+
+    def metadata
+      result = { 'friendlyName' => friendly_name,
+                 'description' => description,
+                 'optional' => optional,
+                 'returnType' => type }
+      result['maxLength'] = max_length if max_length
+      result['pattern'] = pattern if pattern
+      result['format'] = format if format
+      result
+    end
+  end
+end

data/lib/restful_objects/parameter_description_list.rb

@@ -0,0 +1,15 @@
+module RestfulObjects
+  class ParameterDescriptionList
+    extend Forwardable
+
+    def initialize
+      @parameters = Hash.new
+    end
+
+    def add(id, definition)
+      @parameters[id] = ParameterDescription.new(id, definition, count + 1)
+    end
+
+    def_delegators :@parameters, :[], :each, :include?, :count, :empty?
+  end
+end

data/lib/restful_objects/property_list.rb

@@ -0,0 +1,17 @@
+module RestfulObjects
+  class PropertyList
+    extend Forwardable
+
+    def initialize(domain_type)
+      @properties = Hash.new
+      @domain_type = domain_type
+    end
+
+    def add(id, return_type, options = {})
+      options[:member_order] ||= count + 1
+      @properties[id] = PropertyDescription.new(id, @domain_type, return_type, options)
+    end
+
+    def_delegators :@properties, :[], :each, :include?, :count, :empty?
+  end
+end