chore: file operation added

Author: mrasif

lib/imagekit/file.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative "constants/errors"
+require_relative "constants/file"
+require_relative "constants/url"
+
+require_relative "utils/formatter"
+
+class ImageKitFile
+  # This File class holds file related operations like
+  # upload, list etc
+  def initialize(req_obj)
+    @req_obj = req_obj
+  end
+
+  def upload(file, file_name, options)
+    # uploads files with required arguments
+    # supports bot url and binary
+    raise ArgumentError, MISSING_UPLOAD_FILE_PARAMETER unless file
+    raise ArgumentError, MISSING_UPLOAD_FILE_PARAMETER unless file_name
+    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, fileName: file_name}.merge(options)
+
+      url = "#{URL::BASE_URL}#{URL::UPLOAD}"
+      @req_obj.request("post", url, headers, payload)
+    end
+  end
+
+  def update_details(file_id, options)
+    # Update file detail by file_id and options
+
+    unless (options.key? :tags) || (options.key? :custom_coordinates)
+      raise ArgumentError, UPDATE_DATA_MISSING
+    end
+    unless options.fetch(:tags, []).is_a?(Array)
+      raise ArgumentError, UPDATE_DATA_TAGS_INVALID
+    end
+    unless options.fetch(:custom_coordinates, "").is_a?(String)
+      raise ArgumentError, UPDATE_DATA_COORDS_INVALID
+    end
+    url = "#{URL::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 ImageKit Server
+    #  :options dictionary of options
+    formatted_options = request_formatter(options)
+    raise KeyError(LIST_FILES_INPUT_MISSING) unless formatted_options.is_a?(Hash)
+    url = URL::BASE_URL
+    headers = @req_obj.create_headers.update({params: options})
+    @req_obj.request("get", url, headers, options)
+  end
+
+  def details(file_identifier)
+    # Get detail of file by file_identifier
+    url = "#{URL::BASE_URL}/#{file_identifier}/details/"
+    headers = @req_obj.create_headers
+    @req_obj.request("get", url, headers)
+  end
+
+  def get_metadata(file_id)
+    # Get metadata of a file by file_id
+    url = "#{URL::BASE_URL}/#{file_id}/metadata"
+    @req_obj.request("get", url, @req_obj.create_headers)
+  end
+
+  def delete(file_id)
+    # Delete a file_id by file_id
+    url = "#{URL::BASE_URL}/#{file_id}"
+    headers = @req_obj.create_headers
+    @req_obj.request("delete", url, headers)
+  end
+
+  def batch_delete(file_ids)
+    url = "#{URL::BASE_URL}#{URL::BULK_FILE_DELETE}"
+    payload = {'fileIds': file_ids}
+    @req_obj.request("post", url, @req_obj.create_headers, payload.to_json)
+  end
+
+  def purge_cache(file_url)
+
+    # purges cache from server by file_url
+
+    url = "#{URL::BASE_URL}/purge"
+    payload = {'url': file_url}
+    @req_obj.request("post", url, @req_obj.create_headers, payload)
+  end
+
+  def purge_cache_status(request_id)
+    # This function is to get cache_status
+    url = "#{URL::BASE_URL}/purge/#{request_id}"
+    @req_obj.request("get", url, @req_obj.create_headers)
+  end
+
+  def get_metadata_from_remote_url(remote_file_url)
+    if remote_file_url == ""
+      raise ArgumentError, "remote_file_url is required"
+    end
+    url = "#{URL::REMOTE_METADATA_FULL_URL}?url=#{remote_file_url}"
+    @req_obj.request("get", url, @req_obj.create_headers)
+  end
+
+  def validate_upload_options(options)
+
+    #  Validates upload value, checks if params are valid,
+    #  changes snake to camel case which is supported by
+    #  ImageKit server
+
+
+    response_list = []
+    options.each do |key, val|
+      if 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

lib/imagekit/resource.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "base64"
+require "rest-client"
+require "json"
+require_relative "constants/defaults"
+
+# ImageKitRequest requests and sends data from server
+class ImageKitRequest
+  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 || Default::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 = nil, payload = nil)
+    headers ||= create_headers
+    response = {response: nil, error: nil}
+    begin
+      resp = RestClient::Request.new(method: method,
+                                     url: url,
+                                     headers: headers,
+                                     payload: payload).execute
+
+
+      if resp.code == 404
+        raise RestClient::ExceptionWithResponse
+      elsif (resp.code >= 200) && (resp.code < 204)
+        response[:response] = JSON.parse(resp.body.to_s)
+      elsif resp.code == 204
+        response[:response] = {'success': true}
+      end
+
+    rescue RestClient::ExceptionWithResponse => err
+      err.http_code == 404 ? response[:error] = {'message': err.response.to_s} : JSON.parse(err.response)
+    end
+    response
+  end
+end

lib/imagekit/sdk.rb

@@ -0,0 +1,71 @@
+require "imagekit/sdk/railtie"
+
+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.rb'
+require_relative "./resource"
+require_relative "./file"
+require_relative "./url"
+require_relative "./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
+        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
+    end
+
+  end
+
+end