safrano 0.3.2 → 0.4.2

data/lib/odata/common_logger.rb

@@ -0,0 +1,59 @@
+module Rack
+  class ODataCommonLogger < CommonLogger
+    def call(env)
+      env['safrano.logger_mw'] = self
+      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 = 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
+      # calls to write on the log device without formatting
+      if logger.respond_to?(:write)
+        logger.write(msg)
+      else
+        logger << msg
+      end
+    end
+  end
+end

data/lib/odata/entity.rb

@@ -2,13 +2,16 @@ require 'json'
 require 'rexml/document'
 require 'safrano.rb'
 require 'odata/collection.rb' # required for  self.class.entity_type_name ??
+require_relative 'navigation_attribute'
 
 module OData
   # this will be mixed in the  Model classes (subclasses of Sequel Model)
-  module Entity
+  module EntityBase
     attr_reader :params
     attr_reader :uribase
 
+    include EntityBase::NavigationInfo
+
     # methods related to transitions to next state (cf. walker)
     module Transitions
       def allowed_transitions
@@ -16,6 +19,7 @@ module OData
           Safrano::TransitionEnd,
           Safrano::TransitionCount,
           Safrano::TransitionLinks,
+          Safrano::TransitionValue,
           Safrano::Transition.new(self.class.transition_attribute_regexp,
                                   trans: 'transition_attribute')
         ]
@@ -41,6 +45,11 @@ module OData
         [self, :end]
       end
 
+      def transition_value(_match_result)
+        # $value is only allowd for media entities (or attributes)
+        [self, :end_with_media_value]
+      end
+
       def transition_links(_match_result)
         [self, :run_with_links]
       end
@@ -54,8 +63,6 @@ module OData
       def transition_nav_collection(match_result)
         attrib = match_result[1]
         [get_related(attrib), :run]
-        #        attr_klass = self.class.nav_collection_attribs[attrib].to_s
-        #        [get_related(attr_klass), :run]
       end
 
       def transition_nav_entity(match_result)
@@ -72,7 +79,6 @@ module OData
       self.class.nav_entity_attribs&.each_key do |na_str|
         @nav_values[na_str.to_sym] = send(na_str)
       end
-
       @nav_values
     end
 
@@ -84,30 +90,51 @@ module OData
       @nav_coll
     end
 
-    def uri_path
-      kla = self.class
-      "#{kla.entity_set_name}(#{pk_uri})"
-    end
-
     def uri(uriba)
-      "#{uriba}/#{uri_path}"
+      "#{uriba}/#{self.class.entity_set_name}(#{pk_uri})"
     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:)
-      { 'd' => service.get_entity_odata_h(entity: self,
-                                          expand: @params['$expand'],
-                                          #     links: @do_links,
-                                          uribase: @uribase) }.to_json
+      template = self.class.output_template(@uparms)
+      innerj = service.get_entity_odata_h(entity: self,
+                                          template: template,
+                                          uribase: @uribase).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
+      "#{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
 
     # needed for proper datetime output
-    # TODO design/performance
-    def casted_values
+    # 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
-      values.transform_values! { |v|
+
+      vals.transform_values! do |v|
         case v
         when Time
           # try to get back the database time zone and value
@@ -115,56 +142,92 @@ module OData
         else
           v
         end
-      }
+      end
     end
 
     # post paylod expects the new entity in an array
     def to_odata_post_json(service:)
-      { 'd' => service.get_coll_odata_h(array: [self],
-                                        uribase: @uribase) }.to_json
+      innerj = service.get_coll_odata_h(array: [self],
+                                        template: self.class.default_template,
+                                        uribase: @uribase).to_json
+      "#{DJ_OPEN}#{innerj}#{DJ_CLOSE}"
     end
 
     def type_name
       self.class.type_name
     end
 
-    # metadata for json h
-    def metadata_h(uribase:)
-      {   uri: uri(uribase),
-          type: type_name }
-    end
-
     def copy_request_infos(req)
       @params = req.params
       @uribase = req.uribase
       @do_links = req.walker.do_links
+      @uparms = UrlParameters4Single.new(@params)
     end
 
     # Finally Process REST verbs...
     def odata_get(req)
       copy_request_infos(req)
-
-      if req.accept?(APPJSON)
-        [200, CT_JSON, to_odata_json(service: req.service)]
+      if req.walker.media_value
+        odata_media_value_get(req)
+      elsif req.accept?(APPJSON)
+        if req.walker.do_links
+          [200, CT_JSON, [to_odata_onelink_json(service: req.service)]]
+        else
+          [200, CT_JSON, [to_odata_json(service: req.service)]]
+        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
+    DELETE_REL_AND_ENTY = lambda do |entity, assoc, parent|
+      OData.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.walker.media_value
+        odata_media_value_put(req)
+      elsif req.accept?(APPJSON)
+        data.delete('__metadata')
 
-      if req.accept?(APPJSON)
+        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)
+      elsif req.accept?(APPJSON)
+        data = JSON.parse(req.body.read)
+        @uribase = req.uribase
         data.delete('__metadata')
 
         if req.in_changeset
@@ -174,21 +237,20 @@ module OData
           update_fields(data, self.class.data_fields, missing: :skip)
         end
 
-        [202, to_odata_post_json(service: req.service)]
+        ARY_204_EMPTY_HASH_ARY
       else # TODO: other formats
         415
       end
     end
 
     def odata_patch(req)
-      on_error = (proc { raise Sequel::Rollback } if req.in_changeset)
-      req.with_parsed_data(on_error: on_error) do |data|
+      req.with_parsed_data do |data|
         data.delete('__metadata')
 
         # validate payload column names
         if (invalid = self.class.invalid_hash_data?(data))
-          on_error.call if on_error
-          return [422, {}, ['Invalid attribute name: ', invalid.to_s]]
+          ::OData::Request::ON_CGST_ERROR.call(req)
+          return [422, EMPTY_HASH, ['Invalid attribute name: ', invalid.to_s]]
         end
         # TODO: check values/types
 
@@ -203,7 +265,7 @@ 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
 
@@ -218,11 +280,6 @@ module OData
         @child_method.call.count
       end
 
-      # TODO: fix design
-      def navigated_coll
-        true
-      end
-
       def dataset
         @child_dataset_method.call
       end
@@ -236,6 +293,23 @@ module OData
         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
@@ -254,6 +328,8 @@ module OData
         # 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 []
@@ -269,11 +345,134 @@ module OData
       # 'Race[12].RaceType'
       # where Race[12] would be our self and 'RaceType' is the single
       # childattrib entity
-      child_method = method(childattrib.to_sym)
-      child_method.call
+
+      # when the child attribute is nil (because the FK is NULL on DB)
+      # 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.set_relation_info(self, childattrib)
+
+      ret
     end
   end
   # end of module ODataEntity
+  module Entity
+    include EntityBase
+  end
+
+  module NonMediaEntity
+    # non media entity metadata for json h
+    def metadata_h(uribase:)
+      {   uri: uri(uribase),
+          type: type_name }
+    end
+
+    def values_for_odata
+      values.dup
+    end
+
+    def odata_delete(req)
+      if req.accept?(APPJSON)
+        #        delete
+        begin
+          odata_delete_relation_and_entity(req, @navattr_reflection, @nav_parent)
+          [200, CT_JSON, [{ '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)
+      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)
+      BadRequestNonMediaValue.odata_get
+    end
+  end
+
+  module MediaEntity
+    # media entity metadata for json h
+    def metadata_h(uribase:)
+      {   uri: uri(uribase),
+          type: type_name,
+          media_src: media_src(uribase),
+          edit_media: edit_media(uribase),
+          content_type: @values[:content_type] }
+    end
+
+    def media_src(uribase)
+      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
+    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, CT_JSON, [{ '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
+      self.class.media_handler.odata_get(request: req, entity: self)
+    end
+
+    # real implementation for replacing $value for a media entity
+    def odata_media_value_put(req)
+      model = self.class
+      req.with_media_data do |data, mimetype, filename|
+        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)
+        ARY_204_EMPTY_HASH_ARY
+      end
+    end
+  end
 
   # for a single public key
   module EntitySinglePK
@@ -281,15 +480,30 @@ module OData
     def pk_uri
       pk
     end
+
+    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
-      #     self.class.primary_key is provided by Sequel as
-      # array of symbols
-      self.class.primary_key.map { |pk| "#{pk}='#{values[pk]}'" }.join(',')
+      # pk_hash is provided by Sequel
+      pk_hash.map { |k, v| "#{k}='#{v}'" }.join(COMMA)
+    end
+
+    def media_path_id
+      pk_hash.values.join(SPACE)
+    end
+
+    def media_path_ids
+      pk_hash.values
     end
   end
 end