safrano 0.4.4 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88f62ce611a5030382ea19c2e7c22b47f454b85c51261e5bad060d82e4680dff
-  data.tar.gz: '088e66ed4a107a3bef8dd6db68c8ca626f7d3acef6ed2e58eb53d871e6349613'
+  metadata.gz: 00bf6cd3a561928000b8bf53bbc71f139b162f92adc229e625f010dc6f1ce3c7
+  data.tar.gz: bf154e1b55e4d32e4640d6c993566a45eae8a2bce44b23dd979a9946d3633dc7
 SHA512:
-  metadata.gz: 2d719e317178a4baebc2e40cc50b95559921fe2936a6a03437f7f92714d173ef6160b10620ce5476ea54a7433b3dd1366b49ec37a48b121b8f808ad030e2c364
-  data.tar.gz: 535ee0f1d4fed30a0c94918c31149a2e95fce90051548a2ccca6bffb71930c0767543255695496c3623249070b5efb1b6a203a1dae6f868c1e4da9a126a85346
+  metadata.gz: 9b2fad0321b45bae50f3435b688b31f99d320cfa4f81f14867f64659faa0c4e8ece7bc4f1f7ecc2db2c7710c08f7726bb4d758bf5d09d487a54199afea50119a
+  data.tar.gz: b9a70b4a08fb7a2cc31df7e7637f635a42a85433660f5061f6897e1fb463496252c8d611fb1023e5f27202bbc478b58569d2ad42b1c3359db14e34c92f4ec35c

data/lib/odata/attribute.rb

@@ -53,7 +53,7 @@ module Safrano
     # methods related to transitions to next state (cf. walker)
     module Transitions
       def transition_end(_match_result)
-        [nil, :end]
+        Transition::RESULT_END
       end
 
       def transition_value(_match_result)
@@ -64,7 +64,7 @@ module Safrano
                              Safrano::TransitionValue].freeze
 
       def allowed_transitions
-        ALLOWED_TRANSITIONS
+        Transitions::ALLOWED_TRANSITIONS
       end
     end
     include Transitions

data/lib/odata/collection.rb

@@ -60,10 +60,13 @@ module Safrano
       end
 
       def initialize_dataset(dtset = nil)
-        @cx = dtset || @modelk
+        @cx = @cx ||  dtset || @modelk
+      end
+      
+      def initialize_uparms
         @uparms = UrlParameters4Coll.new(@cx, @params)
       end
-
+      
       def odata_get_apply_params
         @uparms.apply_to_dataset(@cx).map_result! do |dataset|
           @cx = dataset
@@ -77,17 +80,20 @@ module Safrano
         end
       end
 
-      D = 'd'.freeze
-      DJ_OPEN = '{"d":'.freeze
-      DJ_CLOSE = '}'.freeze
+      D = 'd'
+      DJ_OPEN = '{"d":'
+      DJ_CLOSE = '}'
       EMPTYH = {}.freeze
 
       def to_odata_json(request:)
         template = @modelk.output_template(expand_list: @uparms.expand.template,
                                            select: @uparms.select)
+        # TODO: Error handling if database contains binary BLOB data that cant be
+        # interpreted as UTF-8 then JSON will fail here
         innerj = request.service.get_coll_odata_h(array: @cx.all,
                                                   template: template,
                                                   icount: @inlinecount).to_json
+
         "#{DJ_OPEN}#{innerj}#{DJ_CLOSE}"
       end
 
@@ -128,9 +134,9 @@ module Safrano
 
       # on model class level we return the collection
       def odata_get(req)
-        @params = req.params
-        initialize_dataset
-
+        @params = @params || req.params
+        initialize_dataset 
+        initialize_uparms
         @uparms.check_all.if_valid { |_ret|
           odata_get_apply_params.if_valid { |_ret|
             odata_get_output(req)
@@ -167,8 +173,7 @@ module Safrano
       end
 
       def initialize_dataset(dtset = nil)
-        @cx = dtset || navigated_dataset
-        @uparms = UrlParameters4Coll.new(@cx, @params)
+        @cx = @cx || dtset || navigated_dataset
       end
       # redefinitions of the main methods for a navigated collection
       # (eg. all Books of Author[2]  is Author[2].Books.all )

data/lib/odata/collection_filter.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require 'odata/error.rb'
+require 'odata/error'
 
-require_relative 'filter/parse.rb'
-require_relative 'filter/sequel.rb'
+require_relative 'filter/parse'
+require_relative 'filter/sequel'
 
 # filter base class and subclass in our OData namespace
 module Safrano
@@ -45,12 +45,12 @@ module Safrano
     # the join-helper is shared by the order-by object and was potentially already
     # partly built on order-by object creation.
     def finalize(jh)
-      @filtexpr = @ast.if_valid do |ast| ast.sequel_expr(jh) end
+      @filtexpr = @ast.if_valid { |ast| ast.sequel_expr(jh) }
     end
 
     def apply_to_dataset(dtcx)
       #     normally finalize is called before, and thus @filtexpr is set
-      @filtexpr.map_result! do |f| dtcx.where(f) end
+      @filtexpr.map_result! { |f| dtcx.where(f) }
     end
 
     # Note: this is really only *parse* error, ie the error encounterd while

data/lib/odata/collection_media.rb

@@ -2,12 +2,17 @@
 
 require 'rack'
 require 'fileutils'
-require_relative './navigation_attribute.rb'
+require_relative './navigation_attribute'
 
 module Safrano
   module Media
     # base class for Media Handler
     class Handler
+      def check_before_create(data:,
+                              entity:,
+                              filename:)
+        Contract::OK
+      end
     end
 
     # Simple static File/Directory based media store handler
@@ -24,9 +29,16 @@ module Safrano
 
       def register
         @abs_klass_dir = File.absolute_path(@media_dir_name, @root)
+      end
+
+      def create_abs_class_dir
         FileUtils.makedirs @abs_klass_dir unless Dir.exist?(@abs_klass_dir)
       end
 
+      def finalize
+        create_abs_class_dir
+      end
+
       # minimal working implementation...
       #  Note: @file_server works relative to @root directory
       def odata_get(request:, entity:)
@@ -47,13 +59,13 @@ module Safrano
       end
 
       # relative to @root
-      # eg Photo/1/pommes-topaz.jpg
+      # eg Photo/1/1
       def filename(entity)
         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
-          File.join(media_path(entity), Dir.glob('*').sort.first)
+          File.join(media_path(entity), Dir.glob('*').max)
         end
       end
 
@@ -62,6 +74,11 @@ module Safrano
         File.absolute_path(media_path(entity), @root)
       end
 
+      # absolute filename
+      def abs_filename(entity)
+        File.absolute_path(filename(entity), @root)
+      end
+
       # this is relative to abs_klass_dir(entity) eg to /@root/Photo
       # simplest implementation is media_directory = entity.media_path_id
       # --> we get a 1 level depth flat directory structure
@@ -101,7 +118,7 @@ module Safrano
       def ressource_version(entity)
         Dir.chdir(@abs_klass_dir) do
           in_media_directory(entity) do
-            Dir.glob('*').sort.last
+            Dir.glob('*').max
           end
         end
       end
@@ -135,15 +152,14 @@ module Safrano
 
       # this is relative to abs_klass_dir(entity) eg to /@root/Photo
       # tree-structure
-      #  media_path_ids = 1  -->  1
-      #  media_path_ids = 15  -->  1/5
-      #  media_path_ids = 555  -->  5/5/5
-      #  media_path_ids = 5,5,5  -->  5/00/5/00/5
-      #  media_path_ids = 5,00,5  -->  5/00/0/0/00/5
-      #  media_path_ids = 5,xyz,5  -->  5/00/x/y/z/00/5
+      #  media_path_ids = 1  -->  1/v
+      #  media_path_ids = 15  -->  1/5/v
+      #  media_path_ids = 555  -->  5/5/5/v
+      #  media_path_ids = 5,5,5  -->  5/00/5/00/5/v
+      #  media_path_ids = 5,00,5  -->  5/00/0/0/00/5/v
+      #  media_path_ids = 5,xyz,5  -->  5/00/x/y/z/00/5/v
       def media_directory(entity)
         StaticTree.path_builder(entity.media_path_ids)
-        #        entity.media_path_ids.map{|id| id.to_s.chars.join('/')}.join(@sep)
       end
 
       def in_media_directory(entity)
@@ -201,9 +217,14 @@ module Safrano
       @media_handler = Safrano::Media::Static.new(mediaklass: self)
     end
 
+    def finalize_media
+      @media_handler.finalize
+    end
+
     def use(klass, args)
       args[:mediaklass] = self
       @media_handler = klass.new(**args)
+      @media_handler.create_abs_class_dir
     end
 
     # API method for setting the model field mapped to SLUG on upload
@@ -250,22 +271,39 @@ module Safrano
                                   missing: :skip)
           end
 
-          # 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
+          # call before_create_entity media hook
+          new_entity.before_create_media_entity(data: data, mimetype: mimetype) if new_entity.respond_to? :before_create_media_entity
+
+          media_handler.check_before_create(data: data,
+                                            entity: new_entity,
+                                            filename: filename).if_valid { |_ret|
+            # 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)
+
+            # call before_create_media hook
+            new_entity.before_create_media if new_entity.respond_to? :before_create_media
+
+            media_handler.save_file(data: data,
+                                    entity: new_entity,
+                                    filename: filename)
+
+            # call after_create_media hook
+            new_entity.after_create_media if new_entity.respond_to? :after_create_media
 
-          req.register_content_id_ref(new_entity)
-          new_entity.copy_request_infos(req)
+            # json is default content type so we dont need to specify it here again
+            #           Contract.valid([201, EMPTY_HASH, new_entity.to_odata_post_json(service: req.service)])
+            # TODO quirks array mode !
+            Contract.valid([201, EMPTY_HASH, new_entity.to_odata_create_json(request: req)])
+          }.tap_error { |e| return e.odata_get(req) }.result
 
-          media_handler.save_file(data: data,
-                                  entity: new_entity,
-                                  filename: filename)
-          # json is default content type so we dont need to specify it here again
-          [201, EMPTY_HASH, new_entity.to_odata_post_json(service: req.service)]
         else # TODO: other formats
           415
         end

data/lib/odata/complex_type.rb

@@ -2,76 +2,184 @@
 
 module Safrano
   module FunctionImport
+    EMPTY_HASH = {}.freeze
     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
+      D = 'd'
+      DJ_OPEN = '{"d":'
+      DJ_CLOSE = '}'
+      METAK = '__metadata'
+      TYPEK = 'type'
+      VALUEK = 'value'
+      RESULTSK = 'results'
+      COLLECTION = 'Collection'
+      
+      def allowed_transitions
+        [Safrano::TransitionEnd]
       end
-
-      def to_odata_json(result, _req)
-        "#{DJ_OPEN}#{result.odata_h.to_json}#{DJ_CLOSE}"
+      
+      def transition_end(_match_result)
+        Safrano::Transition::RESULT_END
       end
-
-      def type_metadata
+           
+      # we will have this on class and instance level for making things simpler first
+      def self.klassmod
+        @klassmod
+      end
+      
+      # return a subclass of ResultAsComplexType
+      def self.asComplexType(klassmod)
+        Class.new(ResultAsComplexType) do
+          @klassmod = klassmod
+        end
+      end
+      
+      # return a subclass of ResultAsComplexType
+      def self.asComplexTypeColl(klassmod)
+        Class.new(ResultAsComplexTypeColl) do
+          @klassmod = klassmod
+        end
+      end
+      
+      def self.asPrimitiveType(klassmod)
+        Class.new(ResultAsPrimitiveType) do
+          @klassmod = klassmod
+        end
+      end
+      
+      def self.asPrimitiveTypeColl(klassmod)
+        Class.new(ResultAsPrimitiveTypeColl) do
+          @klassmod = klassmod
+        end
+      end      
+      
+      def self.asEntity(klassmod)
+        Class.new(ResultAsEntity) do
+          @klassmod = klassmod
+        end
+      end
+      
+      def self.asEntityColl(klassmod)
+        Class.new(ResultAsEntityColl) do
+          @klassmod = klassmod
+        end
+      end
+      
+      def initialize(value)
+        @value = value
+      end
+      
+      def odata_get(req)
+        [200, EMPTY_HASH, [to_odata_json(req)]]
+      end
+      def self.type_metadata
         @klassmod.type_name
       end
+      def type_metadata
+        self.class.type_metadata
+      end
+      
+      # needed for ComplexType result
+      def to_odata_json(_req)
+        "#{DJ_OPEN}#{@value.odata_h.to_json}#{DJ_CLOSE}"
+      end      
+      
+      # wrapper 
+      # for OData Entity and Collections, return them directly
+      # for others, ie ComplexType, Prims etc, return the ResultDefinition-subclass wrapped result
+      def self.do_execute_func_result(result, _req, apply_query_params=false)
+        self.new(result)
+      end
+      
     end
+    
     class ResultAsComplexType < ResultDefinition
+      def self.type_metadata
+        @klassmod.type_name
+      end
     end
+    
     class ResultAsComplexTypeColl < ResultDefinition
-      def type_metadata
+      def self.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}"
+      def to_odata_json(req)
+#        "#{DJ_OPEN}#{{ RESULTSK => coll.map { |c| c.odata_h } }.to_json}#{DJ_CLOSE}"
+        template = self.class.klassmod.output_template
+        # TODO: Error handling if database contains binary BLOB data that cant be
+        # interpreted as UTF-8 then JSON will fail here
+
+        innerh = req.service.get_coll_odata_h(array: @value,
+                                              template: template)
+                                              
+        innerj = innerh.to_json
+
+        "#{DJ_OPEN}#{innerj}#{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
+    
+      def self.type_metadata
+        @klassmod.type_name
       end
+
+      
+      # wrapper 
+      # for OData Entity  return them directly
+      def self.do_execute_func_result(result, _req, apply_query_params=false)
+        # note: Sequel entities instances seem to be thread safe, so we can 
+        # safely add request-dependant data (eg. req.params) there
+        apply_query_params ? result : result.inactive_query_params
+      end
+      
     end
+    
     class ResultAsEntityColl < ResultDefinition
-      def type_metadata
+    
+      def self.type_metadata
         "Collection(#{@klassmod.type_name})"
       end
-
-      def to_odata_json(result_dataset, req)
+      
+      # wrapper 
+      # for OData Entity Collection return them directly
+      def self.do_execute_func_result(result, req, apply_query_params=false)
         coll = Safrano::OData::Collection.new(@klassmod)
+        # instance_exec has other instance variables; @values would be nil in the block below
+        # need to pass a local copy
+        dtset = result
         coll.instance_exec do
-          @params = req.params
-          initialize_dataset(result_dataset)
+
+          @params =  apply_query_params ?  req.params : EMPTY_HASH
+          initialize_dataset(dtset)
+          initialize_uparms
         end
-        coll.to_odata_json(request: req)
+        coll
       end
+
     end
+    
     class ResultAsPrimitiveType < ResultDefinition
-      def to_odata_json(result, _req)
+      def self.type_metadata
+        @klassmod.type_name
+      end
+
+      def to_odata_json(_req)
         { D => { METAK => { TYPEK => type_metadata },
-                 VALUEK => @klassmod.odata_value(result) } }.to_json
+                 VALUEK => self.class.klassmod.odata_value(@value) } }.to_json
       end
     end
+    
     class ResultAsPrimitiveTypeColl < ResultDefinition
-      def type_metadata
+      def self.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
+      def to_odata_json(_req)
+        { D => { METAK => { TYPEK => self.class.type_metadata },
+                 RESULTSK => self.class.klassmod.odata_collection(@value) } }.to_json
       end
+    
     end
   end
 
@@ -80,7 +188,8 @@ module Safrano
   # with added OData functionality
   class ComplexType
     attr_reader :values
-
+    EMPTYH = {}.freeze
+    
     @namespace = nil
     def self.namespace
       @namespace
@@ -89,19 +198,52 @@ module Safrano
     def self.props
       @props
     end
-
+    
+    def type_name
+      self.class.type_name
+    end
+    
+    def metadata_h
+      {   type: type_name }
+    end
+    
+    def casted_values
+      # MVP... TODO: handle time mappings like in Entity models
+      values
+    end
+    
+    # needed for nested json output
+    # this is a simpler version of model_ext#output_template
+    def self.default_template
+      template = {}
+      expand_e = {}
+      
+      template[:all_values] = EMPTYH
+      @props.each { |prop, kl| 
+        if kl.respond_to? :default_template
+          expand_e[prop] = kl.default_template
+        end
+      }
+      template[:expand_e] = expand_e
+      template
+    end
+    
+    def self.output_template
+      default_template
+    end
     def self.type_name
-      "#{@namespace}.#{self.to_s}"
+      @namespace ? "#{@namespace}.#{self.to_s}" : self.to_s
     end
 
     def initialize
       @values = {}
     end
-    METAK = '__metadata'.freeze
-    TYPEK = 'type'.freeze
+    METAK = '__metadata'
+    TYPEK = 'type'
 
     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
@@ -113,11 +255,11 @@ module Safrano
     end
 
     def self.return_as_collection_descriptor
-      FunctionImport::ResultAsComplexTypeColl.new(self)
+      FunctionImport::ResultDefinition.asComplexTypeColl(self)
     end
 
     def self.return_as_instance_descriptor
-      FunctionImport::ResultAsComplexType.new(self)
+      FunctionImport::ResultDefinition.asComplexType(self)
     end
 
     # add metadata xml to the passed REXML schema object