safrano 0.4.2 → 0.5.0

data/lib/odata/edm/primitive_types.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Safrano
+  # Type mapping DB --> Edm
+  #  TypeMap = {"INTEGER" => "Edm.Int32" , "TEXT" => "Edm.String",
+  # "STRING" => "Edm.String"}
+  # Todo: complete mapping... this is just for the most common ones
+
+  # TODO: use Sequel GENERIC_TYPES: -->
+  # Constants
+  # GENERIC_TYPES = %w'String Integer Float Numeric BigDecimal Date DateTime
+  # Time File TrueClass FalseClass'.freeze
+  # Classes specifying generic types that Sequel will convert to
+  # database-specific types.
+  DB_TYPE_STRING_RGX = /\ACHAR\s*\(\d+\)\z/.freeze
+
+  # used in $metadata
+  # cf. Sequel Database column_schema_default_to_ruby_value
+  #                     schema_column_type
+  # https://www.odata.org/documentation/odata-version-2-0/overview/
+  def self.default_edm_type(ruby_type:)
+    case ruby_type
+    when :integer
+      'Edm.Int32'
+    when :string
+      'Edm.String'
+    when :date, :datetime,
+      'Edm.DateTime'
+    when :time
+      'Edm.Time'
+    when :boolean
+      'Edm.Boolean'
+    when :float
+      'Edm.Double'
+    when :decimal
+      'Edm.Decimal'
+    when :blob
+      'Edm.Binary'
+    end
+  end
+
+  # use Edm twice so that we can do include Safrano::Edm and then
+  # have Edm::Int32 etc... availabe
+  # and we can have Edm::String different from ::String
+  module Edm
+    module Edm
+      module OutputClassMethods
+        def type_name
+          "Edm.#{name.split('::').last}"
+        end
+
+        def odata_collection(array)
+          array
+        end
+
+        def odata_value(instance)
+          instance
+        end
+      end
+
+      class Null < NilClass
+        extend OutputClassMethods
+        # nil --> null convertion is done by to_json
+        def self.odata_value(instance)
+          nil
+        end
+
+        def self.convert_from_urlparam(v)
+          return Contract::NOK unless (v == 'null')
+
+          Contract.valid(nil)
+        end
+      end
+
+      # Binary is a String with the BINARY encoding
+      class Binary < String
+        extend OutputClassMethods
+
+        def self.convert_from_urlparam(v)
+          Contract.valid(v.dup.force_encoding('BINARY'))
+        end
+      end
+
+      # an object alwys evaluates to
+      #  true ([true, anything not false & not nil objs])
+      #  or false([nil, false])
+      class Boolean < Object
+        extend OutputClassMethods
+        def Boolean.odata_value(instance)
+          instance ? true : false
+        end
+
+        def self.odata_collection(array)
+          array.map { |v| odata_value(v) }
+        end
+
+        def self.convert_from_urlparam(v)
+          return Contract::NOK unless ['true', 'false'].include?(v)
+
+          Contract.valid(v == 'true')
+        end
+      end
+
+      # Bytes are usualy represented as Intger in ruby,
+      # eg.String.bytes --> Array of ints
+      class Byte < Integer
+        extend OutputClassMethods
+
+        def self.convert_from_urlparam(v)
+          return Contract::NOK unless ((bytev = v.to_i) < 256)
+
+          Contract.valid(bytev)
+        end
+      end
+
+      class DateTime < ::DateTime
+        extend OutputClassMethods
+        def DateTime.odata_value(instance)
+          instance.to_datetime
+        end
+
+        def self.odata_collection(array)
+          array.map { |v| odata_value(v) }
+        end
+
+        def self.convert_from_urlparam(v)
+          begin
+            Contract.valid(DateTime.parse(v))
+          rescue
+            return convertion_error(v)
+          end
+        end
+      end
+
+      class String < ::String
+        extend OutputClassMethods
+
+        def self.convert_from_urlparam(v)
+          Contract.valid(v)
+        end
+      end
+
+      class Int32 < Integer
+        extend OutputClassMethods
+
+        def self.convert_from_urlparam(v)
+          return Contract::NOK unless (ret = number_or_nil(v))
+
+          Contract.valid(ret)
+        end
+      end
+
+      class Int64 < Integer
+        extend OutputClassMethods
+
+        def self.convert_from_urlparam(v)
+          return Contract::NOK unless (ret = number_or_nil(v))
+
+          Contract.valid(ret)
+        end
+      end
+
+      class Double < Float
+        extend OutputClassMethods
+
+        def self.convert_from_urlparam(v)
+          begin
+            Contract.valid(v.to_f)
+          rescue
+            return Contract::NOK
+          end
+        end
+      end
+    end
+  end
+end
+
+# include Safrano
+
+# x = Edm::String.new('xxx')
+
+# pp x

data/lib/odata/entity.rb

@@ -1,44 +1,26 @@
+# frozen_string_literal: true
+
 require 'json'
 require 'rexml/document'
 require 'safrano.rb'
-require 'odata/collection.rb' # required for  self.class.entity_type_name ??
+require 'odata/model_ext.rb' # required for  self.class.entity_type_name ??
 require_relative 'navigation_attribute'
 
-module OData
+module Safrano
   # this will be mixed in the  Model classes (subclasses of Sequel Model)
   module EntityBase
     attr_reader :params
-    attr_reader :uribase
 
-    include EntityBase::NavigationInfo
+    include Safrano::NavigationInfo
 
     # methods related to transitions to next state (cf. walker)
     module Transitions
       def allowed_transitions
-        alltr = [
-          Safrano::TransitionEnd,
-          Safrano::TransitionCount,
-          Safrano::TransitionLinks,
-          Safrano::TransitionValue,
-          Safrano::Transition.new(self.class.transition_attribute_regexp,
-                                  trans: 'transition_attribute')
-        ]
-        if (ncurgx = self.class.nav_collection_url_regexp)
-          alltr <<
-            Safrano::Transition.new(%r{\A/(#{ncurgx})(.*)\z},
-                                    trans: 'transition_nav_collection')
-
-        end
-        if (neurgx = self.class.nav_entity_url_regexp)
-          alltr <<
-            Safrano::Transition.new(%r{\A/(#{neurgx})(.*)\z},
-                                    trans: 'transition_nav_entity')
-        end
-        alltr
+        self.class.entity_allowed_transitions
       end
 
       def transition_end(_match_result)
-        [nil, :end]
+        Safrano::Transition::RESULT_END
       end
 
       def transition_count(_match_result)
@@ -56,8 +38,7 @@ module OData
 
       def transition_attribute(match_result)
         attrib = match_result[1]
-        #        [values[attrib.to_sym], :run]
-        [OData::Attribute.new(self, attrib), :run]
+        [Safrano::Attribute.new(self, attrib), :run]
       end
 
       def transition_nav_collection(match_result)
@@ -69,10 +50,20 @@ module OData
         attrib = match_result[1]
         [get_related_entity(attrib), :run]
       end
+
+      def transition_invalid_attribute(match_result)
+        invalid_attrib = match_result[1]
+        [nil, :error, Safrano::ErrorNotFoundSegment.new(invalid_attrib)]
+      end
     end
 
     include Transitions
 
+    # for testing only?
+    def ==(other)
+      ((self.class.type_name == other.class.type_name) and (@values == other.values))
+    end
+
     def nav_values
       @nav_values = {}
 
@@ -90,26 +81,27 @@ module OData
       @nav_coll
     end
 
-    def uri(uriba)
-      "#{uriba}/#{self.class.entity_set_name}(#{pk_uri})"
+    def uri
+      @odata_pk ||= "(#{pk_uri})"
+      "#{self.class.uri}#{@odata_pk}"
     end
+
     D = 'd'.freeze
     DJ_OPEN = '{"d":'.freeze
     DJ_CLOSE = '}'.freeze
 
     # Json formatter for a single entity (probably OData V1/V2 like)
-    def to_odata_json(service:)
-      template = self.class.output_template(@uparms)
-      innerj = service.get_entity_odata_h(entity: self,
-                                          template: template,
-                                          uribase: @uribase).to_json
+    def to_odata_json(request:)
+      template = self.class.output_template(expand_list: @uparms.expand.template,
+                                            select: @uparms.select)
+      innerj = request.service.get_entity_odata_h(entity: self,
+                                                  template: template).to_json
       "#{DJ_OPEN}#{innerj}#{DJ_CLOSE}"
     end
 
     # Json formatter for a single entity reached by navigation $links
     def to_odata_onelink_json(service:)
-      innerj = service.get_entity_odata_link_h(entity: self,
-                                               uribase: @uribase).to_json
+      innerj = service.get_entity_odata_link_h(entity: self).to_json
       "#{DJ_OPEN}#{innerj}#{DJ_CLOSE}"
     end
 
@@ -120,36 +112,11 @@ module OData
       selvals
     end
 
-    # needed for proper datetime output
-    # TODO: design/performance
-    def casted_values(cols = nil)
-      vals = case cols
-             when nil
-               values_for_odata
-             else
-               selected_values_for_odata(cols)
-             end
-
-      # WARNING; this code is duplicated in attribute.rb
-      # (and the inverted transformation is in test/client.rb)
-      # will require a more systematic solution some day
-
-      vals.transform_values! do |v|
-        case v
-        when Time
-          # try to get back the database time zone and value
-          (v + v.gmt_offset).utc.to_datetime
-        else
-          v
-        end
-      end
-    end
-
-    # post paylod expects the new entity in an array
-    def to_odata_post_json(service:)
-      innerj = service.get_coll_odata_h(array: [self],
-                                        template: self.class.default_template,
-                                        uribase: @uribase).to_json
+    # some clients wrongly expect post payload with the new entity in an array
+    # TODO quirks array mode !
+    def to_odata_array_json(request:)
+      innerj = request.service.get_coll_odata_h(array: [self],
+                                                template: self.class.default_template).to_json
       "#{DJ_OPEN}#{innerj}#{DJ_CLOSE}"
     end
 
@@ -159,29 +126,34 @@ module OData
 
     def copy_request_infos(req)
       @params = req.params
-      @uribase = req.uribase
       @do_links = req.walker.do_links
-      @uparms = UrlParameters4Single.new(@params)
+      @uparms = UrlParameters4Single.new(self, @params)
     end
 
-    # Finally Process REST verbs...
-    def odata_get(req)
-      copy_request_infos(req)
+    def odata_get_output(req)
       if req.walker.media_value
         odata_media_value_get(req)
       elsif req.accept?(APPJSON)
+        # json is default content type so we dont need to specify it here again
         if req.walker.do_links
-          [200, CT_JSON, [to_odata_onelink_json(service: req.service)]]
+          [200, EMPTY_HASH, [to_odata_onelink_json(service: req.service)]]
         else
-          [200, CT_JSON, [to_odata_json(service: req.service)]]
+          [200, EMPTY_HASH, [to_odata_json(request: req)]]
         end
       else # TODO: other formats
         415
       end
     end
 
+    # Finally Process REST verbs...
+    def odata_get(req)
+      copy_request_infos(req)
+      @uparms.check_all.tap_valid { return odata_get_output(req) }
+             .tap_error { |e| return e.odata_get(req) }
+    end
+
     DELETE_REL_AND_ENTY = lambda do |entity, assoc, parent|
-      OData.remove_nav_relation(assoc, parent)
+      Safrano.remove_nav_relation(assoc, parent)
       entity.destroy(transaction: false)
     end
 
@@ -227,7 +199,6 @@ module OData
         odata_media_value_put(req)
       elsif req.accept?(APPJSON)
         data = JSON.parse(req.body.read)
-        @uribase = req.uribase
         data.delete('__metadata')
 
         if req.in_changeset
@@ -249,14 +220,12 @@ module OData
 
         # validate payload column names
         if (invalid = self.class.invalid_hash_data?(data))
-          ::OData::Request::ON_CGST_ERROR.call(req)
+          ::Safrano::Request::ON_CGST_ERROR.call(req)
           return [422, EMPTY_HASH, ['Invalid attribute name: ', invalid.to_s]]
         end
         # TODO: check values/types
 
         my_data_fields = self.class.data_fields
-        @uribase = req.uribase
-        #      if req.accept?('application/json')
 
         if req.in_changeset
           set_fields(data, my_data_fields, missing: :skip)
@@ -269,73 +238,11 @@ module OData
       end
     end
 
-    # redefinitions of the main methods for a navigated collection
-    # (eg. all Books of Author[2]  is Author[2].Books.all )
-    module NavigationRedefinitions
-      def all
-        @child_method.call
-      end
-
-      def count
-        @child_method.call.count
-      end
-
-      def dataset
-        @child_dataset_method.call
-      end
-
-      def navigated_dataset
-        @child_dataset_method.call
-      end
-
-      def each
-        y = @child_method.call
-        y.each { |enty| yield enty }
-      end
-
-      # TODO: design... this is not DRY
-      def slug_field
-        superclass.slug_field
-      end
-
-      def type_name
-        superclass.type_name
-      end
-
-      def media_handler
-        superclass.media_handler
-      end
-
-      def default_template
-        superclass.default_template
-      end
-
-      def to_a
-        y = @child_method.call
-        y.to_a
-      end
-    end
-    # GetRelated that returns a anonymous Class (ie. representing a collection)
-    # subtype of the related object Class  ( childklass )
+    # GetRelated that returns a collection object representing
+    # wrapping  the related object Class  ( childklass )
     # (...to_many relationship )
     def get_related(childattrib)
-      parent = self
-      childklass = self.class.nav_collection_attribs[childattrib]
-      Class.new(childklass) do
-        # this makes use of Sequel's Model relationships; eg this is
-        # 'Race[12].Edition'
-        # where Race[12] would be our self and 'Edition' is the
-        # childattrib(collection)
-        @child_method = parent.method(childattrib.to_sym)
-        @child_dataset_method = parent.method("#{childattrib}_dataset".to_sym)
-        @nav_parent = parent
-        @navattr_reflection = parent.class.association_reflections[childattrib.to_sym]
-        prepare_pk
-        prepare_fields
-        # Now in this anonymous Class we can refine the "all, count and []
-        # methods, to take into account the relationship
-        extend NavigationRedefinitions
-      end
+      Safrano::OData::NavigatedCollection.new(childattrib, self)
     end
 
     # GetRelatedEntity that returns an single related Entity
@@ -350,27 +257,28 @@ module OData
       # then we return a Nil... wrapper object. This object then
       # allows to receive a POST operation that would actually create the nav attribute entity
 
-      ret = method(childattrib.to_sym).call || OData::NilNavigationAttribute.new
+      ret = method(childattrib.to_sym).call || Safrano::NilNavigationAttribute.new
 
       ret.set_relation_info(self, childattrib)
 
       ret
     end
   end
-  # end of module ODataEntity
+
+  # end of module SafranoEntity
   module Entity
     include EntityBase
   end
 
   module NonMediaEntity
     # non media entity metadata for json h
-    def metadata_h(uribase:)
-      {   uri: uri(uribase),
+    def metadata_h
+      {   uri: uri,
           type: type_name }
     end
 
     def values_for_odata
-      values.dup
+      values
     end
 
     def odata_delete(req)
@@ -378,7 +286,7 @@ module OData
         #        delete
         begin
           odata_delete_relation_and_entity(req, @navattr_reflection, @nav_parent)
-          [200, CT_JSON, [{ 'd' => req.service.get_emptycoll_odata_h }.to_json]]
+          [200, EMPTY_HASH, [{ 'd' => req.service.get_emptycoll_odata_h }.to_json]]
         rescue SequelAdapterError => e
           BadRequestSequelAdapterError.new(e).odata_get(req)
         end
@@ -398,35 +306,55 @@ module OData
     end
   end
 
+  module MappingBeforeOutput
+    # needed for proper datetime output
+    def casted_values(cols = nil)
+      vals = case cols
+             when nil
+               # we need to dup the model values as we need to change it before passing to_json,
+               # but we dont want to interfere with Sequel's owned data
+               # (eg because then in worst case it could happen that we write back changed values to DB)
+               values_for_odata.dup
+             else
+               selected_values_for_odata(cols)
+             end
+      self.class.time_cols.each { |tc| vals[tc] = vals[tc]&.iso8601 if vals.key?(tc) }
+      vals
+    end
+  end
+  module NoMappingBeforeOutput
+    # current model does not have eg. Time fields--> no special mapping, just to_json is fine
+    # --> we can use directly the model.values (values_for_odata) withoud dup'ing it as we dont
+    # need to change it, just output as is
+    def casted_values(cols = nil)
+      case cols
+      when nil
+        values_for_odata
+      else
+        selected_values_for_odata(cols)
+      end
+    end
+  end
+
   module MediaEntity
     # media entity metadata for json h
-    def metadata_h(uribase:)
-      {   uri: uri(uribase),
+    def metadata_h
+      {   uri: uri,
           type: type_name,
-          media_src: media_src(uribase),
-          edit_media: edit_media(uribase),
+          media_src: media_src,
+          edit_media: edit_media,
           content_type: @values[:content_type] }
     end
 
-    def media_src(uribase)
+    def media_src
       version = self.class.media_handler.ressource_version(self)
-      "#{uri(uribase)}/$value?version=#{version}"
-    end
-
-    def edit_media(uribase)
-      "#{uri(uribase)}/$value"
+      "#{uri}/$value?version=#{version}"
     end
 
-    # directory where to put/find the media files for this entity-type
-    def klass_dir
-      type_name
+    def edit_media
+      "#{uri}/$value"
     end
 
-    #    # this is just ModelKlass/pk as a single string
-    #    def qualified_media_path_id
-    #      "#{self.class}/#{media_path_id}"
-    #    end
-
     def values_for_odata
       ret = values.dup
       ret.delete(:content_type)
@@ -443,7 +371,7 @@ module OData
         # delete the relation(s)  to parent(s) (if any) and then entity
         odata_delete_relation_and_entity(req, @navattr_reflection, @nav_parent)
         # result
-        [200, CT_JSON, [{ 'd' => req.service.get_emptycoll_odata_h }.to_json]]
+        [200, EMPTY_HASH, [{ 'd' => req.service.get_emptycoll_odata_h }.to_json]]
       else # TODO: other formats
         415
       end
@@ -464,11 +392,14 @@ module OData
           set_fields(emdata, model.data_fields, missing: :skip)
           save(transaction: false)
         else
+
           update_fields(emdata, model.data_fields, missing: :skip)
+
         end
         model.media_handler.replace_file(data: data,
                                          entity: self,
                                          filename: filename)
+
         ARY_204_EMPTY_HASH_ARY
       end
     end
@@ -494,8 +425,11 @@ module OData
   module EntityMultiPK
     include Entity
     def pk_uri
-      # pk_hash is provided by Sequel
-      pk_hash.map { |k, v| "#{k}='#{v}'" }.join(COMMA)
+      pku = +''
+      self.class.odata_upk_parts.each_with_index { |upart, i|
+        pku = "#{pku}#{upart}#{pk[i]}"
+      }
+      pku
     end
 
     def media_path_id
@@ -506,5 +440,22 @@ module OData
       pk_hash.values
     end
   end
-end
-# end of Module OData
+
+  module EntityCreateStandardOutput
+    # Json formatter for a create  entity POST call / Standard version; return as json object
+    def to_odata_create_json(request:)
+      # TODO Perf: reduce method call overhead
+      # we added this redirection for readability and flexibility
+      to_odata_json(request: request)
+    end
+  end
+
+  module EntityCreateArrayOutput
+    # Json formatter for a create  entity POST call Array version
+    def to_odata_create_json(request:)
+      # TODO Perf: reduce method call overhead
+      # we added this redirection for readability and flexibility
+      to_odata_array_json(request: request)
+    end
+  end
+end # end of Module OData