imagekitio 3.0.0 → 4.0.0

data/lib/active_storage/active_storage.rb

@@ -1,7 +0,0 @@
-begin
-    require 'active_storage'
-  rescue LoadError
-    puts "Add gem 'activestorage' to use this service"
-  end
-  require_relative './service/ik_file'
-  require_relative './service/image_kit_io_service'

data/lib/active_storage/service/ik_file.rb

@@ -1,115 +0,0 @@
-module ImageKiIo
-  module ActiveStorage
-    class IKFile
-      attr_accessor :identifier
-
-      def initialize(identifier)
-        @identifier = identifier
-        @imagekit = ImageKitIo.client
-      end
-
-      def url
-        identifier['url']
-      end
-
-      def delete
-        begin
-          @imagekit.delete_file(file_id: file_id)
-        rescue
-          file_id
-        end
-      end
-
-      def file_type
-        identifier['fileType']
-      end
-
-      def thumbnail_url
-        identifier['thumbnail']
-      end
-
-      def filename
-        identifier['name']
-      end
-
-      def size
-        identifier['size']
-      end
-
-      def path
-        identifier['filePath']
-      end
-
-      def height
-        identifier['height']
-      end
-
-      def width
-        identifier['width']
-      end
-
-      def file_id
-        identifier['fileId']
-      end
-
-      def exist?
-        details = @imagekit.get_file_details(file_id: file_id)
-        return false if details[:error].present?
-
-        true
-      end
-
-      def type
-        identifier['type']
-      end
-
-      def tags
-        identifier['tags']
-      end
-
-      def ai_tags
-        identifier['AITags']
-      end
-
-      def is_private?
-        identifier['isPrivateFile']
-      end
-
-      def custom_coordinates
-        identifier['customCoordinates']
-      end
-
-      def mime
-        identifier['mime']
-      end
-
-      def alpha?
-        identifier['hasAlpha']
-      end
-
-      def custom_metadata
-        identifier['customMetadata']
-      end
-
-      def embedded_metadata
-        identifier['embeddedMetadata']
-      end
-
-      def created_at
-        identifier['createdAt']
-      end
-
-      def updated_at
-        identifier['updatedAt']
-      end
-
-      def extension_status
-        identifier['extensionStatus']
-      end
-
-      def transformation
-        identifier['transformation']
-      end
-    end
-  end
-end

data/lib/active_storage/service/image_kit_io_service.rb

@@ -1,188 +0,0 @@
-require_relative './ik_file'
-
-if defined? Rails
-  # Overwrite the ActiveStorage::Downloader's open method and remove the file integrity check constraint method verify_integrity_of
-  class DownloaderExtension < ::ActiveStorage::Downloader
-    def open(key, checksum:, name: "ActiveStorage-", tmpdir: nil, **options)
-      open_tempfile(name, tmpdir) do |file|
-        download key, file
-        # verify_integrity_of file, checksum: checksum
-        yield file
-      end
-    end
-  end
-
-  module ActiveStorageBlobExtension
-    def self.included(base)
-      base.class_eval do
-        before_update :check_metadata
-        before_destroy :remove_imagekit_file
-        # ActiveRecord::Blob class first destroy the record data and then calls the service.delete method with key
-        # as an argument. But the imagekit.io needs fileId to destroy the file which can be get from the metadata.
-        # So first destroy the remote file and then destroy the local blob record.
-        def remove_imagekit_file
-          service.class.delete_ik_file(self)
-        end
-
-        def remote_file_exist?
-          service.exist?(self.key)
-        end
-
-        def remote_file
-          return false unless remote_file_exist?
-
-          service.class.remote_file(self)
-        end
-
-        # Needs to reload the record to reflect updated remote meta data.
-        def check_metadata
-          self.reload
-        end
-      end
-    end
-  end
-
-  Rails.application.config.to_prepare do
-    ActiveStorage::Blob.send :include, ::ActiveStorageBlobExtension
-  end
-
-  module ActiveStorage
-    class Service::ImageKitIoService < Service
-      include ImageKitIo::Constantable
-
-      class << self
-        def delete_ik_file(blob)
-          ik_file(blob).delete
-        end
-
-        def remote_file(blob)
-          ik_file(blob)
-        end
-
-        def ik_file(blob)
-          self.new.send(:ik_file).new(blob.metadata)
-        end
-      end
-
-      def initialize(**options)
-        @options = options
-      end
-
-      def upload(key, io, checksum: nil, **options)
-        instrument :upload, key: key, checksum: checksum do
-          blob = storage_blob(key)
-          response = client.upload_file(file: io, file_name: blob.filename.to_s, content_type: blob.content_type)
-          if response[:error].nil?
-            blob.update_columns(metadata: response[:response].transform_keys(&:to_sym))
-          else
-            raise Exception.new response[:error]
-          end
-        end
-      end
-
-      def download(key, &block)
-        if block_given?
-          instrument :stream_file, key: key do
-            stream_file(key, &block)
-          end
-        else
-          instrument :download, key: key do
-            image_kit_file(key)
-          end
-        end
-      end
-
-      def download_chunk(key, range)
-        puts 'Not implemented download_chunk'
-      end
-
-      def delete(key)
-        instrument :delete, key: key do
-          # image kit file is already deleted on before blob destroy callback
-          key
-        end
-      end
-
-      def delete_prefixed(prefix)
-        # delete the variants files
-        puts 'Not implemented delete_prefixed'
-      end
-
-      def exist?(key)
-        image_kit_file(key).exist?
-      end
-
-      def url_for_direct_upload(key, **options)
-        instrument :url, key: key do |payload|
-          options.delete(:content_length)
-          options.delete(:checksum)
-          url = "#{constants.BASE_URL}#{constants.UPLOAD}"
-          generated_url = client.url(src: url)
-          payload[:url] = generated_url
-          generated_url
-        end
-      end
-
-      def headers_for_direct_upload(key, content_type:, checksum:, **options)
-        {
-          'Content-Type' => content_type
-        }
-      end
-
-      def path_for(key)
-        image_kit_file(key).path
-      end
-
-      def url(key, filename: nil, content_type: '', **options)
-        generate_url(key, filename: filename, content_type: content_type, path: image_kit_file(key).path, **options)
-      end
-
-      def open(*args, **options, &block)
-        DownloaderExtension.new(self).open(*args, **options, &block)
-      end
-
-      private
-
-      def private_url(key, expires_in:, filename:, disposition:, content_type:, **options)
-        generate_url(key, expires_in: expires_in, filename: filename, disposition: disposition, content_type: content_type, path: image_kit_file(key).path, **options)
-      end
-
-      def generate_url(key, expires_in:, filename:, content_type:, disposition:, **options)
-        # filename = filename.to_s if filename.is_a? ActiveStorage::Filename
-        # options[:filename] = filename if filename
-        client.url(url_endpoint: config.url_endpoint, **options)
-      end
-
-      def client
-        ImageKitIo.client
-      end
-
-      def config
-        ImageKitIo.config
-      end
-
-      def storage_blob(key)
-        ActiveStorage::Blob.find_by_key(key)
-      end
-
-      def image_kit_file(key)
-        blob = storage_blob(key)
-        ik_file.new(blob.metadata)
-      end
-
-      def ik_file
-        ImageKiIo::ActiveStorage::IKFile
-      end
-
-      def stream_file(key, &download_block)
-        file_obj = image_kit_file(key)
-        block = proc { |response|
-          response.read_body do |chunk|
-            download_block.call(chunk) if download_block.present?
-          end
-        }
-        client.stream_file(file_url: file_obj.url, &block)
-      end
-    end
-  end
-end

data/lib/carrierwave/carrierwave.rb

@@ -1,83 +0,0 @@
-begin
-  require 'carrierwave'
-rescue LoadError
-  puts "Add gem 'carrierwave' to use this service"
-end
-require_relative './storage/imagekit_store'
-require_relative './storage/ik_file'
-require_relative './support/uri_filename'
-
-module ImageKitIo
-  module CarrierWave
-    def self.included(base)
-      base.include InstanceMethods
-      base.class_eval do
-        configure do |config|
-          config.storage_engines[:imagekit_store] = 'ImageKitIo::CarrierWave::Storage::ImageKitStore'
-        end
-      end
-      base.storage :imagekit_store
-    end
-
-    module InstanceMethods
-      def initialize(*)
-        @imagekit = ImageKitIo.client
-        @options = {}
-      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
-          resp = @imagekit.upload_file(file: open(self.file.file, 'rb'), file_name: 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

data/lib/carrierwave/storage/ik_file.rb

@@ -1,51 +0,0 @@
-module ImageKitIo
-  module CarrierWave
-    module Storage
-      class IKFile
-        # Initialize as required.
-
-        def initialize(identifier)
-          @identifier=JSON.parse(identifier)
-          @imagekit = ImageKitIo.client
-        end
-
-        # Duck-type methods for CarrierWave::SanitizedFile.
-        def content_type
-          "image/jpg"
-        end
-        def public_url
-          @identifier['url']
-        end
-        def url(options = {})
-          @identifier['url']
-        end
-
-        def fileId
-          @identifier['fileId']
-        end
-        def filename(options = {})
-          @identifier['name']
-        end
-        def read
-        end
-        def size
-        end
-        def delete
-          # file_id=@identifier['fileId']
-          begin
-            @imagekit.delete_file(file_id: fileId)
-          rescue
-            fileId
-          end
-          # binding.pry
-          # return nil
-        end
-        def exists?
-        end
-        # Others... ?
-      end
-
-    end
-
-  end
-end

data/lib/carrierwave/storage/imagekit_store.rb

@@ -1,68 +0,0 @@
-require 'uri'
-require 'net/http'
-require 'base64'
-
-module ImageKitIo
-  module CarrierWave
-    module Storage
-      class ImageKitStore < ::CarrierWave::Storage::Abstract
-
-        def initialize(*)
-          super
-          @cache_called = nil
-        end
-
-        def store!(file)
-          file.delete
-        end
-
-        def retrieve!(identifier)
-
-          IKFile.new(identifier)
-        end
-
-        def cache!(new_file)
-          new_file.move_to(::File.expand_path(uploader.cache_path, uploader.root), uploader.permissions, uploader.directory_permissions, true)
-        rescue Errno::EMLINK, Errno::ENOSPC => e
-          raise(e) if @cache_called
-          @cache_called = true
-
-          # NOTE: Remove cached files older than 10 minutes
-          clean_cache!(600)
-
-          cache!(new_file)
-        end
-
-        def retrieve_from_cache!(identifier)
-          CarrierWave::SanitizedFile.new(::File.expand_path(uploader.cache_path(identifier), uploader.root))
-        end
-
-        def delete_dir!(path)
-          if path
-            begin
-              Dir.rmdir(::File.expand_path(path, uploader.root))
-            rescue Errno::ENOENT
-              # Ignore: path does not exist
-            rescue Errno::ENOTDIR
-              # Ignore: path is not a dir
-            rescue Errno::ENOTEMPTY, Errno::EEXIST
-              # Ignore: dir is not empty
-            end
-          end
-        end
-
-        def clean_cache!(seconds)
-          Dir.glob(::File.expand_path(::File.join(uploader.cache_dir, '*'), CarrierWave.root)).each do |dir|
-            # generate_cache_id returns key formated TIMEINT-PID(-COUNTER)-RND
-            time = dir.scan(/(\d+)-\d+-\d+(?:-\d+)?/).first.map(&:to_i)
-            time = Time.at(*time)
-            if time < (Time.now.utc - seconds)
-              FileUtils.rm_rf(dir)
-            end
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/carrierwave/support/uri_filename.rb

@@ -1,12 +0,0 @@
-module ImageKitIo
-  module CarrierWave
-    module Support
-      module UriFilename
-        def self.filename(url)
-          path = url.split('?').first
-          URI.decode(path).gsub(%r{.*/(.*?$)}, '\1')
-        end
-      end
-    end
-  end
-end

data/lib/imagekitio/api_service/bulk.rb

@@ -1,58 +0,0 @@
-require_relative '../constant'
-
-module ImageKitIo
-  module ApiService
-    class Bulk
-      include Constantable
-
-      def initialize(req_obj)
-        @req_obj = req_obj
-      end
-
-      def job_status(job_id: nil)
-        if job_id == '' || job_id.nil?
-          raise ArgumentError, 'job_id is required'
-        end
-        url = "#{constants.BULK_BASE_URL}/#{job_id}"
-        payload = { 'jobId': job_id }
-        @req_obj.request('get', url, @req_obj.create_headers, payload)
-      end
-
-      def add_tags(file_ids: [], tags: [])
-        if file_ids.empty? || tags.empty?
-          raise ArgumentError, 'Parameters are required'
-        end
-        url = "#{constants.BASE_URL}/addTags"
-        payload = { 'fileIds': file_ids, 'tags': tags }.to_json
-        @req_obj.request('post', url, @req_obj.create_headers, payload)
-      end
-
-      def remove_tags(file_ids: [], tags: [])
-        if file_ids.empty? || tags.empty?
-          raise ArgumentError, 'Parameters are required'
-        end
-        url = "#{constants.BASE_URL}/removeTags"
-        payload = { 'fileIds': file_ids, 'tags': tags }.to_json
-        @req_obj.request('post', url, @req_obj.create_headers, payload)
-      end
-
-      def remove_ai_tags(file_ids: [], ai_tags: [])
-        if file_ids.empty? || ai_tags.empty?
-          raise ArgumentError, 'Parameters are required'
-        end
-        url = "#{constants.BASE_URL}/removeAITags"
-        payload = { 'fileIds': file_ids, 'AITags': ai_tags }.to_json
-        @req_obj.request('post', url, @req_obj.create_headers, payload)
-      end
-
-      def remove_files(file_ids: [])
-        if file_ids.empty?
-          raise ArgumentError, 'File ids are required'
-        end
-        url = "#{constants.BASE_URL}#{constants.BULK_FILE_DELETE}"
-        payload = {'fileIds': file_ids}.to_json
-        @req_obj.request("post", url, @req_obj.create_headers, payload)
-      end
-    end
-  end
-end

data/lib/imagekitio/api_service/custom_metadata_field.rb

@@ -1,52 +0,0 @@
-require_relative '../utils/option_validator'
-require_relative '../constant'
-
-module ImageKitIo
-  module ApiService
-    class CustomMetadataField
-      include Utils::OptionValidator
-      include Constantable
-
-      def initialize(req_obj)
-        @req_obj = req_obj
-      end
-
-      def create(name: nil, label: nil, schema: nil)
-        if name == '' || name.nil? || label == '' || label.nil? || schema == '' || schema.nil?
-          raise ArgumentError, 'Parameters required'
-        end
-        unless schema.is_a?(Hash)
-          raise ArgumentError, 'Schema must be hash object'
-        end
-        url = "#{constants.API_BASE_URL}/customMetadataFields"
-        payload = { 'name': name, 'label': label, 'schema': schema }.to_json
-        @req_obj.request('post', url, @req_obj.create_headers, payload)
-      end
-
-      def list(**options)
-        url = "#{constants.API_BASE_URL}/customMetadataFields"
-        payload = request_formatter(options || {})
-        @req_obj.request('get', url, @req_obj.create_headers, payload)
-      end
-
-      def update(id: nil, label: nil, schema: nil)
-        if id == '' || id.nil?
-          raise ArgumentError, 'id is required'
-        end
-        url = "#{constants.API_BASE_URL}/customMetadataFields/#{id}"
-        payload = {}
-        payload = payload.merge({ 'label': label }) unless label.nil?
-        payload = payload.merge({ 'schema': label }) unless schema.nil?
-        @req_obj.request('patch', url, @req_obj.create_headers, payload.to_json)
-      end
-
-      def delete(id: nil)
-        if id == '' || id.nil?
-          raise ArgumentError, 'id is required'
-        end
-        url = "#{constants.API_BASE_URL}/customMetadataFields/#{id}"
-        @req_obj.request('delete', url, @req_obj.create_headers)
-      end
-    end
-  end
-end