safrano 0.4.1 → 0.4.6

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,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
 
@@ -91,50 +81,43 @@ 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'],
-                                          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
 
     # 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
-      "#{DJopen}#{innerj}#{DJclose}"
+      innerj = service.get_entity_odata_link_h(entity: self).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
-      }
+    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}"
+    # 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
 
     def type_name
@@ -143,32 +126,37 @@ 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)
+        # 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(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
@@ -182,52 +170,47 @@ module OData
       else
         destroy(transaction: false)
       end
-      rescue StandardError => e
-        raise SequelAdapterError.new(e)
+    rescue StandardError => e
+      raise SequelAdapterError.new(e)
     end
-    
+
     # TODO: differentiate between POST/PUT/PATCH/MERGE
     def odata_post(req)
       if req.walker.media_value
         odata_media_value_put(req)
-      else
-        if req.accept?(APPJSON)
-          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
-  
-          [202, {}, to_odata_post_json(service: req.service)]
-        else # TODO: other formats
-          415
+      elsif req.accept?(APPJSON)
+        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
+
+        [202, EMPTY_HASH, to_odata_post_json(service: req.service)]
+      else # TODO: other formats
+        415
       end
     end
 
     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
 
@@ -237,14 +220,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)
@@ -253,75 +234,17 @@ 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
-
-      # 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 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
     # (...to_one relationship )
     def get_related_entity(childattrib)
@@ -334,35 +257,36 @@ 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)
       if req.accept?(APPJSON)
-#        delete
+        #        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
@@ -372,44 +296,64 @@ module OData
     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: 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"
-    end
-    
-    # directory where to put/find the media files for this entity-type
-    def klass_dir
-      type_name
+      "#{uri}/$value?version=#{version}"
     end
 
-    #    # this is just ModelKlass/pk as a single string
-    #    def qualified_media_path_id
-    #      "#{self.class}/#{media_path_id}"
-    #    end
+    def edit_media
+      "#{uri}/$value"
+    end
 
     def values_for_odata
       ret = values.dup
@@ -422,13 +366,12 @@ module OData
         # delete the MR
         # delegate to the media handler on collection(ie class) level
         # TODO error handling
-        
-      
-        self.class.media_handler.odata_delete(request: req, entity: self)
+
+        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, 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
@@ -444,17 +387,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
@@ -469,6 +415,7 @@ module OData
     def media_path_id
       pk.to_s
     end
+
     def media_path_ids
       [pk]
     end
@@ -478,17 +425,37 @@ module OData
   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
-      self.pk_hash.values
+      pk_hash.values
+    end
+  end
+
+  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
+end # end of Module OData