safrano 0.3.2 → 0.3.3

data/lib/odata/collection_media.rb

@@ -0,0 +1,148 @@
+require 'rack'
+require_relative './navigation_attribute.rb'
+
+module OData
+  module Media
+    # base class for Media Handler
+    class Handler
+    end
+
+    # Simple static File/Directory based media store handler
+    # similar to Rack::Static
+    class Static < Handler
+      def initialize(root: nil)
+        @root = File.absolute_path(root || Dir.pwd)
+        @file_server = ::Rack::File.new(@root)
+      end
+
+      # minimal working implementation...
+      #  Note: @file_server works relative to @root directory
+      def odata_get(request:, entity:)
+        media_env = request.env.dup
+        relpath = Dir.chdir(abs_path(entity)) do
+          # simple design: one file per directory, and the directory
+          # contains the media entity-id --> implicit link between the media
+          # entity
+          filename = Dir.glob('*').first
+
+          File.join(path(entity), filename)
+        end
+        media_env['PATH_INFO'] = relpath
+        @file_server.call(media_env)
+      end
+
+      # TODO perf: this can be precalculated and cached on MediaModelKlass level
+      #            and passed as argument to save_file
+      def abs_klass_dir(entity)
+        File.absolute_path(entity.klass_dir, @root)
+      end
+
+      def abs_path(entity)
+        File.absolute_path(path(entity), @root)
+      end
+
+      # this is relative to @root
+      def path(entity)
+        File.join(entity.klass_dir, entity.media_path_id)
+      end
+
+      # Here as well, MVP implementation
+      def save_file(data:, filename:, entity:)
+        mpi = entity.media_path_id
+        Dir.chdir(abs_klass_dir(entity)) do
+          Dir.mkdir mpi unless Dir.exists?(mpi)
+          Dir.chdir mpi do
+            File.open(filename, 'wb') { |f| IO.copy_stream(data, f) }
+          end
+        end
+      end
+
+      # Here as well, MVP implementation
+      def replace_file(data:, filename:, entity:)
+        mpi = entity.media_path_id
+        Dir.chdir(abs_klass_dir(entity)) do
+          Dir.mkdir mpi unless Dir.exists?(mpi)
+          Dir.chdir mpi do
+            Dir.glob('*').each { |oldf| File.delete(oldf) }
+            File.open(filename, 'wb') { |f| IO.copy_stream(data, f) }
+          end
+        end
+      end
+    end
+  end
+
+  # special handling for media entity
+  module EntityClassMedia
+    attr_reader :media_handler
+
+    # API method for defining the media handler
+    # eg.
+    # publish_media_model photos do
+    #   use OData::Media::Static, :root => '/media_root'
+    # end
+
+    def set_default_media_handler
+      @media_handler = OData::Media::Static.new
+    end
+
+    def use(klass, *args)
+      @media_handler = klass.new(*args)
+    end
+
+    def api_check_media_fields
+      unless self.db_schema.has_key?(:content_type)
+        raise OData::API::MediaModelError, self
+      end
+      #      unless self.db_schema.has_key?(:media_src)
+      #        raise OData::API::MediaModelError, self
+      #      end
+    end
+
+    def new_media_entity(mimetype:)
+      nh = {}
+      nh['content_type'] = mimetype
+      new_from_hson_h(nh)
+    end
+
+    # POST for media entity collection --> Create media-entity linked to
+    # uploaded file from payload
+    # 1. create new media entity
+    # 2. get the pk/id from the new media entity
+    # 3. Upload the file and use the pk/id to get an unique Directory/filename
+    #    assignment to the media entity record
+    # NOTE: we will implement this first in a MVP way. There will be plenty of
+    #       potential future enhancements (performance, scallability, flexibility... with added complexity)
+    # 4. create relation to parent if needed
+    def odata_create_entity_and_relation(req, assoc, parent)
+      req.with_media_data do |data, mimetype, filename|
+        ## future enhancement: validate allowed mimetypes ?
+        # if (invalid = invalid_media_mimetype(mimetype))
+        #  ::OData::Request::ON_CGST_ERROR.call(req)
+        #  return [422, {}, ['Invalid mime type: ', invalid.to_s]]
+        # end
+
+        if req.accept?(APPJSON)
+
+          new_entity = new_media_entity(mimetype: mimetype)
+
+          # to_one rels are create with FK data set on the parent entity
+          if parent
+            odata_create_save_entity_and_rel(req, new_entity, assoc, parent)
+          else
+            # in-changeset requests get their own transaction
+            new_entity.save(transaction: !req.in_changeset)
+          end
+
+          req.register_content_id_ref(new_entity)
+          new_entity.copy_request_infos(req)
+
+          media_handler.save_file(data: data, entity: new_entity, filename: filename)
+
+          [201, CT_JSON, new_entity.to_odata_post_json(service: req.service)]
+        else # TODO: other formats
+          415
+        end
+      end
+    end
+  end
+end

data/lib/odata/common_logger.rb

@@ -0,0 +1,34 @@
+module Rack
+  class ODataCommonLogger < CommonLogger
+    def call(env)
+      env['safrano.logger_mw'] = self
+      super
+    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
+      ]
+
+      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

@@ -5,7 +5,7 @@ require 'odata/collection.rb' # required for  self.class.entity_type_name ??
 
 module OData
   # this will be mixed in the  Model classes (subclasses of Sequel Model)
-  module Entity
+  module EntityBase
     attr_reader :params
     attr_reader :uribase
 
@@ -16,6 +16,7 @@ module OData
           Safrano::TransitionEnd,
           Safrano::TransitionCount,
           Safrano::TransitionLinks,
+          Safrano::TransitionValue,
           Safrano::Transition.new(self.class.transition_attribute_regexp,
                                   trans: 'transition_attribute')
         ]
@@ -41,6 +42,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 +60,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)
@@ -84,21 +88,19 @@ 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
+    DJopen = '{"d":'.freeze
+    DJclose = '}'.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,
+      innerj = service.get_entity_odata_h(entity: self,
                                           expand: @params['$expand'],
                                           #     links: @do_links,
-                                          uribase: @uribase) }.to_json
+                                          uribase: @uribase).to_json
+      "#{DJopen}#{innerj}#{DJclose}"
     end
 
     # needed for proper datetime output
@@ -107,7 +109,7 @@ module OData
       # 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|
+      values_for_odata.transform_values! { |v|
         case v
         when Time
           # try to get back the database time zone and value
@@ -120,20 +122,15 @@ module OData
 
     # 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],
+                                        uribase: @uribase).to_json
+      "#{DJopen}#{innerj}#{DJclose}"
     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
@@ -144,8 +141,10 @@ module OData
     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)
+        [200, CT_JSON, [to_odata_json(service: req.service)]]
       else # TODO: other formats
         415
       end
@@ -154,12 +153,13 @@ module OData
     def odata_delete(req)
       if req.accept?(APPJSON)
         delete
-        [200, CT_JSON, { 'd' => req.service.get_emptycoll_odata_h }.to_json]
+        [200, CT_JSON, [{ 'd' => req.service.get_emptycoll_odata_h }.to_json]]
       else # TODO: other formats
         415
       end
     end
 
+    # TODO: differentiate between POST/PUT/PATCH/MERGE
     def odata_post(req)
       data = JSON.parse(req.body.read)
       @uribase = req.uribase
@@ -174,20 +174,42 @@ module OData
           update_fields(data, self.class.data_fields, missing: :skip)
         end
 
-        [202, to_odata_post_json(service: req.service)]
+        [202, {}, 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
+
+          [204, {}, []]
+        else # TODO: other formats
+          415
+        end
+      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
+          ::OData::Request::ON_CGST_ERROR.call(req)
           return [422, {}, ['Invalid attribute name: ', invalid.to_s]]
         end
         # TODO: check values/types
@@ -218,11 +240,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 +253,14 @@ module OData
         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
@@ -254,6 +279,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 +296,98 @@ 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(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
+
+    # 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
+    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
+    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: media_src(uribase),
+          content_type: @values[:content_type] }
+    end
+
+    def media_src(urbase)
+      "#{uri(urbase)}/$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
+
+    # 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)
+        [204, {}, []]
+      end
+    end
+  end
 
   # for a single public key
   module EntitySinglePK
@@ -281,15 +395,22 @@ module OData
     def pk_uri
       pk
     end
+
+    def media_path_id
+      pk.to_s
+    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
+      self.pk_hash.map { |k, v| "#{k}='#{v}'" }.join(',')
+    end
+
+    def media_path_id
+      self.pk_hash.values.join('_')
     end
   end
 end