imagekitio 1.0.10 → 2.1.0

data/lib/imagekitio/api_service/file.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+require_relative '../constant'
+require_relative '../utils/option_validator'
+require 'net/http/post/multipart'
+
+module ImageKitIo
+  module ApiService
+    class File
+      include Utils::OptionValidator
+      include Constantable
+
+      # This File class holds file related operations like
+      # upload, list etc
+      def initialize(req_obj)
+        @req_obj = req_obj
+      end
+
+      # uploads files with required arguments, supports bot url and binary
+      # Options types:
+      #  - `extensions` should be array of hash
+      #     eg: option['extension'] = [
+      #           { 'name' => 'remove-bg', 'options' => { 'add_shadow' => 'true' } },
+      #           { 'name' => 'google-auto-tagging', 'minConfidence' => 80 }
+      #         ]
+      #  - `custom_metadata` should be hash
+      #     eg: option['custom_metadata'] = {
+      #            "SKU": "VS882HJ2JD",
+      #            "price": 599.99,
+      #            "brand": "H&M",
+      #            "discount": 30
+      #         }
+      def upload(file: nil, file_name: nil, **options)
+        raise ArgumentError, constants.MISSING_UPLOAD_FILE_PARAMETER unless file
+        raise ArgumentError, constants.MISSING_UPLOAD_FILE_PARAMETER unless file_name
+
+        content_type = options.delete(:content_type) || ''
+        options = format_to_json(options, :extensions, Array)
+        options = format_to_json(options, :custom_metadata, Hash)
+        options = validate_upload_options(options || {})
+        if options.is_a?(FalseClass)
+          raise ArgumentError, "Invalid Upload option"
+        else
+          headers = @req_obj.create_headers
+          payload =  {
+            multipart: true,
+            file: file.is_a?(String) ? file : ::UploadIO.new(file, content_type, file_name),
+            fileName: file_name
+          }
+          payload.merge!(options)
+          url = "#{constants.BASE_URL}#{constants.UPLOAD}"
+          @req_obj.request("post", url, headers, payload)
+        end
+      end
+
+      def update_details(file_id: nil, **options)
+        unless options.fetch(:tags, []).is_a?(Array)
+          raise ArgumentError, constants.UPDATE_DATA_TAGS_INVALID
+        end
+        unless options.fetch(:custom_coordinates, "").is_a?(String)
+          raise ArgumentError, constants.UPDATE_DATA_COORDS_INVALID
+        end
+        url = "#{constants.BASE_URL}/#{file_id}/details/"
+        headers = @req_obj.create_headers
+        payload = request_formatter(options || {})
+        @req_obj.request("patch", url, headers, payload.to_json)
+      end
+
+      def list(**options)
+        #  returns list of files on ImageKitIo Server
+        #  :options dictionary of options
+        formatted_options = request_formatter(options || {})
+        raise KeyError(constants.LIST_FILES_INPUT_MISSING) unless formatted_options.is_a?(Hash)
+        url = constants.BASE_URL
+        headers = @req_obj.create_headers.update({params: formatted_options})
+        @req_obj.request("get", url, headers, formatted_options)
+      end
+
+      def details(file_identifier: nil)
+        # Get detail of file by file_identifier
+        if file_identifier == "" || file_identifier.nil?
+          raise ArgumentError, "file_identifier is required"
+        end
+        url = "#{constants.BASE_URL}/#{file_identifier}/details/"
+        headers = @req_obj.create_headers
+        @req_obj.request("get", url, headers)
+      end
+
+      def get_metadata(file_id: nil)
+        # Get metadata of a file by file_id
+        if file_id == "" || file_id.nil?
+          raise ArgumentError, "file_id is required"
+        end
+        url = "#{constants.BASE_URL}/#{file_id}/metadata"
+        @req_obj.request("get", url, @req_obj.create_headers)
+      end
+
+      def delete(file_id: nil)
+        # Delete a file_id by file_id
+        if file_id == "" || file_id.nil?
+          raise ArgumentError, "file_id is required"
+        end
+        url = "#{constants.BASE_URL}/#{file_id}"
+        headers = @req_obj.create_headers
+        @req_obj.request("delete", url, headers)
+      end
+
+      def purge_cache(file_url: nil)
+        # purges cache from server by file_url
+        if file_url == "" || file_url.nil?
+          raise ArgumentError, "file_url is required"
+        end
+        url = "#{constants.BASE_URL}/purge"
+        payload = {'url': file_url}
+        @req_obj.request("post", url, @req_obj.create_headers, payload)
+      end
+
+      def purge_cache_status(request_id: nil)
+        # This function is to get cache_status
+        if request_id == "" || request_id.nil?
+          raise ArgumentError, "remote_file_url is required"
+        end
+        url = "#{constants.BASE_URL}/purge/#{request_id}"
+        @req_obj.request("get", url, @req_obj.create_headers)
+      end
+
+      def get_metadata_from_remote_url(remote_file_url: nil)
+        if remote_file_url == "" || remote_file_url.nil?
+          raise ArgumentError, "remote_file_url is required"
+        end
+        url = "#{constants.REMOTE_METADATA_FULL_URL}?url=#{remote_file_url}"
+        @req_obj.request("get", url, @req_obj.create_headers)
+      end
+
+      def stream_file(remote_file_url: nil, &block)
+        if remote_file_url == '' || remote_file_url.nil?
+          raise ArgumentError, 'remote_file_url is required'
+        end
+        @req_obj.request_stream('get', remote_file_url, headers: @req_obj.create_headers, &block)
+      end
+
+      def copy(source_file_path: nil, destination_path: nil)
+        if source_file_path == '' || source_file_path.nil? || destination_path == '' || destination_path.nil?
+          raise ArgumentError, 'parameters required'
+        end
+        url = "#{constants.BASE_URL}/copy"
+        payload = { 'sourceFilePath': source_file_path, 'destinationPath': destination_path }
+        @req_obj.request('post', url, @req_obj.create_headers, payload)
+      end
+
+      def move(source_file_path: nil, destination_path: nil)
+        if source_file_path == '' || source_file_path.nil? || destination_path == '' || destination_path.nil?
+          raise ArgumentError, 'parameters required'
+        end
+        url = "#{constants.BASE_URL}/move"
+        payload = { 'sourceFilePath': source_file_path, 'destinationPath': destination_path }
+        @req_obj.request('post', url, @req_obj.create_headers, payload)
+      end
+
+      def rename(file_path: nil, new_file_name: nil, **options)
+        if file_path == '' || file_path.nil? || new_file_name == '' || new_file_name.nil?
+          raise ArgumentError, 'parameters required'
+        end
+        url = "#{constants.BASE_URL}/rename"
+        payload = { 'filePath': file_path, 'newFileName': new_file_name }.merge(request_formatter(options)).to_json
+        @req_obj.request('put', url, @req_obj.create_headers, payload)
+      end
+
+
+      private
+      def image_format?(type)
+        %(image/jpeg image/bmp image/apng image/avif image/gif image/ief image/svg+xml image/tiff image/x-icon image/rgb image/webp).include?(type)
+      end
+    end
+  end
+end

data/lib/imagekitio/api_service/folder.rb

@@ -0,0 +1,49 @@
+require_relative '../constant'
+
+module ImageKitIo
+  module ApiService
+    class Folder
+      include Constantable
+
+      def initialize(req_obj)
+        @req_obj = req_obj
+      end
+
+      def create(folder_name: nil, parent_folder_path: nil)
+        if folder_name == '' || folder_name.nil?
+          raise ArgumentError, 'folder_name is required'
+        end
+        url = "#{constants.API_BASE_URL}/folder"
+        payload = { 'folderName': folder_name, 'parentFolderPath': parent_folder_path }.to_json
+        @req_obj.request('post', url, @req_obj.create_headers, payload)
+      end
+
+    def delete(folder_path: nil)
+        if folder_path == '' || folder_path.nil?
+          raise ArgumentError, 'folder_path is required'
+        end
+        url = "#{constants.API_BASE_URL}/folder"
+        payload = { 'folderPath': folder_path }
+        @req_obj.request('delete', url, @req_obj.create_headers, payload)
+      end
+
+      def copy(source_folder_path: nil, destination_path: nil)
+        if source_folder_path == '' || source_folder_path.nil? || destination_path == '' || destination_path.nil?
+          raise ArgumentError, 'Parameters required'
+        end
+        url = "#{constants.BULK_BASE_URL}/copyFolder"
+        payload = { 'sourceFolderPath': source_folder_path, 'destinationPath': destination_path }
+        @req_obj.request('post', url, @req_obj.create_headers, payload)
+      end
+
+      def move(source_folder_path: nil, destination_path: nil)
+        if source_folder_path == '' || source_folder_path.nil? || destination_path == '' || destination_path.nil?
+          raise ArgumentError, 'Parameters required'
+        end
+        url = "#{constants.BULK_BASE_URL}/moveFolder"
+        payload = { 'sourceFolderPath': source_folder_path, 'destinationPath': destination_path }
+        @req_obj.request('post', url, @req_obj.create_headers, payload)
+      end
+    end
+  end
+end

data/lib/imagekitio/base.rb

@@ -0,0 +1,12 @@
+require_relative './configurable'
+
+module ImageKitIo
+  include ImageKitIo::Configurable
+
+  class << self
+    def client
+      ik_config = config
+      @client ||= ImageKitIo::Client.new(ik_config.private_key, ik_config.public_key, ik_config.url_endpoint)
+    end
+  end
+end

data/lib/imagekitio/client.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+$VERBOSE = nil
+
+require_relative "./request"
+require_relative "./url"
+require_relative "./utils/calculation"
+require_relative './constant'
+require_relative './configurable'
+require_relative './api_service/custom_metadata_field'
+require_relative './api_service/folder'
+require_relative './api_service/file'
+require_relative './api_service/bulk'
+
+module ImageKitIo
+  # ImageKitIo class holds each method will be used by user
+  class Client
+    include Utils::Calculation
+    include Constantable
+
+    attr_reader :file_service, :custom_metadata_field_service, :folder_service, :bulk_service
+
+    def initialize(private_key, public_key, url_endpoint, transformation_pos = nil, options = nil)
+      unless(private_key.is_a?(String) && private_key.to_s.strip.length != 0)
+        raise ArgumentError, constants.MISSING_PRIVATE_KEY
+      end
+      unless(public_key.is_a?(String) && public_key.to_s.strip.length != 0)
+        raise ArgumentError, constants.MISSING_PUBLIC_KEY
+      end
+      unless(url_endpoint.is_a?(String) && url_endpoint.to_s.strip.length != 0)
+        raise ArgumentError, constants.MISSING_URL_ENDPOINT
+      end
+
+      @private_key = private_key
+      @public_key = public_key
+      @url_endpoint = url_endpoint
+      @transformation_position = transformation_pos
+      @options = options
+
+      @ik_req = Request.new(private_key, public_key, url_endpoint)
+      @url_obj = Url.new(@ik_req)
+      @file_service = ApiService::File.new(@ik_req)
+      @custom_metadata_field_service = ApiService::CustomMetadataField.new(@ik_req)
+      @folder_service = ApiService::Folder.new(@ik_req)
+      @bulk_service = ApiService::Bulk.new(@ik_req)
+    end
+
+    def set_ik_request(ik_req)
+      # setter for imagekit request mainly will be used for
+      # test
+      @ik_req = ik_req
+    end
+
+    def url(options = {})
+      @url_obj.generate_url(options)
+    end
+
+    def upload_file(file: nil, file_name: nil, **options)
+      # upload file to imagekit server
+      @file_service.upload(file: file, file_name: file_name, **options)
+    end
+
+    def list_files(options = {})
+      # list all files
+      @file_service.list(**options)
+    end
+
+    def get_file_details(file_id: nil)
+      # Get file detail by file-id or file_url
+      @file_service.details(file_identifier: file_id)
+    end
+
+    def update_file_details(file_id: nil, **options)
+      # update file details by file id and other options payload
+      @file_service.update_details(file_id: file_id, **options)
+    end
+
+    def delete_file(file_id: nil)
+      # Delete a file by file-id
+      @file_service.delete(file_id: file_id)
+    end
+
+    def get_file_metadata(file_id: nil)
+      # Get metadata of a file by file-id
+      @file_service.get_metadata(file_id: file_id)
+    end
+
+    def purge_file_cache(file_url: nil)
+      # Purge cache from ImageKitIo server by file_url
+      @file_service.purge_cache(file_url: file_url)
+    end
+
+    def purge_file_cache_status(request_id: nil)
+      @file_service.purge_cache_status(request_id: request_id.to_s)
+    end
+
+    # Get metadata from remote_file_url
+    # param remote_file_url: url string of remote file
+    def get_remote_file_url_metadata(remote_file_url: "")
+      @file_service.get_metadata_from_remote_url(remote_file_url: remote_file_url)
+    end
+
+    def stream_file(file_url: nil, &block)
+      @file_service.stream_file(remote_file_url: file_url, &block)
+    end
+
+    def copy_file(source_file_path: nil, destination_path: nil)
+      @file_service.copy(source_file_path: source_file_path, destination_path: destination_path)
+    end
+
+    def move_file(source_file_path: nil, destination_path: nil)
+      @file_service.move(source_file_path: source_file_path, destination_path: destination_path)
+    end
+
+    def rename_file(file_path: nil, new_file_name: nil, **options)
+      @file_service.rename(file_path: file_path, new_file_name: new_file_name, **options)
+    end
+
+    def add_bulk_tags(file_ids: [], tags: [])
+      @bulk_service.add_tags(file_ids: file_ids, tags: tags)
+    end
+
+    def delete_bulk_files(file_ids: [])
+      # Delete file in bulks by list of file id
+      @bulk_service.remove_files(file_ids: file_ids)
+    end
+
+    def delete_bulk_tags(file_ids: [], tags: [])
+      @bulk_service.remove_tags(file_ids: file_ids, tags: tags)
+    end
+
+    def delete_bulk_ai_tags(file_ids: [], ai_tags: [])
+      @bulk_service.remove_ai_tags(file_ids: file_ids, ai_tags: ai_tags)
+    end
+
+    def bulk_job_status(job_id: nil)
+      @bulk_service.job_status(job_id: job_id)
+    end
+
+    def create_folder(folder_name: nil, parent_folder_path: "/")
+      @folder_service.create(folder_name: folder_name, parent_folder_path: parent_folder_path)
+    end
+
+    def delete_folder(folder_path: nil)
+      @folder_service.delete(folder_path: folder_path)
+    end
+
+    def copy_folder(source_folder_path: nil, destination_path: nil)
+      @folder_service.copy(source_folder_path: source_folder_path, destination_path: destination_path)
+    end
+
+    def move_folder(source_folder_path: nil, destination_path: nil)
+      @folder_service.move(source_folder_path: source_folder_path, destination_path: destination_path)
+    end
+
+    def create_custom_metadata_field(name: nil, label: nil, schema: {})
+      @custom_metadata_field_service.create(name: name, label: label, schema: schema)
+    end
+
+    def get_custom_metadata_fields(options = {})
+      @custom_metadata_field_service.list(**options)
+    end
+
+    def update_custom_metadata_field(id: nil, label: nil, schema: nil)
+      @custom_metadata_field_service.update(id: id, label: label, schema: schema)
+    end
+
+    def delete_custom_metadata_field(id: nil)
+      @custom_metadata_field_service.delete(id: id)
+    end
+
+    def phash_distance(first, second)
+      # Get hamming distance between two phash(image hash) to check
+      # similarity between images
+      if first.to_s.strip == "" || second.to_s.strip == ""
+        raise ArgumentError, constants.MISSING_PHASH_VALUE
+      end
+      hamming_distance(first, second)
+    end
+
+    def get_authentication_parameters(token = nil, expire = nil)
+      # Get Authentication params
+      get_authenticated_params(token, expire, @ik_req.private_key)
+    end
+  end
+end

data/lib/imagekitio/configurable.rb

@@ -0,0 +1,43 @@
+module ImageKitIo
+  module Configurable
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    module ClassMethods
+      def config
+        @config ||= Configuration.new
+      end
+
+      def configure
+        yield config
+        initialize_service
+      end
+
+      def initialize_service
+        if config.service == :carrierwave
+          require_relative '../carrierwave/carrierwave'
+        elsif config.service == :active_storage
+          require_relative '../active_storage/active_storage'
+        end
+      end
+
+      def constants
+        config.constants
+      end
+    end
+
+    class Configuration
+      AVAILABLE_SERVICE = [:carrierwave, :active_storage]
+      attr_accessor :public_key, :private_key, :url_endpoint, :service
+
+      def service
+        @service&.to_sym || :carrierwave
+      end
+
+      def constants
+        @constants ||= ImageKitIo::Constant
+      end
+    end
+  end
+end

data/lib/imagekitio/constant.rb

@@ -0,0 +1,36 @@
+require_relative './constants/default'
+require_relative './constants/error'
+require_relative './constants/file'
+require_relative './constants/supported_transformation'
+require_relative './constants/url'
+require_relative './configurable'
+
+module ImageKitIo
+  module Constantable
+    def self.included(base)
+      def constants
+        ImageKitIo.constants
+      end
+    end
+  end
+  class Constant
+    include Constants::Default
+    include Constants::Error
+    include Constants::File
+    include Constants::SupportedTransformation
+    include Constants::URL
+
+    class << self
+      def method_missing(symbol, *args)
+        method_name = symbol.to_s.gsub('=', '')
+        if self.const_defined? method_name
+          return self.const_get(method_name) if args.empty?
+
+          self.const_set(method_name, args.first)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/imagekitio/constants/default.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Enum for defaults
+module ImageKitIo
+  module Constants
+    module Default
+      TRANSFORMATION_POSITION = "path"
+      QUERY_TRANSFORMATION_POSITION = "query"
+      VALID_TRANSFORMATION_POSITION = [TRANSFORMATION_POSITION,
+                                       QUERY_TRANSFORMATION_POSITION,].freeze
+      DEFAULT_TIMESTAMP = "9999999999"
+      TRANSFORMATION_PARAMETER = "tr"
+      CHAIN_TRANSFORM_DELIMITER = ":"
+      TRANSFORM_DELIMITER = ","
+      TRANSFORM_KEY_VALUE_DELIMITER = "-"
+
+      SIGNATURE_PARAMETER = "ik-s"
+      TIMESTAMP_PARAMETER = "ik-t"
+      TIMESTAMP = "9999999999"
+    end
+  end
+end

data/lib/imagekitio/constants/error.rb

@@ -0,0 +1,69 @@
+module ImageKitIo
+  module Constants
+    module Error
+      MANDATORY_INIT_MISSING = {
+        'message': "Missing public_key or private_key or url_endpoint during ImageKitIo initialization",
+        help: "",
+      }
+      INVALID_TRANSFORMATION_POS = {'message': "Invalid transformationPosition parameter",
+                                    help: "",}
+      INVALID_URL_GENERATION_PARAM = {'message': "Invalid url parameter", help: ""}
+      INVALID_TRANSFORMATION_OPTIONS = {
+        'message': "Invalid transformation parameter options",
+        help: "",
+      }
+      CACHE_PURGE_URL_MISSING = {'message': "Missing URL parameter for this request",
+                                 help: "",}
+      CACHE_PURGE_STATUS_ID_MISSING = {'message': "Missing Request ID parameter for this request",
+                                       help: "",}
+      FILE_ID_MISSING = {'message': "Missing File ID parameter for this request",
+                         help: "",}
+      UPDATE_DATA_MISSING = {'message': "Missing file update data for this request",
+                             help: "",}
+
+      UPDATE_DATA_TAGS_INVALID = {'message': "Invalid tags parameter for this request",
+                                  help: "tags should be passed as null or an array like ['tag1', 'tag2']",}.freeze
+
+      UPDATE_DATA_COORDS_INVALID =
+        {'message': "Invalid custom_coordinates parameter for this request",
+         help: "custom_coordinates should be passed as null or a string like 'x,y,width,height'",}
+
+      LIST_FILES_INPUT_MISSING = {
+        'message': "Missing options for list files",
+        help: "If you do not want to pass any parameter for listing, pass an empty object",
+      }
+      MISSING_FILE_URL = {'message': "Missing file_url for purge_cache", help: ""}
+      MISSING_UPLOAD_DATA = {'message': "Missing data for upload", help: ""}
+      MISSING_UPLOAD_FILE_PARAMETER = {
+        'message': "Missing file parameter for upload",
+        help: "",
+      }
+      MISSING_UPLOAD_FILENAME_PARAM = {
+        'message': "Missing fileName parameter for upload",
+        help: "",
+      }
+
+      INVALID_PHASH_VALUE =
+        {
+          'message': "Invalid pHash value",
+          help: "Both pHash strings must be valid hexadecimal numbers",
+        }
+
+      MISSING_PHASH_VALUE = {
+        'message': "Missing pHash value",
+        help: "Please pass two pHash values",
+      }
+      UNEQUAL_STRING_LENGTH = {
+        '': "Unequal pHash string length",
+        help: "For distance calculation, the two pHash strings must have equal length",
+      }
+
+      MISSING_PRIVATE_KEY = "ImageKitIo private key missing"
+
+      MISSING_PUBLIC_KEY = "ImageKitIo public key missing"
+
+      MISSING_URL_ENDPOINT = "ImageKitIo URL Endpoint missing. Default URL Endpoint: https://ik.imagekit.io/<YOUR_IMAGEKIT_ID>/"
+
+    end
+  end
+end

data/lib/imagekitio/constants/file.rb

@@ -0,0 +1,11 @@
+module ImageKitIo
+  module Constants
+    module File
+      VALID_FILE_OPTIONS = %w[path fileType tags includeFolder name limit skip]
+
+      VALID_FILE_DETAIL_OPTIONS = ["fileID"]
+
+      VALID_UPLOAD_OPTIONS = %w[file file_name use_unique_file_name tags folder is_private_file custom_coordinates response_fields extensions webhook_url overwrite_file overwrite_AI_tags overwrite_custom_metadata custom_metadata mime overwrite_tags content_type  ]
+    end
+  end
+end

data/lib/imagekitio/constants/supported_transformation.rb

@@ -0,0 +1,64 @@
+module ImageKitIo
+  module Constants
+    module SupportedTransformation
+      SUPPORTED_TRANS = {
+        'height': "h",
+        'width': "w",
+        'aspect_ratio': "ar",
+        'quality': "q",
+        'crop': "c",
+        'crop_mode': "cm",
+        'x': "x",
+        'y': "y",
+        'focus': "fo",
+        'format': "f",
+        'radius': "r",
+        'background': "bg",
+        'border': "b",
+        'rotation': "rt",
+        'blur': "bl",
+        'named': "n",
+        'overlay_image': "oi",
+        'overlay_image_trim': "oit",
+        'overlay_image_cropping': "oic",
+        'overlay_image_quality': "oiq",
+        'overlay_image_DPR': "oidpr",
+        'overlay_image_border': "oib",
+        'overlay_image_background': "oibg",
+        'overlay_image_aspect_ratio': "oiar",
+        'overlay_x': "ox",
+        'overlay_y': "oy",
+        'overlay_focus': "ofo",
+        'overlay_height': "oh",
+        'overlay_width': "ow",
+        'overlay_text': "ot",
+        'overlay_text_font_size': "ots",
+        'overlay_text_font_family': "otf",
+        'overlay_text_encoded': "ote",
+        'overlay_text_color': "otc",
+        'overlay_text_width': "otw",
+        'overlay_text_background': "otbg",
+        'overlay_text_padding': "otp",
+        'overlay_text_inner_alignment': "otia",
+        'overlay_text_transparency': "oa",
+        'overlay_alpha': "oa",
+        'overlay_radius': "or",
+        'overlay_text_typography': "ott",
+        'overlay_background': "obg",
+        'progressive': "pr",
+        'lossless': "lo",
+        'trim': "t",
+        'metadata': "md",
+        'color_profile': "cp",
+        'default_image': "di",
+        'dpr': "dpr",
+        'effect_sharpen': "e-sharpen",
+        'effect_usm': "e-usm",
+        'effect_contrast': "e-contrast",
+        'effect_gray': "e-grayscale",
+        'original': "orig",
+        'raw': 'raw',
+      }
+    end
+  end
+end