aspose_email_cloud 1.0.2 → 18.7.0

data/lib/aspose_email_cloud/api_client.rb

@@ -1,335 +0,0 @@
-require 'date'
-require 'json'
-require 'logger'
-require 'tempfile'
-require 'typhoeus'
-require 'uri'
-require 'openssl'
-require 'base64'
-require 'rexml/document'
-
-module AsposeEmailCloud
-  class ApiClient
-    
-    include AsposeStorageCloud
-    
-    attr_accessor :host
-
-    # Defines the headers to be used in HTTP requests of all API calls by default.
-    #
-    # @return [Hash]
-    attr_accessor :default_headers
-
-    # Stores the HTTP response from the last API call using this API client.
-    attr_accessor :last_response
-
-    def initialize(host = nil)
-      @host = host || Configuration.base_url
-      @format = 'json'
-      @user_agent = "ruby-swagger-#{VERSION}"
-      @default_headers = {
-        'Content-Type' => "application/#{@format.downcase}",
-        'User-Agent' => @user_agent
-      }
-    end
-
-    def call_api(http_method, path, opts = {})
-      request = build_request(http_method, path, opts)
-      response = request.run
-
-      # record as last response
-      @last_response = response
-
-      if Configuration.debugging
-        Configuration.logger.debug "HTTP response body ~BEGIN~\n#{response.body}\n~END~\n"
-      end
-
-      unless response.success?
-        fail ApiError.new(:code => response.code,
-                          :response_headers => response.headers,
-                          :response_body => response.body),
-             response.status_message
-      end
-
-      if opts[:return_type]
-        deserialize(response, opts[:return_type])
-      else
-        nil
-      end
-    end
-
-    def build_request(http_method, path, opts = {})
-      url = build_request_url(path)
-      http_method = http_method.to_sym.downcase
-      
-      header_params = @default_headers.merge(opts[:header_params] || {})
-      query_params = {}
-      form_params = opts[:form_params] || {}
-
-      req_opts = {
-        :method => http_method,
-        :headers => header_params,
-        :params => query_params,
-        :ssl_verifypeer => Configuration.verify_ssl,
-        :sslcert => Configuration.cert_file,
-        :sslkey => Configuration.key_file,
-        :cainfo => Configuration.ssl_ca_cert,
-        :verbose => Configuration.debugging
-      }
-
-      if [:post, :patch, :put, :delete].include?(http_method)
-        req_body = build_request_body(header_params, form_params, opts[:body])
-        req_opts.update :body => req_body
-        if Configuration.debugging
-          Configuration.logger.debug "HTTP request body param ~BEGIN~\n#{req_body}\n~END~\n"
-        end
-      end
-      
-      url = sign(url, opts[:query_params])
-      Typhoeus::Request.new(url, req_opts)
-
-    end
-    
-    # Signs a URI with your appSID and Key.
-    # * :url describes the URL to sign
-    
-    def sign(url, query_params)
-        
-      fail "Please set Aspose App key and SID first. You can get App key and App SID from https://cloud.aspose.com" if AsposeApp.app_key.nil? || AsposeApp.app_sid.nil?
-      
-      url = url[0..-2] if url[-1].eql? '/'
-
-      unless query_params.empty?
-        url = "#{url}?"
-        query_params.each { |key, value|
-          url = "#{url}#{key}=#{value}&"
-        }
-        url = url[0..-2]
-      end
-
-      url = URI.escape(url)
-      parsed_url = URI.parse(url)
-        
-      url_to_sign = "#{parsed_url.scheme}://#{parsed_url.host}#{parsed_url.path}"
-      url_to_sign += "?#{parsed_url.query}" if parsed_url.query
-      if parsed_url.query
-        url_to_sign += "&appSID=#{AsposeApp.app_sid}"
-      else
-        url_to_sign += "?appSID=#{AsposeApp.app_sid}"
-      end  
-        
-      # create a signature using the private key and the URL
-      raw_signature = OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha1'), AsposeApp.app_key, url_to_sign)
-        
-      #Convert raw to encoded string
-      signature = Base64.strict_encode64(raw_signature).tr('+/', '-_')
-        
-      #remove invalid character
-      signature = signature.gsub(/[=_-]/, '=' => '', '_' => '%2f', '-' => '%2b')
-        
-      #Define expression
-      pat = Regexp.new('%[0-9a-f]{2}')
-        
-      #Replace the portion matched to the above pattern to upper case
-      6.times do
-        signature = signature.sub(pat, pat.match(signature).to_s.upcase)
-      end
-      
-      # prepend the server and append the signature.
-      url_to_sign + "&signature=#{signature}"
-
-    end
-
-    # Deserialize the response to the given return type.
-    #
-    # @param [String] return_type some examples: "User", "Array[User]", "Hash[String,Integer]"
-    def deserialize(response, return_type)
-      body = response.body
-      return nil if body.nil? || body.empty?
-
-      # handle file downloading - save response body into a tmp file and return the File instance
-      return download_file(response) if return_type == 'File'
-
-      # ensuring a default content type
-      content_type = response.headers['Content-Type'] || 'application/json'
-
-      unless content_type.start_with?('application/json')
-        fail "Content-Type is not supported: #{content_type}"
-      end
-
-      begin
-        data = JSON.parse("[#{body}]", :symbolize_names => true)[0]
-      rescue JSON::ParserError => e
-        if %w(String Date DateTime).include?(return_type)
-          data = body
-        else
-          raise e
-        end
-      end
-
-      convert_to_type data, return_type
-    end
-
-    # Convert data to the given return type.
-    def convert_to_type(data, return_type)
-      return nil if data.nil?
-      case return_type
-      when 'String'
-        data.to_s
-      when 'Integer'
-        data.to_i
-      when 'Float'
-        data.to_f
-      when 'BOOLEAN'
-        data == true
-      when 'DateTime'
-        # parse date time (expecting ISO 8601 format)
-        DateTime.parse data
-      when 'Date'
-        # parse date time (expecting ISO 8601 format)
-        Date.parse data
-      when 'Object'
-        # generic object, return directly
-        data
-      when /\AArray<(.+)>\z/
-        # e.g. Array<Pet>
-        sub_type = $1
-        data.map {|item| convert_to_type(item, sub_type) }
-      when /\AHash\<String, (.+)\>\z/
-        # e.g. Hash<String, Integer>
-        sub_type = $1
-        {}.tap do |hash|
-          data.each {|k, v| hash[k] = convert_to_type(v, sub_type) }
-        end
-      else
-        # models, e.g. Pet
-        AsposeEmailCloud.const_get(return_type).new.tap do |model|
-          model.build_from_hash data
-        end
-      end
-    end
-
-    # Save response body into a file in (the defined) temporary folder, using the filename
-    # from the "Content-Disposition" header if provided, otherwise a random filename.
-    #
-    # @see Configuration#temp_folder_path
-    # @return [File] the file downloaded
-    def download_file(response)
-      tmp_file = Tempfile.new '', Configuration.temp_folder_path
-      content_disposition = response.headers['Content-Disposition']
-
-      if content_disposition
-        filename = content_disposition[/filename=['"]?([^'"\s]+)['"]?/, 1]
-        path = File.join File.dirname(tmp_file), filename
-      else
-        path = tmp_file.path
-      end
-      # close and delete temp file
-      tmp_file.close!
-
-      File.open(path, 'wb') { |file| file.write(response.body) }
-      Configuration.logger.info "File written to #{path}. Please move the file to a proper "\
-                                "folder for further processing and delete the temp afterwards"
-      File.new(path)
-    end
-
-    def build_request_url(path)
-      # Add leading and trailing slashes to path
-      path = "/#{path}".gsub(/\/+/, '/')
-      URI.encode(host + path)
-    end
-
-    def build_request_body(header_params, form_params, body)
-      # http form
-      if header_params['Content-Type'] == 'application/x-www-form-urlencoded' ||
-          header_params['Content-Type'] == 'multipart/form-data'
-        
-        data = form_params.dup
-        data.each do |key, value|
-          if key.eql? "file"
-            data = value
-            break
-          else
-            data[key] = value.to_s if value && !value.is_a?(File)
-          end
-        end
-      elsif body
-        data = body.is_a?(String) ? body : body.to_json
-      else
-        data = nil
-      end
-      data
-    end
-
-    # Update hearder and query params based on authentication settings.
-    def update_params_for_auth!(header_params, query_params, auth_names)
-      Array(auth_names).each do |auth_name|
-        auth_setting = Configuration.auth_settings[auth_name]
-        next unless auth_setting
-        case auth_setting[:in]
-        when 'header' then header_params[auth_setting[:key]] = auth_setting[:value]
-        when 'query'  then query_params[auth_setting[:key]] = auth_setting[:value]
-        else fail ArgumentError, 'Authentication token must be in `query` of `header`'
-        end
-      end
-    end
-
-    def user_agent=(user_agent)
-      @user_agent = user_agent
-      @default_headers['User-Agent'] = @user_agent
-    end
-
-    # Return Accept header based on an array of accepts provided.
-    # @param [Array] accepts array for Accept
-    # @return [String] the Accept header (e.g. application/json)
-    def select_header_accept(accepts)
-      if accepts.empty?
-        return
-      elsif accepts.any?{ |s| s.casecmp('application/json') == 0 }
-        'application/json' # look for json data by default
-      else
-        accepts.join(',')
-      end
-    end
-
-    # Return Content-Type header based on an array of content types provided.
-    # @param [Array] content_types array for Content-Type
-    # @return [String] the Content-Type header  (e.g. application/json)
-    def select_header_content_type(content_types)
-      if content_types.empty?
-        'application/json' # use application/json by default
-      elsif content_types.any?{ |s| s.casecmp('application/json')==0 }
-        'application/json' # use application/json if it's included
-      else
-        content_types[0] # otherwise, use the first one
-      end
-    end
-
-    # Convert object (array, hash, object, etc) to JSON string.
-    # @param [Object] model object to be converted into JSON string
-    # @return [String] JSON string representation of the object
-    def object_to_http_body(model)
-      return if model.nil?
-      _body = nil
-      if model.is_a?(Array)
-        _body = model.map{|m| object_to_hash(m) }
-      else
-        _body = object_to_hash(model)
-      end
-      _body.to_json
-    end
-
-    # Convert object(non-array) to hash.
-    # @param [Object] obj object to be converted into JSON string
-    # @return [String] JSON string representation of the object
-    def object_to_hash(obj)
-      if obj.respond_to?(:to_hash)
-        obj.to_hash
-      else
-        obj
-      end
-    end
-     
-    
-  end
-end

data/lib/aspose_email_cloud/api_error.rb

@@ -1,24 +0,0 @@
-module AsposeEmailCloud
-  class ApiError < StandardError
-    attr_reader :code, :response_headers, :response_body
-
-    # Usage examples:
-    #   ApiError.new
-    #   ApiError.new("message")
-    #   ApiError.new(:code => 500, :response_headers => {}, :response_body => "")
-    #   ApiError.new(:code => 404, :message => "Not Found")
-    def initialize(arg = nil)
-      if arg.is_a? Hash
-        arg.each do |k, v|
-          if k.to_s == 'message'
-            super v
-          else
-            instance_variable_set "@#{k}", v
-          end
-        end
-      else
-        super arg
-      end
-    end
-  end
-end

data/lib/aspose_email_cloud/models/base_object.rb

@@ -1,88 +0,0 @@
-require 'date'
-
-module AsposeEmailCloud
-  # base class containing fundamental method such as to_hash, build_from_hash and more
-  class BaseObject
-
-    # build the object from hash
-    def build_from_hash(attributes)
-      return nil unless attributes.is_a?(Hash)
-      self.class.swagger_types.each_pair do |key, type|
-        if type =~ /^Array<(.*)>/i
-          if attributes[self.class.attribute_map[key]].is_a?(Array)
-            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
-          else
-            #TODO show warning in debug mode
-          end
-        elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
-        else
-          # data not found in attributes(hash), not an issue as the data can be optional
-        end
-      end
-
-      self
-    end
-
-    def _deserialize(type, value)
-      case type.to_sym
-      when :DateTime
-        DateTime.parse(value)
-      when :Date
-        Date.parse(value)
-      when :String
-        value.to_s
-      when :Integer
-        value.to_i
-      when :Float
-        value.to_f
-      when :BOOLEAN
-        if value =~ /^(true|t|yes|y|1)$/i
-          true
-        else
-          false
-        end
-      when :Object
-        value
-      else # model
-        _model = AsposeEmailCloud.const_get(type).new
-        _model.build_from_hash(value)
-      end
-    end
-
-    def to_s
-      to_hash.to_s
-    end
-
-    # to_body is an alias to to_body (backward compatibility))
-    def to_body
-      to_hash
-    end
-
-    # return the object in the form of hash
-    def to_hash
-      hash = {}
-      self.class.attribute_map.each_pair do |attr, param|
-        value = self.send(attr)
-        next if value.nil?
-        if value.is_a?(Array)
-          hash[param] = value.compact.map{ |v| _to_hash(v) }
-        else
-          hash[param] = _to_hash(value)
-        end
-      end
-      hash
-    end
-
-    # Method to output non-array value in the form of hash
-    # For object, use to_hash. Otherwise, just return the value
-    def _to_hash(value)
-      if value.respond_to? :to_hash
-        value.to_hash
-      else
-        value
-      end
-    end
-
-  end
-end

data/lib/aspose_email_cloud/models/email_document.rb

@@ -1,63 +0,0 @@
-module AsposeEmailCloud
-  # 
-  class EmailDocument < BaseObject
-    attr_accessor :links, :document_properties, :data, :format
-    # attribute mapping from ruby-style variable name to JSON key
-    def self.attribute_map
-      {
-        
-        # 
-        :'links' => :'Links',
-        
-        # 
-        :'document_properties' => :'DocumentProperties',
-        
-        # 
-        :'data' => :'Data',
-        
-        # 
-        :'format' => :'Format'
-        
-      }
-    end
-
-    # attribute type
-    def self.swagger_types
-      {
-        :'links' => :'Array<Link>',
-        :'document_properties' => :'EmailProperties',
-        :'data' => :'Stream',
-        :'format' => :'String'
-        
-      }
-    end
-
-    def initialize(attributes = {})
-      return if !attributes.is_a?(Hash) || attributes.empty?
-
-      # convert string to symbol for hash key
-      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
-
-      
-      if attributes[:'Links']
-        if (value = attributes[:'Links']).is_a?(Array)
-          self.links = value
-        end
-      end
-      
-      if attributes[:'DocumentProperties']
-        self.document_properties = attributes[:'DocumentProperties']
-      end
-      
-      if attributes[:'Data']
-        self.data = attributes[:'Data']
-      end
-      
-      if attributes[:'Format']
-        self.format = attributes[:'Format']
-      end
-      
-    end
-
-  end
-end