safrano 0.3.4 → 0.4.4

data/lib/odata/common_logger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   class ODataCommonLogger < CommonLogger
     def call(env)
@@ -5,21 +7,46 @@ module Rack
       super
     end
 
+    # Handle https://github.com/rack/rack/pull/1526
+    # new in Rack 2.2.2 : Format has now 11 placeholders instead of 10
+
+    MSG_FUNC = if FORMAT.count('%') == 10
+                 lambda { |env, length, status, began_at|
+                   FORMAT % [
+                     env['HTTP_X_FORWARDED_FOR'] || env['REMOTE_ADDR'] || '-',
+                     env['REMOTE_USER'] || '-',
+                     Time.now.strftime('%d/%b/%Y:%H:%M:%S %z'),
+                     env[REQUEST_METHOD],
+                     env[SCRIPT_NAME] + env[PATH_INFO],
+                     env[QUERY_STRING].empty? ? '' : "?#{env[QUERY_STRING]}",
+                     env[SERVER_PROTOCOL],
+                     status.to_s[0..3],
+                     length,
+                     Utils.clock_time - began_at
+                   ]
+                 }
+               elsif FORMAT.count('%') == 11
+                 lambda { |env, length, status, began_at|
+                   FORMAT % [
+                     env['HTTP_X_FORWARDED_FOR'] || env['REMOTE_ADDR'] || '-',
+                     env['REMOTE_USER'] || '-',
+                     Time.now.strftime('%d/%b/%Y:%H:%M:%S %z'),
+                     env[REQUEST_METHOD],
+                     env[SCRIPT_NAME],
+                     env[PATH_INFO],
+                     env[QUERY_STRING].empty? ? '' : "?#{env[QUERY_STRING]}",
+                     env[SERVER_PROTOCOL],
+                     status.to_s[0..3],
+                     length,
+                     Utils.clock_time - began_at
+                   ]
+                 }
+               end
+
     def batch_log(env, status, header, began_at)
       length = extract_content_length(header)
 
-      msg = FORMAT % [
-        env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-",
-        env["REMOTE_USER"] || "-",
-        Time.now.strftime("%d/%b/%Y:%H:%M:%S %z"),
-        env[REQUEST_METHOD],
-        env[PATH_INFO],
-        env[QUERY_STRING].empty? ? "" : "?#{env[QUERY_STRING]}",
-        env[SERVER_PROTOCOL],
-        status.to_s[0..3],
-        length,
-        Utils.clock_time - began_at
-      ]
+      msg = MSG_FUNC.call(env, length, status, began_at)
 
       logger = @logger || env[RACK_ERRORS]
       # Standard library logger doesn't support write but it supports << which actually

data/lib/odata/complex_type.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Safrano
+  module FunctionImport
+    class ResultDefinition
+      D = 'd'.freeze
+      DJ_OPEN = '{"d":'.freeze
+      DJ_CLOSE = '}'.freeze
+      METAK = '__metadata'.freeze
+      TYPEK = 'type'.freeze
+      VALUEK = 'value'.freeze
+      RESULTSK = 'results'.freeze
+      COLLECTION = 'Collection'.freeze
+
+      def initialize(klassmod)
+        @klassmod = klassmod
+      end
+
+      def to_odata_json(result, _req)
+        "#{DJ_OPEN}#{result.odata_h.to_json}#{DJ_CLOSE}"
+      end
+
+      def type_metadata
+        @klassmod.type_name
+      end
+    end
+    class ResultAsComplexType < ResultDefinition
+    end
+    class ResultAsComplexTypeColl < ResultDefinition
+      def type_metadata
+        "Collection(#{@klassmod.type_name})"
+      end
+
+      def to_odata_json(coll, _req)
+        "#{DJ_OPEN}#{{ RESULTSK => coll.map { |c| c.odata_h } }.to_json}#{DJ_CLOSE}"
+      end
+    end
+    class ResultAsEntity < ResultDefinition
+      def to_odata_json(result_entity, req)
+        result_entity.instance_exec do
+          copy_request_infos(req)
+          to_odata_json(request: req)
+        end
+      end
+    end
+    class ResultAsEntityColl < ResultDefinition
+      def type_metadata
+        "Collection(#{@klassmod.type_name})"
+      end
+
+      def to_odata_json(result_dataset, req)
+        coll = Safrano::OData::Collection.new(@klassmod)
+        coll.instance_exec do
+          @params = req.params
+          initialize_dataset(result_dataset)
+        end
+        coll.to_odata_json(request: req)
+      end
+    end
+    class ResultAsPrimitiveType < ResultDefinition
+      def to_odata_json(result, _req)
+        { D => { METAK => { TYPEK => type_metadata },
+                 VALUEK => @klassmod.odata_value(result) } }.to_json
+      end
+    end
+    class ResultAsPrimitiveTypeColl < ResultDefinition
+      def type_metadata
+        "Collection(#{@klassmod.type_name})"
+      end
+
+      def to_odata_json(result, _req)
+        { D => { METAK => { TYPEK => type_metadata },
+                 RESULTSK => @klassmod.odata_collection(result) } }.to_json
+      end
+    end
+  end
+
+  # a generic Struct  like ruby's standard Struct, but implemented with a
+  # @values Hash, similar to Sequel models and
+  # with added OData functionality
+  class ComplexType
+    attr_reader :values
+
+    @namespace = nil
+    def self.namespace
+      @namespace
+    end
+
+    def self.props
+      @props
+    end
+
+    def self.type_name
+      "#{@namespace}.#{self.to_s}"
+    end
+
+    def initialize
+      @values = {}
+    end
+    METAK = '__metadata'.freeze
+    TYPEK = 'type'.freeze
+
+    def odata_h
+      ret = { METAK => { TYPEK => self.class.type_name } }
+      @values.each { |k, v|
+        ret[k] = if v.respond_to? :odata_h
+                   v.odata_h
+                 else
+                   v
+                 end
+      }
+      ret
+    end
+
+    def self.return_as_collection_descriptor
+      FunctionImport::ResultAsComplexTypeColl.new(self)
+    end
+
+    def self.return_as_instance_descriptor
+      FunctionImport::ResultAsComplexType.new(self)
+    end
+
+    # add metadata xml to the passed REXML schema object
+    def self.add_metadata_rexml(schema)
+      ctty = schema.add_element('ComplexType', 'Name' => to_s)
+
+      # with their properties
+      @props.each do |prop, rbtype|
+        attrs = { 'Name' => prop.to_s,
+                  'Type' => rbtype.type_name }
+        ctty.add_element('Property', attrs)
+      end
+      ctty
+    end
+  end
+
+  def Safrano.ComplexType(**props)
+    Class.new(Safrano::ComplexType) do
+      @props = props
+      props.each { |a, klassmod|
+        asym = a.to_sym
+        define_method(asym) do @values[asym] end
+        define_method("#{a}=") do |val| @values[asym] = val end
+      }
+      define_method :initialize do |*p, **kwvals|
+        super()
+        p.zip(props.keys).each { |val, a| @values[a] = val } if p
+        kwvals.each { |a, val| @values[a] = val if props.key?(a) } if kwvals
+      end
+    end
+  end
+end

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,41 +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 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)
@@ -53,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)
@@ -66,17 +50,26 @@ 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 = {}
 
       self.class.nav_entity_attribs&.each_key do |na_str|
         @nav_values[na_str.to_sym] = send(na_str)
       end
-
       @nav_values
     end
 
@@ -88,43 +81,42 @@ 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
-    DJopen = '{"d":'.freeze
-    DJclose = '}'.freeze
+    DJ_OPEN = '{"d":'.freeze
+    DJ_CLOSE = '}'.freeze
+
     # Json formatter for a single entity (probably OData V1/V2 like)
-    def to_odata_json(service:)
-      innerj = service.get_entity_odata_h(entity: self,
-                                          expand: @params['$expand'],
-                                          #     links: @do_links,
-                                          uribase: @uribase).to_json
-      "#{DJopen}#{innerj}#{DJclose}"
+    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
 
-    # needed for proper datetime output
-    # TODO design/performance
-    def casted_values
-      # 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
-      values_for_odata.transform_values! { |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
-      }
+    # 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).to_json
+      "#{DJ_OPEN}#{innerj}#{DJ_CLOSE}"
+    end
+
+    def selected_values_for_odata(cols)
+      allvals = values_for_odata
+      selvals = {}
+      cols.map(&:to_sym).each { |k| selvals[k] = allvals[k] if allvals.key?(k) }
+      selvals
     end
 
     # post paylod expects the new entity in an array
     def to_odata_post_json(service:)
       innerj = service.get_coll_odata_h(array: [self],
-                                        uribase: @uribase).to_json
-      "#{DJopen}#{innerj}#{DJclose}"
+                                        template: self.class.default_template).to_json
+      "#{DJ_OPEN}#{innerj}#{DJ_CLOSE}"
     end
 
     def type_name
@@ -133,38 +125,59 @@ module OData
 
     def copy_request_infos(req)
       @params = req.params
-      @uribase = req.uribase
       @do_links = req.walker.do_links
+      @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)
-        [200, CT_JSON, [to_odata_json(service: req.service)]]
+        # json is default content type so we dont need to specify it here again
+        if req.walker.do_links
+          [200, EMPTY_HASH, [to_odata_onelink_json(service: req.service)]]
+        else
+          [200, EMPTY_HASH, [to_odata_json(request: req)]]
+        end
       else # TODO: other formats
         415
       end
     end
 
-    def odata_delete(req)
-      if req.accept?(APPJSON)
-        delete
-        [200, CT_JSON, [{ 'd' => req.service.get_emptycoll_odata_h }.to_json]]
-      else # TODO: other formats
-        415
+    # 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|
+      Safrano.remove_nav_relation(assoc, parent)
+      entity.destroy(transaction: false)
+    end
+
+    def odata_delete_relation_and_entity(req, assoc, parent)
+      if parent
+        if req.in_changeset
+          # in-changeset requests get their own transaction
+          DELETE_REL_AND_ENTY.call(self, assoc, parent)
+        else
+          db.transaction do
+            DELETE_REL_AND_ENTY.call(self, assoc, parent)
+          end
+        end
+      else
+        destroy(transaction: false)
       end
+    rescue StandardError => e
+      raise SequelAdapterError.new(e)
     end
 
     # TODO: differentiate between POST/PUT/PATCH/MERGE
     def odata_post(req)
-      data = JSON.parse(req.body.read)
-      @uribase = req.uribase
-
-      if req.accept?(APPJSON)
+      if req.walker.media_value
+        odata_media_value_put(req)
+      elsif req.accept?(APPJSON)
         data.delete('__metadata')
 
         if req.in_changeset
@@ -174,7 +187,7 @@ module OData
           update_fields(data, self.class.data_fields, missing: :skip)
         end
 
-        [202, {}, to_odata_post_json(service: req.service)]
+        [202, EMPTY_HASH, to_odata_post_json(service: req.service)]
       else # TODO: other formats
         415
       end
@@ -183,23 +196,20 @@ module OData
     def odata_put(req)
       if req.walker.media_value
         odata_media_value_put(req)
-      else
-        if req.accept?(APPJSON)
-          data = JSON.parse(req.body.read)
-          @uribase = req.uribase
-          data.delete('__metadata')
-
-          if req.in_changeset
-            set_fields(data, self.class.data_fields, missing: :skip)
-            save(transaction: false)
-          else
-            update_fields(data, self.class.data_fields, missing: :skip)
-          end
+      elsif req.accept?(APPJSON)
+        data = JSON.parse(req.body.read)
+        data.delete('__metadata')
 
-          [204, {}, []]
-        else # TODO: other formats
-          415
+        if req.in_changeset
+          set_fields(data, self.class.data_fields, missing: :skip)
+          save(transaction: false)
+        else
+          update_fields(data, self.class.data_fields, missing: :skip)
         end
+
+        ARY_204_EMPTY_HASH_ARY
+      else # TODO: other formats
+        415
       end
     end
 
@@ -209,14 +219,12 @@ module OData
 
         # validate payload column names
         if (invalid = self.class.invalid_hash_data?(data))
-          ::OData::Request::ON_CGST_ERROR.call(req)
-          return [422, {}, ['Invalid attribute name: ', invalid.to_s]]
+          ::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)
@@ -225,68 +233,15 @@ module OData
           update_fields(data, my_data_fields, missing: :skip)
         end
         # patch should return 204 + no content
-        [204, {}, []]
+        ARY_204_EMPTY_HASH_ARY
       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
-
-      def type_name
-        superclass.type_name
-      end
-
-      def media_handler
-        superclass.media_handler
-      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
@@ -301,69 +256,125 @@ 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(self, childattrib)
+      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)
+      if req.accept?(APPJSON)
+        #        delete
+        begin
+          odata_delete_relation_and_entity(req, @navattr_reflection, @nav_parent)
+          [200, EMPTY_HASH, [{ 'd' => req.service.get_emptycoll_odata_h }.to_json]]
+        rescue SequelAdapterError => e
+          BadRequestSequelAdapterError.new(e).odata_get(req)
+        end
+      else # TODO: other formats
+        415
+      end
     end
 
     # in case of a non media entity, we have to return an error on $value request
-    def odata_media_value_get(req)
-      return BadRequestNonMediaValue.odata_get
+    def odata_media_value_get(_req)
+      BadRequestNonMediaValue.odata_get
     end
 
     # in case of a non media entity, we have to return an error on $value PUT
-    def odata_media_value_put(req)
-      return BadRequestNonMediaValue.odata_get
+    def odata_media_value_put(_req)
+      BadRequestNonMediaValue.odata_get
+    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: media_src(uribase),
+          media_src: media_src,
+          edit_media: edit_media,
           content_type: @values[:content_type] }
     end
 
-    def media_src(urbase)
-      "#{uri(urbase)}/$value"
+    def media_src
+      version = self.class.media_handler.ressource_version(self)
+      "#{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)
       ret
     end
 
+    def odata_delete(req)
+      if req.accept?(APPJSON)
+        # delete the MR
+        # delegate to the media handler on collection(ie class) level
+        # TODO error handling
+
+        self.class.media_handler.odata_delete(entity: self)
+        # delete the relation(s)  to parent(s) (if any) and then entity
+        odata_delete_relation_and_entity(req, @navattr_reflection, @nav_parent)
+        # result
+        [200, EMPTY_HASH, [{ 'd' => req.service.get_emptycoll_odata_h }.to_json]]
+      else # TODO: other formats
+        415
+      end
+    end
+
     # real implementation for returning $value for a media entity
     def odata_media_value_get(req)
       # delegate to the media handler on collection(ie class) level
@@ -374,17 +385,20 @@ module OData
     def odata_media_value_put(req)
       model = self.class
       req.with_media_data do |data, mimetype, filename|
-        emdata = { :content_type => mimetype }
+        emdata = { content_type: mimetype }
         if req.in_changeset
           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)
-        [204, {}, []]
+
+        ARY_204_EMPTY_HASH_ARY
       end
     end
   end
@@ -399,18 +413,29 @@ module OData
     def media_path_id
       pk.to_s
     end
+
+    def media_path_ids
+      [pk]
+    end
   end
 
   # for multiple key
   module EntityMultiPK
     include Entity
     def pk_uri
-      # pk_hash is provided by Sequel
-      self.pk_hash.map { |k, v| "#{k}='#{v}'" }.join(',')
+      pku = +''
+      self.class.odata_upk_parts.each_with_index { |upart, i|
+        pku = "#{pku}#{upart}#{pk[i]}"
+      }
+      pku
     end
 
     def media_path_id
-      self.pk_hash.values.join('_')
+      pk_hash.values.join(SPACE)
+    end
+
+    def media_path_ids
+      pk_hash.values
     end
   end
 end