microsoft_kiota_abstractions 0.12.0

data/lib/microsoft_kiota_abstractions/authentication/base_bearer_token_authentication_provider.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative './authentication_provider'
+require_relative './access_token_provider'
+
+module MicrosoftKiotaAbstractions
+  # Provides a base class for implementing AuthenticationProvider for Bearer token scheme
+  class BaseBearerTokenAuthenticationProvider
+    include MicrosoftKiotaAbstractions::AuthenticationProvider
+    def initialize(access_token_provider)
+      raise StandardError, 'access_token_provider parameter cannot be nil' if access_token_provider.nil?
+
+      @access_token_provider = access_token_provider
+    end 
+
+    AUTHORIZATION_HEADER_KEY = 'Authorization'
+    def authenticate_request(request, additional_properties = {})
+      raise StandardError, 'Request cannot be null' if request.nil?
+
+      Fiber.new do
+        token = @access_token_provider.get_authorization_token(request.uri, additional_properties).resume
+        request.headers.add(AUTHORIZATION_HEADER_KEY, "Bearer #{token}") unless token.nil? || token.empty?
+      end unless request.headers.get_all.key?(AUTHORIZATION_HEADER_KEY)
+    end
+  end
+end

data/lib/microsoft_kiota_abstractions/http_method.rb

@@ -0,0 +1,17 @@
+module MicrosoftKiotaAbstractions
+  module HttpMethod
+
+    HTTP_METHOD = {
+      GET: :GET,
+      POST: :POST,
+      PATCH: :PATCH,
+      DELETE: :DELETE,
+      OPTIONS: :OPTIONS,
+      CONNECT: :CONNECT,
+      PUT: :PUT,
+      TRACE: :TRACE,
+      HEAD: :HEAD
+    }
+    
+    end 
+  end

data/lib/microsoft_kiota_abstractions/request_adapter.rb

@@ -0,0 +1,25 @@
+require_relative 'request_information'
+
+module MicrosoftKiotaAbstractions
+  module RequestAdapter
+
+    def send_async(request_info, factory, errors_mapping)
+      raise NotImplementedError.new
+    end
+
+    # TODO we're most likley missing something for enums and collections or at least at the implemenation level
+
+    def get_serialization_writer_factory()
+      raise NotImplementedError.new
+    end
+
+    def set_base_url(base_url)
+      raise NotImplementedError.new
+    end
+
+    def get_base_url()
+      raise NotImplementedError.new
+    end
+
+  end
+end

data/lib/microsoft_kiota_abstractions/request_headers.rb

@@ -0,0 +1,44 @@
+module MicrosoftKiotaAbstractions
+    class RequestHeaders
+        def initialize()
+            @headers = Hash.new
+        end
+        def add(key, value)
+            if key.nil? || key.empty? || value.nil? || value.empty? then
+              raise ArgumentError, 'key and value cannot be nil or empty'
+            end
+            existing_value = @headers[key]
+            if existing_value.nil? then
+              if value.kind_of?(Array) then
+                @headers[key] = value
+              else
+                @headers[key] = Array[value.to_s]
+              end
+            else
+              if value.kind_of?(Array) then
+                @headers[key] = existing_value | value
+              else
+                existing_value << value.to_s
+              end
+            end
+        end
+        def get(key)
+            if key.nil? || key.empty? then
+              raise ArgumentError, 'key cannot be nil or empty'
+            end
+            return @headers[key]
+        end
+        def remove(key)
+            if key.nil? || key.empty? then
+              raise ArgumentError, 'key cannot be nil or empty'
+            end
+            @headers.delete(key)
+        end
+        def clear()
+            @headers.clear()
+        end
+        def get_all()
+            return @headers
+        end
+    end
+end

data/lib/microsoft_kiota_abstractions/request_information.rb

@@ -0,0 +1,130 @@
+require 'uri'
+require 'addressable/template'
+require_relative 'http_method'
+require_relative 'request_headers'
+
+module MicrosoftKiotaAbstractions
+  class RequestInformation
+    attr_reader :content, :http_method, :headers
+    attr_accessor :url_template, :path_parameters, :query_parameters
+    @@binary_content_type = 'application/octet-stream'
+    @@content_type_header = 'Content-Type'
+    @@raw_url_key = 'request-raw-url'
+
+    def initialize()
+      @headers = RequestHeaders.new
+      @query_parameters = Hash.new
+      @path_parameters = Hash.new
+    end
+    
+    def uri=(arg)
+      if arg.nil? || arg.empty?
+        raise ArgumentError, 'arg cannot be nil or empty'
+      end
+      self.path_parameters.clear()
+      self.query_parameters.clear()
+      @uri = URI(arg)
+    end
+
+    def uri
+      if @uri != nil
+        return @uri
+      else
+        if self.path_parameters[@@raw_url_key] != nil
+          self.uri = self.path_parameters[@@raw_url_key]
+          return @uri
+        else
+          template = Addressable::Template.new(@url_template)
+          return URI(template.expand(self.path_parameters.merge(self.query_parameters)).to_s)
+        end
+      end
+    end
+
+    def add_request_options(request_options_to_add)
+      unless request_options_to_add.nil? then
+        @request_options ||= Hash.new
+        unless request_options_to_add.kind_of?(Array) then
+          request_options_to_add = [request_options_to_add]
+        end
+        request_options_to_add.each do |request_option|
+          key = request_option.get_key
+          @request_options[key] = request_option
+        end
+      end
+    end
+
+    def get_request_options()
+      if @request_options.nil? then
+        return []
+      else
+        return @request_options.values
+      end
+    end
+
+    def get_request_option(key)
+      if @request_options.nil? || key.nil? || key.empty? then
+        return nil
+      else
+        return @request_options[key]
+      end
+    end
+
+    def remove_request_options(keys)
+      unless keys.nil? || @request_options.nil? then
+        unless keys.kind_of?(Array) then
+          keys = [keys]
+        end
+        keys.each do |key|
+          @request_options.delete(key)
+        end
+      end
+    end
+
+    def http_method=(method)
+      @http_method = HttpMethod::HTTP_METHOD[method]
+    end
+
+    def set_stream_content(value = $stdin)
+      @content = value
+      @headers.add(@@content_type_header, @@binary_content_type)
+    end
+
+    def set_content_from_parsable(request_adapter, content_type, values)
+      begin
+        writer  = request_adapter.get_serialization_writer_factory().get_serialization_writer(content_type)
+        @headers.add(@@content_type_header, content_type)
+        if values != nil && values.kind_of?(Array)
+          writer.write_collection_of_object_values(nil, values)
+        else
+          writer.write_object_value(nil, values);
+        end
+        this.content = writer.get_serialized_content();
+      rescue => exception
+        raise Exception.new "could not serialize payload"
+      end
+    end
+
+    def add_headers_from_raw_object(h)
+      h.select{|x,y| @headers.add(x.to_s, y)} unless !h
+    end
+    
+    def set_query_string_parameters_from_raw_object(q)
+      if !q || q.is_a?(Hash) || q.is_a?(Array)
+        return
+      end
+      q.class.instance_methods(false).select{|x|
+        method_name = x.to_s
+        unless method_name == "compare_by_identity" || method_name == "get_query_parameter" || method_name.end_with?("=") || method_name.end_with?("?") || method_name.end_with?("!") then
+          begin
+            key = q.get_query_parameter(method_name)
+          rescue => exception
+            key = method_name
+          end
+          value = eval("q.#{method_name}")
+          self.query_parameters[key] = value unless value.nil?
+        end
+      }
+    end
+
+  end
+end

data/lib/microsoft_kiota_abstractions/request_option.rb

@@ -0,0 +1,7 @@
+module MicrosoftKiotaAbstractions
+    module RequestOption
+        def get_key()
+            raise NotImplementedError.new
+        end
+    end
+end

data/lib/microsoft_kiota_abstractions/serialization/additional_data_holder.rb

@@ -0,0 +1,7 @@
+module MicrosoftKiotaAbstractions
+    module AdditionalDataHolder
+      def additional_data 
+        @additional_data ||= Hash.new
+      end
+    end
+end

data/lib/microsoft_kiota_abstractions/serialization/iso_duration.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+require 'iso8601'
+
+module MicrosoftKiotaAbstractions
+  # Wrapper Class for ISO8601::Duration
+  # Integer support for :years, :months, :weeks, :days, :hours, :minutes, :seconds
+  # Initialize with a hash of symbols to integers eg { :years => 3, :days => 4, seconds: => 2}
+  # or with an ISO8601 formated string eg "PT3H12M5S".
+  class ISODuration
+    attr_reader :years, :months, :weeks, :days, :hours, :minutes, :seconds
+
+    UNITS = { :years => 'Y', 
+              :months => 'M', 
+              :weeks => 'W', 
+              :days => 'D', 
+              :hours => 'H', 
+              :minutes => 'M',
+              :seconds => 'S'}
+
+    CONVERSIONS = {
+      :ms_to_s => 1000,
+      :s_to_m => 60,
+      :m_to_h => 60,
+      :h_to_d => 24,
+      :d_to_w => 7,
+      :m_to_y => 12
+    }
+    def initialize(input)
+      if input.is_a? String
+        @duration_obj = ISO8601::Duration.new(input)
+      elsif input.is_a? Hash
+        @duration_obj = parse_hash(input)
+      else
+        raise StandardError, 'Must provide initialize ISODuration by providing a hash or an ISO8601-formatted string.'
+      end
+      update_member_variables
+      normalize
+    end
+
+    def string
+      input = { :seconds => @seconds, :minutes => @minutes, :hours => @hours, 
+                :days => @days, :weeks => @weeks, :months => @months, 
+                :years => @years } 
+      iso_str = 'P'
+      UNITS.each do |unit, abrev|
+        iso_str += input[unit].to_s + abrev unless input[unit].zero?
+        iso_str += 'T' if unit == :days
+      end
+      iso_str = iso_str.strip
+      iso_str = iso_str.chomp('T') if (iso_str[-1]).eql? 'T'
+      iso_str
+    end
+
+    def normalize
+      if @seconds >= CONVERSIONS[:s_to_m]
+        @minutes += (@seconds / CONVERSIONS[:s_to_m]).floor
+        @seconds %= CONVERSIONS[:s_to_m]
+      end
+      if @minutes >= CONVERSIONS[:m_to_h]
+        @hours += (@minutes / CONVERSIONS[:m_to_h]).floor
+        @minutes %= CONVERSIONS[:m_to_h]
+      end
+      if @hours >= CONVERSIONS[:h_to_d]
+        @days += (@hours / CONVERSIONS[:h_to_d]).floor
+        @hours %= CONVERSIONS[:h_to_d]
+      end
+      if @days >= CONVERSIONS[:d_to_w] && @months == 0 && @years == 0
+        @weeks += (@days / CONVERSIONS[:d_to_w]).floor
+        @days %= CONVERSIONS[:d_to_w]
+      end
+      if @months > CONVERSIONS[:m_to_y]
+        @years += (@months / CONVERSIONS[:m_to_y]).floor
+        @months %= CONVERSIONS[:m_to_y]
+      end
+    end
+
+    def seconds=(value)
+      input = { :seconds => value, :minutes => @minutes, :hours => @hours, 
+                :days => @days, :weeks => @weeks, :months => @months, 
+                :years => @years } 
+      @duration_obj = parse_hash(input)
+      @seconds = value
+      normalize
+    end
+
+    def minutes=(value)
+      input = { :seconds => @seconds, :minutes => value, :hours => @hours, 
+                :days => @days, :weeks => @weeks, :months => @months, 
+                :years => @years } 
+      @duration_obj = parse_hash(input)
+      @minutes = value
+      normalize
+    end
+
+    def hours=(value)
+      input = { :seconds => @seconds, :minutes => @minutes, :hours => value, 
+                :days => @days, :weeks => @weeks, :months => @months, 
+                :years => @years } 
+      @duration_obj = parse_hash(input)
+      @hours = value
+      normalize
+    end
+
+    def days=(value)
+      input = { :seconds => @seconds, :minutes => @minutes, :hours => @hours, 
+                :days => value, :weeks => @weeks, :months => @months, 
+                :years => @years } 
+      @duration_obj = parse_hash(input)
+      @days = value
+      normalize
+    end
+
+    def weeks=(value)
+      input = { :seconds => @seconds, :minutes => @minutes, :hours => @hours, 
+                :days => @days, :weeks => value, :months => @months, 
+                :years => @years } 
+      @duration_obj = parse_hash(input)
+      @weeks = value
+      normalize
+    end
+
+    def months=(value)
+      input = { :seconds => @seconds, :minutes => @minutes, :hours => @hours, 
+                :days => @days, :weeks => @weeks, :months => value, 
+                :years => @years } 
+      @duration_obj = parse_hash(input)
+      @months = value
+      normalize
+    end
+
+    def years=(value)
+      input = { :seconds => @seconds, :minutes => @minutes, :hours => @hours, 
+        :days => @days, :weeks => @weeks, :months => @months, 
+        :years => value } 
+      @duration_obj = parse_hash(input)
+      @years = value
+      normalize
+    end
+
+    def abs
+      @duration_obj = @duration_obj.abs
+      update_member_variables
+      return self
+    end
+
+    def +(other)
+      new_obj = self.duration_obj + other.duration_obj
+      MicrosoftKiotaAbstractions::ISODuration.new(dur_obj_to_hash(new_obj))
+    end
+
+    def -(other)
+      new_obj = self.duration_obj - other.duration_obj
+      MicrosoftKiotaAbstractions::ISODuration.new(dur_obj_to_hash(new_obj))
+    end
+
+    def ==(other)
+      @duration_obj == other.duration_obj
+    end
+
+    def -@
+      @duration_obj = -@duration_obj
+      update_member_variables
+    end
+
+    def eql?(other)
+      @duration_obj == other.duration_obj
+    end
+
+    protected
+
+    attr_accessor :duration_obj
+
+    def parse_hash(input)
+      iso_str = 'P'
+      input.each do |keys, values|
+        raise StandardError, "The key #{keys} is not recognized" unless UNITS.key?(keys)
+      end
+      UNITS.each do |unit, abrev|
+        iso_str += input[unit].to_s + abrev if input.key?(unit) && !input[unit].zero?
+        iso_str += 'T' if unit == :days
+      end
+      iso_str = iso_str.strip
+      iso_str = iso_str.chomp('T') if (iso_str[-1]).eql? 'T'
+      ISO8601::Duration.new(iso_str)
+    end
+
+    def update_member_variables
+      @seconds = @duration_obj.seconds.nil? ? 0 : ((@duration_obj.seconds.to_s).split('S')[0]).to_i
+      @minutes = @duration_obj.minutes.nil? ? 0 : ((@duration_obj.minutes.to_s).split('H')[0]).to_i
+      @hours = @duration_obj.hours.nil? ? 0 : ((@duration_obj.hours.to_s).split('H')[0]).to_i
+      @days = @duration_obj.days.nil? ? 0 : ((@duration_obj.days.to_s).split('D')[0]).to_i
+      @weeks = @duration_obj.weeks.nil? ? 0 : ((@duration_obj.weeks.to_s).split('W')[0]).to_i
+      @months = @duration_obj.months.nil? ? 0 : ((@duration_obj.months.to_s).split('M')[0]).to_i
+      @years = @duration_obj.years.nil? ? 0 : ((@duration_obj.years.to_s).split('Y')[0]).to_i
+    end
+
+    def dur_obj_to_hash(dur_obj)
+      result_hash = {}
+      result_hash[:seconds] = dur_obj.seconds.nil? ? 0 : ((dur_obj.seconds.to_s).split('S')[0]).to_i
+      result_hash[:minutes] = dur_obj.minutes.nil? ? 0 : ((dur_obj.minutes.to_s).split('H')[0]).to_i
+      result_hash[:hours] = dur_obj.hours.nil? ? 0 : ((dur_obj.hours.to_s).split('H')[0]).to_i
+      result_hash[:days] = dur_obj.days.nil? ? 0 : ((dur_obj.days.to_s).split('D')[0]).to_i
+      result_hash[:weeks] = dur_obj.weeks.nil? ? 0 : ((dur_obj.weeks.to_s).split('W')[0]).to_i
+      result_hash[:months] = dur_obj.months.nil? ? 0 : ((dur_obj.months.to_s).split('M')[0]).to_i
+      result_hash[:years] = dur_obj.years.nil? ? 0 : ((dur_obj.years.to_s).split('Y')[0]).to_i
+      result_hash
+    end
+  end
+end

data/lib/microsoft_kiota_abstractions/serialization/parsable.rb

@@ -0,0 +1,11 @@
+module MicrosoftKiotaAbstractions
+  module Parsable
+    def get_field_deserializers
+      raise NotImplementedError.new
+    end
+
+    def serialize(writer)
+      raise NotImplementedError.new
+    end
+  end
+end

data/lib/microsoft_kiota_abstractions/serialization/parse_node.rb

@@ -0,0 +1,61 @@
+module MicrosoftKiotaAbstractions
+  module ParseNode
+
+    def get_string_value()
+      raise NotImplementedError.new
+    end
+
+    def get_boolean_value()
+      raise NotImplementedError.new
+    end
+
+    def get_number_value()
+      raise NotImplementedError.new
+    end
+
+    def get_guid_value()
+      raise NotImplementedError.new
+    end
+
+    def get_date_value()
+      raise NotImplementedError.new
+    end
+
+    def get_time_value()
+      raise NotImplementedError.new
+    end
+
+    def get_date_time_value()
+      raise NotImplementedError.new
+    end
+
+    def get_duration_value()
+      raise NotImplementedError.new 
+    end
+
+    def get_collection_of_primitive_values()
+      raise NotImplementedError.new
+    end
+
+    def get_collection_of_object_values(factory)
+      raise NotImplementedError.new
+    end
+
+    def get_object_value(factory)
+      raise NotImplementedError.new
+    end
+
+    def assign_field_values(item)
+      raise NotImplementedError.new
+    end
+
+    def get_enum_value(type)
+      raise NotImplementedError.new
+    end
+
+    def get_child_node(name)
+      raise NotImplementedError.new
+    end
+    
+  end
+end

data/lib/microsoft_kiota_abstractions/serialization/parse_node_factory.rb

@@ -0,0 +1,7 @@
+module MicrosoftKiotaAbstractions
+  module ParseNodeFactory
+    def ParseNodeFactory.get_parse_node(content_type, content)
+      raise NotImplementedError.new
+    end
+  end
+end

data/lib/microsoft_kiota_abstractions/serialization/parse_node_factory_registry.rb

@@ -0,0 +1,42 @@
+require_relative 'parse_node_factory'
+
+module MicrosoftKiotaAbstractions
+  class ParseNodeFactoryRegistry
+    include ParseNodeFactory
+
+    class << self
+    attr_accessor :default_instance
+    def default_instance; @default_instance ||= ParseNodeFactoryRegistry.new; end
+    end
+
+    def default_instance
+    self.class.default_instance
+    end
+
+    def content_type_associated_factories
+      @content_type_associated_factories ||= Hash.new
+    end
+
+    def get_parse_node(content_type, content)
+      if !content_type
+        raise Exception.new 'content type cannot be undefined or empty'
+      end
+      if !content
+        raise Exception.new 'content cannot be undefined or empty'
+      end
+      vendor_specific_content_type = content_type.split(';').first
+      factory = @content_type_associated_factories[vendor_specific_content_type]
+      if factory
+        return factory.get_parse_node(vendor_specific_content_type, content)
+      end
+
+      clean_content_type = vendor_specific_content_type.gsub(/[^\/]+\+/i, '')
+      factory = @content_type_associated_factories[clean_content_type]
+      if factory
+        return factory.get_parse_node(clean_content_type, content)
+      end
+      raise Exception.new "Content type #{contentType} does not have a factory to be parsed"
+    end
+        
+  end
+end

data/lib/microsoft_kiota_abstractions/serialization/serialization_writer.rb

@@ -0,0 +1,69 @@
+module MicrosoftKiotaAbstractions
+  module SerializationWriter
+
+    def write_string_value(key, value)
+      raise NotImplementedError.new
+    end
+
+    def write_boolean_value(key, value)
+      raise NotImplementedError.new
+    end
+
+    def write_number_value(key, value)
+      raise NotImplementedError.new
+    end
+
+    def write_float_value(key, value)
+      raise NotImplementedError.new
+    end
+
+    def get_date_value(key, value)
+      raise NotImplementedError.new
+    end
+
+    def write_guid_value(key, value)
+      raise NotImplementedError.new
+    end
+
+    def write_date_value(key, value)
+      raise NotImplementedError.new
+    end
+    
+    def write_time_value(key, value)
+      raise NotImplementedError.new
+    end
+
+    def write_date_time_value(key, value)
+      raise NotImplementedError.new
+    end
+
+    def write_duration_value(key, value)
+      raise NotImplementedError.new
+    end
+
+    def write_collection_of_primitive_values(key, value)
+      raise NotImplementedError.new
+    end
+
+    def write_collection_of_object_values(key, value)
+      raise NotImplementedError.new
+    end
+
+    def write_enum_value(key, value)
+      raise NotImplementedError.new
+    end
+
+    def get_serialized_content()
+      raise NotImplementedError.new
+    end
+
+    def write_additional_data(type)
+      raise NotImplementedError.new
+    end
+
+    def write_any_value(key, value)
+      raise NotImplementedError.new
+    end
+    
+  end
+end

data/lib/microsoft_kiota_abstractions/serialization/serialization_writer_factory.rb

@@ -0,0 +1,9 @@
+module MicrosoftKiotaAbstractions
+  module SerializationWriterFactory
+
+    def get_serialization_writer(content_type)
+      raise NotImplementedError.new
+    end
+    
+  end
+end