safrano 0.4.3 → 0.4.4

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,15 +1,17 @@
+# 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
 
-    include EntityBase::NavigationInfo
+    include Safrano::NavigationInfo
 
     # methods related to transitions to next state (cf. walker)
     module Transitions
@@ -18,7 +20,7 @@ module OData
       end
 
       def transition_end(_match_result)
-        [nil, :end]
+        Safrano::Transition::RESULT_END
       end
 
       def transition_count(_match_result)
@@ -36,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)
@@ -49,10 +50,20 @@ 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 = {}
 
@@ -80,10 +91,11 @@ module OData
     DJ_CLOSE = '}'.freeze
 
     # Json formatter for a single entity (probably OData V1/V2 like)
-    def to_odata_json(service:)
-      template = self.class.output_template(@uparms)
-      innerj = service.get_entity_odata_h(entity: self,
-                                          template: template).to_json
+    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
 
@@ -114,27 +126,33 @@ module OData
     def copy_request_infos(req)
       @params = req.params
       @do_links = req.walker.do_links
-      @uparms = UrlParameters4Single.new(@params)
+      @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(assoc, parent)
+      Safrano.remove_nav_relation(assoc, parent)
       entity.destroy(transaction: false)
     end
 
@@ -201,7 +219,7 @@ module OData
 
         # validate payload column names
         if (invalid = self.class.invalid_hash_data?(data))
-          ::OData::Request::ON_CGST_ERROR.call(req)
+          ::Safrano::Request::ON_CGST_ERROR.call(req)
           return [422, EMPTY_HASH, ['Invalid attribute name: ', invalid.to_s]]
         end
         # TODO: check values/types
@@ -219,89 +237,11 @@ module OData
       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 time_cols
-        superclass.time_cols
-      end
-
-      def media_handler
-        superclass.media_handler
-      end
-
-      def uri
-        superclass.uri
-      end
-
-      def default_template
-        superclass.default_template
-      end
-
-      def allowed_transitions
-        superclass.allowed_transitions
-      end
-
-      def entity_allowed_transitions
-        superclass.entity_allowed_transitions
-      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
@@ -316,14 +256,14 @@ 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
@@ -344,7 +284,7 @@ module OData
         #        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
@@ -375,7 +315,7 @@ module OData
                values_for_odata.dup
              else
                selected_values_for_odata(cols)
-        end
+             end
       self.class.time_cols.each { |tc| vals[tc] = vals[tc]&.iso8601 if vals.key?(tc) }
       vals
     end
@@ -390,7 +330,7 @@ module OData
         values_for_odata
       else
         selected_values_for_odata(cols)
-        end
+      end
     end
   end
 
@@ -413,16 +353,6 @@ module OData
       "#{uri}/$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)
@@ -439,7 +369,7 @@ module OData
         # 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
@@ -460,11 +390,14 @@ module OData
           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
@@ -490,8 +423,11 @@ module OData
   module EntityMultiPK
     include Entity
     def pk_uri
-      # pk_hash is provided by Sequel
-      pk_hash.map { |k, v| "#{k}='#{v}'" }.join(COMMA)
+      pku = +''
+      self.class.odata_upk_parts.each_with_index { |upart, i|
+        pku = "#{pku}#{upart}#{pk[i]}"
+      }
+      pku
     end
 
     def media_path_id