imagekitio 1.0.10 → 2.1.0

data/lib/imagekitio/constants/url.rb

@@ -0,0 +1,14 @@
+module ImageKitIo
+  module Constants
+    module URL
+      # Default URL Constants
+      BASE_URL = "https://api.imagekit.io/v1/files"
+      PURGE_CACHE = "/purge"
+      BULK_FILE_DELETE = "/batch/deleteByFileIds"
+      UPLOAD = "/upload"
+      REMOTE_METADATA_FULL_URL = "https://api.imagekit.io/v1/metadata"
+      BULK_BASE_URL = 'https://api.imagekit.io/v1/bulkJobs'
+      API_BASE_URL = 'https://api.imagekit.io/v1'
+    end
+  end
+end

data/lib/imagekitio/errors.rb

@@ -0,0 +1,4 @@
+module ImageKitIo
+  class Error < StandardError
+  end
+end

data/lib/imagekitio/railtie.rb

@@ -1,4 +1,4 @@
-module Imagekitio
+module ImageKitIo
   class Railtie < ::Rails::Railtie
   end
 end

data/lib/imagekitio/request.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "base64"
+require "rest-client"
+require "json"
+require 'net/http/post/multipart'
+require_relative './constant'
+# Request requests and sends data from server
+module ImageKitIo
+  class Request
+    include Constantable
+
+    attr_reader :private_key, :public_key, :url_endpoint, :transformation_position, :options
+
+    def initialize(private_key, public_key, url_endpoint, transformation_position = nil, options = nil)
+      @private_key = private_key
+      @public_key = public_key
+      @url_endpoint = url_endpoint
+      @transformation_position = transformation_position || constants.TRANSFORMATION_POSITION
+      @options = options || {}
+    end
+
+    # creates required headers
+    def create_headers
+      headers = {'Accept-Encoding': "application/json", 'Content-Type': "application/json"}
+      headers.update(auth_headers)
+    end
+
+    def auth_headers
+      encoded_private_key = Base64.strict_encode64(@private_key+":")
+      {Authorization: "Basic #{encoded_private_key}"}
+    end
+
+    # request method communicates with server
+    def request(method, url, headers = create_headers, payload = nil)
+      headers ||= create_headers
+      response = {}
+      begin
+        if(method.downcase.to_sym == :post)
+          uri = URI.parse(url)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = (uri.scheme == 'https')
+          req = Net::HTTP::Post::Multipart.new uri.path, payload, headers
+          resp = http.request(req)
+          if resp.code.to_i == 400
+            raise RestClient::ExceptionWithResponse, OpenStruct.new(code: 400, body: resp.body)
+          end
+        else
+          resp = RestClient::Request.new(method: method,
+                                         url: url,
+                                         headers: headers,
+                                         payload: payload).execute
+        end
+        if (resp.code.to_i >= 200) && (resp.code.to_i < 204)
+          content_type = resp.respond_to?(:headers) ? resp.headers[:content_type] : resp.content_type
+          if (content_type.include? "application/json")
+            response[:response] = JSON.parse(resp.body.to_s)
+          else
+            raise RestClient::ExceptionWithResponse, OpenStruct.new(code: 404, body: resp.body)
+          end
+        elsif resp.code.to_i == 204
+          response[:response] = {'success': true}
+        end
+
+      rescue RestClient::ExceptionWithResponse => err
+        response[:error] = if err.http_code.to_i == 404
+                             {'message': err.response.to_s}
+                           else
+                             err.response.is_a?(OpenStruct) ? JSON.parse(err.response.body) : JSON.parse(err.response)
+                           end
+      end
+      response
+    end
+
+    def request_stream(method, url, headers: nil, payload: nil, **options, &block)
+      headers ||= create_headers
+      response = { response: nil, error: nil }
+      begin
+        RestClient::Request.execute(method: method,
+                                    url: url,
+                                    headers: headers,
+                                    payload: payload,
+                                    **options,
+                                    block_response: block
+                                    )
+      rescue RestClient::ExceptionWithResponse => err
+        err.http_code == 404 ? response[:error] = {'message': err.response.to_s} : JSON.parse(err.response)
+      end
+    end
+  end
+end

data/lib/imagekitio/sdk/version.rb

@@ -0,0 +1,5 @@
+module ImageKitIo
+  module Sdk
+    VERSION = '2.1.0'
+  end
+end

data/lib/imagekitio/url.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+# Url holds url generation method
+
+require "cgi"
+require "addressable/uri"
+require "openssl"
+require_relative "./utils/formatter"
+require_relative "sdk/version.rb"
+
+module ImageKitIo
+  class Url
+    include Constantable
+
+    def initialize(request_obj)
+      @req_obj = request_obj
+    end
+
+    def generate_url(options)
+      if options.key? :src
+        options[:transformation_position] = constants.TRANSFORMATION_POSITION
+      end
+      extended_options = extend_url_options(options)
+      build_url(extended_options)
+    end
+
+    def build_url(options)
+      # build url from all options
+
+      path = options.fetch(:path, "")
+      src = options.fetch(:src, "")
+      url_endpoint = options.fetch(:url_endpoint, "")
+      transformation_position = options[:transformation_position]
+
+      unless constants.VALID_TRANSFORMATION_POSITION.include? transformation_position
+        raise ArgumentError, constants.INVALID_TRANSFORMATION_POS
+      end
+
+      src_param_used_for_url = false
+      if (src != "") || (transformation_position == constants.QUERY_TRANSFORMATION_POSITION)
+        src_param_used_for_url = true
+      end
+
+      if path == "" && src == ""
+        return ""
+      end
+
+      result_url_hash = {'host': "", 'path': "", 'query': ""}
+      existing_query=nil
+      if path != ""
+        parsed_url = Addressable::URI.parse(path)
+        existing_query=parsed_url.query
+        parsed_host = Addressable::URI.parse(url_endpoint)
+        result_url_hash[:scheme] = parsed_host.scheme
+
+        # making sure single '/' at end
+        result_url_hash[:host] = parsed_host.host.to_s.chomp("/") + parsed_host.path.chomp("/") + "/"
+        result_url_hash[:path] = trim_slash(parsed_url.path)
+      else
+        parsed_url = Addressable::URI.parse(src)
+        existing_query=parsed_url.query
+        host = parsed_url.host
+        result_url_hash[:userinfo] = parsed_url.userinfo if parsed_url.userinfo
+        result_url_hash[:host] = host
+        result_url_hash[:scheme] = parsed_url.scheme
+        result_url_hash[:path] = parsed_url.path
+        src_param_used_for_url = true
+      end
+      query_params = {}
+      if existing_query!=nil
+        existing_query.split("&").each do |part|
+          parts=part.split("=")
+          if parts.length==2
+            query_params[parts[0]]=parts[1]
+          end
+        end
+      end
+      options.fetch(:query_parameters, {}).each do |key, value|
+        query_params[key]=value
+      end
+      transformation_str = transformation_to_str(options[:transformation]).chomp("/")
+
+      unless transformation_str.nil? || transformation_str.strip.empty?
+        if (transformation_position == constants.QUERY_TRANSFORMATION_POSITION) || src_param_used_for_url == true
+          result_url_hash[:query] = "#{constants.TRANSFORMATION_PARAMETER}=#{transformation_str}"
+          query_params[:tr]=transformation_str
+        else
+          result_url_hash[:path] = "#{constants.TRANSFORMATION_PARAMETER}:#{transformation_str}/#{result_url_hash[:path]}"
+        end
+
+      end
+
+      result_url_hash[:host] = result_url_hash[:host].to_s.reverse.chomp("/").reverse
+      result_url_hash[:path] = result_url_hash[:path].chomp("/")
+      result_url_hash[:scheme] ||= "https"
+
+      query_param_arr = []
+      query_param_arr.push("ik-sdk-version=ruby-"+ImageKitIo::Sdk::VERSION)
+      query_params.each do |key, value|
+        if value.to_s == ""
+          query_param_arr.push(key.to_s)
+        else
+          query_param_arr.push(key.to_s + "=" + value.to_s)
+        end
+      end
+
+      query_param_str = query_param_arr.join("&")
+      result_url_hash[:query] = query_param_str
+
+      # Signature String and Timestamp
+      # We can do this only for URLs that are created using urlEndpoint and path parameter
+      # because we need to know the endpoint to be able to remove it from the URL to create a signature
+      # for the remaining. With the src parameter, we would not know the "pattern" in the URL
+      if options[:signed] && !(options[:src])
+        intermediate_url = result_url_hash.fetch(:scheme, "") + "://" + result_url_hash.fetch(:host, "") + result_url_hash.fetch(:path, "")
+        if result_url_hash[:query]!=nil && result_url_hash[:query]!=""
+          intermediate_url += result_url_hash.fetch(:query, "")
+        end
+      end
+
+      url=hash_to_url(result_url_hash)
+      if options[:signed]
+        private_key = options[:private_key]
+        expire_seconds = options[:expire_seconds]
+        expire_timestamp = get_signature_timestamp(expire_seconds)
+        url_signature = get_signature(private_key, url, url_endpoint, expire_timestamp)
+        query_param_arr.push(constants.SIGNATURE_PARAMETER + "=" + url_signature)
+
+        if expire_timestamp && (expire_timestamp != constants.TIMESTAMP)
+          query_param_arr.push(constants.TIMESTAMP_PARAMETER + "=" + expire_timestamp.to_s)
+        end
+
+        query_param_str = query_param_arr.join("&")
+        result_url_hash[:query] = query_param_str
+
+        url=hash_to_url(result_url_hash)
+      end
+      url
+    end
+
+    def transformation_to_str(transformation)
+      # creates transformation_position string for url
+      # from transformation dictionary
+
+      unless transformation.is_a?(Array)
+        return ""
+      end
+
+      parsed_transforms = []
+      (0..(transformation.length - 1)).each do |i|
+        parsed_transform_step = []
+
+        transformation[i].keys.each do |key|
+          transform_key = constants.SUPPORTED_TRANS.fetch(key, nil)
+          transform_key ||= key
+
+          if transform_key == "oi" || transform_key == "di"
+            transformation[i][key][0] = "" if transformation[i][key][0] == "/"
+            transformation[i][key] = transformation[i][key].gsub("/", "@@")
+          end
+
+          if transformation[i][key] == "-"
+            parsed_transform_step.push(transform_key)
+          elsif transform_key == 'raw'
+            parsed_transform_step.push(transformation[i][key])
+          else
+            parsed_transform_step.push("#{transform_key}#{constants.TRANSFORM_KEY_VALUE_DELIMITER}#{transformation[i][key]}")
+          end
+        end
+        parsed_transforms.push(parsed_transform_step.join(constants.TRANSFORM_DELIMITER))
+      end
+      parsed_transforms.join(constants.CHAIN_TRANSFORM_DELIMITER)
+    end
+
+    def get_signature_timestamp(seconds)
+      # this function returns either default time stamp
+      # or current unix time and expiry seconds to get
+      # signature time stamp
+
+      if seconds.to_i == 0
+        constants.DEFAULT_TIMESTAMP
+      else
+        DateTime.now.strftime("%s").to_i + seconds.to_i
+      end
+    end
+
+    def get_signature(private_key, url, url_endpoint, expiry_timestamp)
+      # creates signature(hashed hex key) and returns from
+      # private_key, url, url_endpoint and expiry_timestamp
+      if expiry_timestamp==0
+        expiry_timestamp=constants.DEFAULT_TIMESTAMP
+      end
+      if url_endpoint[url_endpoint.length-1]!="/"
+        url_endpoint+="/"
+      end
+      replaced_url=url.gsub(url_endpoint, "")
+      replaced_url =  replaced_url + expiry_timestamp.to_s
+      OpenSSL::HMAC.hexdigest("SHA1", private_key, replaced_url)
+    end
+
+    def extend_url_options(options)
+      attr_dict = {"public_key": @req_obj.public_key,
+                   "private_key": @req_obj.private_key,
+                   "url_endpoint": @req_obj.url_endpoint,
+                   "transformation_position": @req_obj.transformation_position, }
+      # extending  url options
+      attr_dict.merge(options)
+    end
+
+    def hash_to_url(url_hash)
+      generated_url = url_hash.fetch(:scheme, "") + "://" + url_hash.fetch(:host, "") + url_hash.fetch(:path, "")
+      if url_hash[:query] != ""
+        generated_url = generated_url + "?" + url_hash.fetch(:query, "")
+        return generated_url
+      end
+      generated_url
+    end
+
+    def trim_slash(str, both = true)
+      if str == ""
+        return ""
+      end
+      # remove slash from a string
+      # if both is not provide trims both slash
+      # example - '/abc/' returns 'abc'
+      # if both=false it will only trim end slash
+      # example - '/abc/' returns '/abc'
+      # NOTE: IT'S RECOMMENDED TO USE inbuilt .chomp('string you want to remove')
+      # FOR REMOVING ONLY TRAILING SLASh
+      if both
+        str[0].chomp("/") + str[1..-2] + str[-1].chomp("/")
+      else
+        str.chomp("/")
+      end
+    end
+
+    # class Imagekit
+
+    # end
+  end
+end

data/lib/imagekitio/utils/calculation.rb

@@ -0,0 +1,44 @@
+require "date"
+require "securerandom"
+
+module ImageKitIo
+  module Utils
+    module Calculation
+      DEFAULT_TIME_DIFF = 60 * 30
+
+      module_function
+
+      def is_valid_hex(hex_string)
+        # checks if hexadecimal value is valid or not
+        /^[[:xdigit:]]+$/ === hex_string
+      end
+
+      def hamming_distance(first, second)
+        # Calculate Hamming distance between to hex string
+        unless is_valid_hex(first) && is_valid_hex(second)
+          raise ArgumentError, "Both argument should be hexadecimal"
+        end
+        a = first.to_i(16)
+        b = second.to_i(16)
+        (a ^ b).to_s(2).count("1")
+      end
+
+      def get_authenticated_params(token, expire, private_key)
+        # return authenticated param
+        default_expire = DateTime.now.strftime("%s").to_i + DEFAULT_TIME_DIFF
+        token ||= SecureRandom.uuid
+
+        auth_params = {'token': token, 'expire': expire, 'signature': ""}
+        unless private_key
+          return nil
+        end
+
+        signature = OpenSSL::HMAC.hexdigest("SHA1", private_key, token.to_s + expire.to_s)
+        auth_params[:token] = token
+        auth_params[:expire] = expire || default_expire
+        auth_params[:signature] = signature
+        auth_params
+      end
+    end
+  end
+end

data/lib/imagekitio/utils/formatter.rb

@@ -0,0 +1,48 @@
+require 'json'
+
+module ImageKitIo
+  module Utils
+    module Formatter
+
+      module_function
+      def snake_to_camel(word)
+        word_list = word.split("_")
+        result = []
+        word_list&.each { |i|
+          if i == word_list[0]
+            result.push(i)
+          else
+            result.push(i.capitalize)
+          end
+        }
+        result.join
+      end
+
+      def camel_to_snake(camel_word)
+        # convert camel case to snake case
+        camel_word.to_s.gsub(/::/, "/")
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr("-", "_")
+          .downcase
+      end
+
+      def request_formatter(data)
+        result = {}
+        data.each do |key, val|
+          result[snake_to_camel(key.to_s)] = val
+        end
+        result
+      end
+
+      def format_to_json(options, key, expected_class)
+        options ||= {}
+        val = options[key]
+        if !val.nil? && val.is_a?(expected_class)
+          options[key] = options[key].to_json
+        end
+        options
+      end
+    end
+  end
+end

data/lib/imagekitio/utils/option_validator.rb

@@ -0,0 +1,36 @@
+require_relative './formatter'
+
+module ImageKitIo
+  module Utils
+    module OptionValidator
+      include Formatter
+      include Constantable
+
+      module_function
+
+      def validate_upload_options(options)
+
+        #  Validates upload value, checks if params are valid,
+        #  changes snake to camel case which is supported by
+        #  ImageKitIo server
+
+
+        response_list = []
+        options.each do |key, val|
+          if constants.VALID_UPLOAD_OPTIONS.include?(key.to_s)
+            if val.is_a?(Array)
+              val = val.join(",")
+            end
+            if val.is_a?(TrueClass) || val.is_a?(FalseClass)
+              val = val.to_s
+            end
+            options[key] = val
+          else
+            return false
+          end
+        end
+        request_formatter(options)
+      end
+    end
+  end
+end

data/lib/imagekitio.rb

@@ -1,86 +1,13 @@
-require "imagekitio/railtie"
+require "imagekitio/railtie" if defined? Rails
 
-require 'carrierwave'
 require 'base64'
-require_relative './carrierwave/storage/imagekit_store'
-require_relative './carrierwave/storage/ik_file'
-require_relative './carrierwave/support/uri_filename'
-require_relative './imagekit/imagekit.rb'
-require_relative "./imagekit/resource"
-require_relative "./imagekit/file"
-require_relative "./imagekit/url"
-require_relative "./imagekit/utils/calculation"
 
-module CarrierWave
-    module Uploader
-      class Base
-  
-        def initialize(*)
-          ik_config=Rails.application.config.imagekit
-          @imagekit=ImageKit::ImageKitClient.new(ik_config[:private_key],ik_config[:public_key],ik_config[:url_endpoint])
-          @options={}
-        end
-  
-        configure do |config|
-          config.storage_engines[:imagekit_store] = 'CarrierWave::Storage::ImageKitStore'
-        end
-  
-        def filename
-          if options!=nil
-            @options=options
-          end
-          folder=nil
-          begin
-            folder=store_dir
-          rescue
-          end
-
-          if folder!=nil
-            @options[:folder]=folder
-          end
-
-          if self.file!=nil
-            base64=Base64.encode64(::File.open(self.file.file, "rb").read)
-            resp=@imagekit.upload_file(open(self.file.file,'rb'),self.file.filename,@options)
-            # ::File.delete(self.file.file)
-            res=resp[:response].to_json
-            if res!="null"
-              res
-            else
-              "{\"filePath\":\"\",\"url\":\"\",\"name\":\"\"}"
-            end
-          else
-            "{\"filePath\":\"\",\"url\":\"\",\"name\":\"\"}"
-          end
-        end
-  
-        def fileId
-          JSON.parse(self.identifier)['fileId']
-        end
-  
-        def blob
-          JSON.parse(self.identifier)
-        end
-  
-        def url_with(opt)
-          path=JSON.parse(self.identifier)['filePath']
-          opt[:path]=path
-          url=@imagekit.url(opt)
-        end
-  
-        def url
-          JSON.parse(self.identifier)['url']
-        end
-  
-        def options
-          options={}
-        end
-
-        def store_dir
-          store_dir=nil
-        end
-      end
-  
-    end
-  
-  end
+require_relative './imagekitio/constant'
+require_relative './imagekitio/base'
+require_relative './imagekitio/configurable'
+require_relative './imagekitio/client'
+require_relative "./imagekitio/request"
+require_relative "./imagekitio/url"
+require_relative './imagekitio/api_service/custom_metadata_field'
+require_relative './imagekitio/api_service/file'
+require_relative './imagekitio/api_service/folder'