imagekitio 1.0.10 → 2.1.0

data/lib/active_storage/service/image_kit_io_service.rb

@@ -0,0 +1,188 @@
+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

@@ -0,0 +1,79 @@
+require 'carrierwave'
+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,17 +1,17 @@
-module CarrierWave
+module ImageKitIo
+  module CarrierWave
     module Storage
       class IKFile
         # Initialize as required.
-        
+
         def initialize(identifier)
           @identifier=JSON.parse(identifier)
-          ik_config=Rails.application.config.imagekit
-          @imagekit=ImageKit::ImageKitClient.new(ik_config[:private_key],ik_config[:public_key],ik_config[:url_endpoint])
+          @imagekit = ImageKitIo.client
         end
 
-        # Duck-type methods for CarrierWave::SanitizedFile. 
+        # Duck-type methods for CarrierWave::SanitizedFile.
         def content_type
-            "image/jpg"
+          "image/jpg"
         end
         def public_url
           @identifier['url']
@@ -33,7 +33,7 @@ module CarrierWave
         def delete
           # file_id=@identifier['fileId']
           begin
-            @imagekit.delete_file(fileId)
+            @imagekit.delete_file(file_id: fileId)
           rescue
             fileId
           end
@@ -47,4 +47,5 @@ module CarrierWave
 
     end
 
+  end
 end

data/lib/carrierwave/storage/imagekit_store.rb

@@ -1,65 +1,68 @@
 require 'uri'
 require 'net/http'
 require 'base64'
-module CarrierWave
+
+module ImageKitIo
+  module CarrierWave
     module Storage
-        class ImageKitStore < Abstract
+      class ImageKitStore < ::CarrierWave::Storage::Abstract
 
-          def initialize(*)
-              super
-              @cache_called = nil
-          end
-          
-          def store!(file)
-            file.delete
-          end
+        def initialize(*)
+          super
+          @cache_called = nil
+        end
 
-          def retrieve!(identifier)
-            
-            IKFile.new(identifier)
-          end
+        def store!(file)
+          file.delete
+        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!(identifier)
 
-          def retrieve_from_cache!(identifier)
-              CarrierWave::SanitizedFile.new(::File.expand_path(uploader.cache_path(identifier), uploader.root))
-          end
+          IKFile.new(identifier)
+        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
+        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
+        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
+end

data/lib/carrierwave/support/uri_filename.rb

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

data/lib/imagekitio/api_service/bulk.rb

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,52 @@
+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