resourcespace-ruby 0.1.0

data/lib/resourcespace/collection.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module ResourceSpace
+  # Collection management interface for ResourceSpace API
+  #
+  # @example
+  #   collections = client.collections
+  #
+  #   # Get user collections
+  #   user_collections = collections.get_user_collections
+  #
+  #   # Create a new collection
+  #   collection = collections.create_collection("My Web Assets")
+  #
+  #   # Add resources to collection
+  #   collections.add_resource_to_collection(123, collection_id)
+  class Collection
+    # @return [Client] the ResourceSpace client
+    attr_reader :client
+
+    # Initialize the collection interface
+    #
+    # @param client [Client] ResourceSpace client instance
+    def initialize(client)
+      @client = client
+    end
+
+    # Get user collections
+    #
+    # @param user [String] username (optional, defaults to current user)
+    # @return [Array] user collections
+    def get_user_collections(user = nil)
+      params = {}
+      params[:param1] = user if user
+
+      client.get("get_user_collections", params)
+    end
+
+    # Create a new collection
+    #
+    # @param name [String] collection name
+    # @param public [Boolean] whether collection is public
+    # @param allow_changes [Boolean] whether to allow changes to collection
+    # @return [Hash] created collection data
+    def create_collection(name, public: false, allow_changes: true)
+      params = {
+        param1: name,
+        param2: public ? "1" : "0"
+      }
+      params[:param3] = allow_changes ? "1" : "0"
+
+      client.post("create_collection", params)
+    end
+
+    # Delete a collection
+    #
+    # @param collection_id [Integer] collection ID
+    # @return [Hash] response
+    def delete_collection(collection_id)
+      client.post("delete_collection", { param1: collection_id.to_s })
+    end
+
+    # Get collection details
+    #
+    # @param collection_id [Integer] collection ID
+    # @return [Hash] collection details
+    def get_collection(collection_id)
+      client.get("get_collection", { param1: collection_id.to_s })
+    end
+
+    # Save collection (update collection details)
+    #
+    # @param collection_id [Integer] collection ID
+    # @param name [String] new collection name
+    # @param public [Boolean] whether collection is public
+    # @param allow_changes [Boolean] whether to allow changes
+    # @return [Hash] response
+    def save_collection(collection_id, name: nil, public: nil, allow_changes: nil)
+      params = { param1: collection_id.to_s }
+      params[:param2] = name if name
+      params[:param3] = public ? "1" : "0" unless public.nil?
+      params[:param4] = allow_changes ? "1" : "0" unless allow_changes.nil?
+
+      client.post("save_collection", params)
+    end
+
+    # Add a resource to a collection
+    #
+    # @param resource_id [Integer] resource ID
+    # @param collection_id [Integer] collection ID
+    # @return [Hash] response
+    def add_resource_to_collection(resource_id, collection_id)
+      client.post("add_resource_to_collection", {
+        param1: resource_id.to_s,
+        param2: collection_id.to_s
+      })
+    end
+
+    # Remove a resource from a collection
+    #
+    # @param resource_id [Integer] resource ID
+    # @param collection_id [Integer] collection ID
+    # @return [Hash] response
+    def remove_resource_from_collection(resource_id, collection_id)
+      client.post("remove_resource_from_collection", {
+        param1: resource_id.to_s,
+        param2: collection_id.to_s
+      })
+    end
+
+    # Show or hide a collection
+    #
+    # @param collection_id [Integer] collection ID
+    # @param show [Boolean] true to show, false to hide
+    # @return [Hash] response
+    def show_hide_collection(collection_id, show: true)
+      client.post("show_hide_collection", {
+        param1: collection_id.to_s,
+        param2: show ? "1" : "0"
+      })
+    end
+
+    # Send collection to admin
+    #
+    # @param collection_id [Integer] collection ID
+    # @param message [String] message to admin
+    # @return [Hash] response
+    def send_collection_to_admin(collection_id, message = "")
+      client.post("send_collection_to_admin", {
+        param1: collection_id.to_s,
+        param2: message
+      })
+    end
+
+    # Search public collections
+    #
+    # @param search_term [String] search term
+    # @return [Array] matching public collections
+    def search_public_collections(search_term)
+      client.get("search_public_collections", { param1: search_term })
+    end
+
+    # Get featured collections
+    #
+    # @return [Array] featured collections
+    def get_featured_collections
+      client.get("get_featured_collections")
+    end
+
+    # Delete all resources in a collection
+    #
+    # @param collection_id [Integer] collection ID
+    # @return [Hash] response
+    def delete_resources_in_collection(collection_id)
+      client.post("delete_resources_in_collection", { param1: collection_id.to_s })
+    end
+
+    # Add multiple resources to a collection
+    #
+    # @param resource_ids [Array<Integer>] array of resource IDs
+    # @param collection_id [Integer] collection ID
+    # @return [Array] array of responses
+    def add_resources_to_collection(resource_ids, collection_id)
+      Array(resource_ids).map do |resource_id|
+        add_resource_to_collection(resource_id, collection_id)
+      end
+    end
+
+    # Remove multiple resources from a collection
+    #
+    # @param resource_ids [Array<Integer>] array of resource IDs
+    # @param collection_id [Integer] collection ID
+    # @return [Array] array of responses
+    def remove_resources_from_collection(resource_ids, collection_id)
+      Array(resource_ids).map do |resource_id|
+        remove_resource_from_collection(resource_id, collection_id)
+      end
+    end
+
+    # Create a collection for web assets
+    #
+    # @param name [String] collection name
+    # @param asset_type [String] type of web assets ("images", "css", "js", "fonts", "icons")
+    # @param public [Boolean] whether collection is public
+    # @return [Hash] created collection data
+    def create_web_asset_collection(name, asset_type: nil, public: false)
+      collection_name = asset_type ? "#{name} - #{asset_type.capitalize}" : name
+      create_collection(collection_name, public: public)
+    end
+
+    # Get collections containing web assets
+    #
+    # @param asset_type [String] type of web assets to filter by
+    # @return [Array] collections with web assets
+    def get_web_asset_collections(asset_type: nil)
+      collections = get_user_collections
+
+      # Filter collections that likely contain web assets based on name
+      web_asset_keywords = %w[web asset css js javascript image icon font stylesheet]
+
+      if asset_type
+        web_asset_keywords << asset_type.downcase
+      end
+
+      collections.select do |collection|
+        name = collection["name"]&.downcase || ""
+        web_asset_keywords.any? { |keyword| name.include?(keyword) }
+      end
+    end
+  end
+end

data/lib/resourcespace/configuration.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module ResourceSpace
+  # Configuration class for ResourceSpace client
+  #
+  # @example
+  #   config = ResourceSpace::Configuration.new
+  #   config.url = "https://your-resourcespace.com/api/"
+  #   config.user = "your_username"
+  #   config.private_key = "your_private_key"
+  class Configuration
+    # @return [String] the ResourceSpace API URL (must end with /api/)
+    attr_accessor :url
+
+    # @return [String] the ResourceSpace username
+    attr_accessor :user
+
+    # @return [String] the private API key for the user
+    attr_accessor :private_key
+
+    # @return [Integer] request timeout in seconds (default: 30)
+    attr_accessor :timeout
+
+    # @return [Integer] number of retry attempts for failed requests (default: 3)
+    attr_accessor :retries
+
+    # @return [String] user agent string for requests
+    attr_accessor :user_agent
+
+    # @return [Boolean] whether to verify SSL certificates (default: true)
+    attr_accessor :verify_ssl
+
+    # @return [String] authentication mode ('userkey', 'sessionkey', or 'native')
+    attr_accessor :auth_mode
+
+    # @return [Hash] default headers to include with all requests
+    attr_accessor :default_headers
+
+    # @return [Boolean] whether to log API requests and responses (default: false)
+    attr_accessor :debug
+
+    # @return [Logger] logger instance for debugging
+    attr_accessor :logger
+
+    # Initialize a new configuration with default values
+    def initialize
+      @url = nil
+      @user = nil
+      @private_key = nil
+      @timeout = 30
+      @retries = 3
+      @user_agent = "ResourceSpace Ruby Client #{ResourceSpace::VERSION}"
+      @verify_ssl = true
+      @auth_mode = "userkey"
+      @default_headers = {}
+      @debug = false
+      @logger = nil
+    end
+
+    # Validate the configuration
+    #
+    # @raise [ConfigurationError] if configuration is invalid
+    # @return [Boolean] true if configuration is valid
+    def validate!
+      errors = []
+
+      errors << "URL is required" if url.nil? || url.empty?
+      errors << "URL must end with /api/" if url && !url.end_with?("/api/")
+      errors << "User is required" if user.nil? || user.empty?
+      errors << "Private key is required" if private_key.nil? || private_key.empty?
+      errors << "Timeout must be positive" if timeout && timeout <= 0
+      errors << "Retries must be non-negative" if retries && retries < 0
+      errors << "Auth mode must be userkey, sessionkey, or native" unless %w[userkey sessionkey native].include?(auth_mode)
+
+      raise ConfigurationError, "Configuration errors: #{errors.join(', ')}" unless errors.empty?
+
+      true
+    end
+
+    # Check if configuration is valid without raising an error
+    #
+    # @return [Boolean] true if configuration is valid
+    def valid?
+      validate!
+      true
+    rescue ConfigurationError
+      false
+    end
+
+    # Convert configuration to a hash
+    #
+    # @return [Hash] configuration as a hash
+    def to_h
+      {
+        url: url,
+        user: user,
+        private_key: private_key ? "[REDACTED]" : nil,
+        timeout: timeout,
+        retries: retries,
+        user_agent: user_agent,
+        verify_ssl: verify_ssl,
+        auth_mode: auth_mode,
+        default_headers: default_headers,
+        debug: debug
+      }
+    end
+
+    # Create a duplicate of this configuration
+    #
+    # @return [Configuration] a new configuration with the same values
+    def dup
+      new_config = Configuration.new
+      new_config.url = url
+      new_config.user = user
+      new_config.private_key = private_key
+      new_config.timeout = timeout
+      new_config.retries = retries
+      new_config.user_agent = user_agent
+      new_config.verify_ssl = verify_ssl
+      new_config.auth_mode = auth_mode
+      new_config.default_headers = default_headers.dup
+      new_config.debug = debug
+      new_config.logger = logger
+      new_config
+    end
+  end
+end

data/lib/resourcespace/errors.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module ResourceSpace
+  # Base error class for all ResourceSpace errors
+  class Error < StandardError
+    # @return [Hash, nil] additional error data
+    attr_reader :data
+
+    # @return [Integer, nil] HTTP status code if applicable
+    attr_reader :status_code
+
+    # @return [String, nil] response body if applicable
+    attr_reader :response_body
+
+    # Initialize a new error
+    #
+    # @param message [String] error message
+    # @param data [Hash] additional error data
+    # @param status_code [Integer] HTTP status code
+    # @param response_body [String] HTTP response body
+    def initialize(message = nil, data: nil, status_code: nil, response_body: nil)
+      @data = data
+      @status_code = status_code
+      @response_body = response_body
+      super(message)
+    end
+
+    # Convert error to a hash representation
+    #
+    # @return [Hash] error as a hash
+    def to_h
+      {
+        error: self.class.name,
+        message: message,
+        status_code: status_code,
+        data: data
+      }.compact
+    end
+  end
+
+  # Configuration validation error
+  class ConfigurationError < Error; end
+
+  # Authentication error
+  class AuthenticationError < Error; end
+
+  # Authorization error (user doesn't have permission)
+  class AuthorizationError < Error; end
+
+  # Resource not found error
+  class NotFoundError < Error; end
+
+  # Validation error (invalid parameters)
+  class ValidationError < Error; end
+
+  # Rate limiting error
+  class RateLimitError < Error; end
+
+  # Server error (5xx responses)
+  class ServerError < Error; end
+
+  # Network/connection error
+  class NetworkError < Error; end
+
+  # Request timeout error
+  class TimeoutError < Error; end
+
+  # File upload error
+  class UploadError < Error; end
+
+  # API response parsing error
+  class ParseError < Error; end
+
+  # Resource already exists error
+  class ConflictError < Error; end
+
+  # API quota exceeded error
+  class QuotaExceededError < Error; end
+
+  # Generic client error (4xx responses)
+  class ClientError < Error; end
+
+  # Method to create appropriate error based on HTTP status code
+  #
+  # @param status_code [Integer] HTTP status code
+  # @param message [String] error message
+  # @param response_body [String] HTTP response body
+  # @return [Error] appropriate error instance
+  def self.from_response(status_code, message = nil, response_body = nil)
+    case status_code
+    when 400
+      ValidationError.new(message, status_code: status_code, response_body: response_body)
+    when 401
+      AuthenticationError.new(message, status_code: status_code, response_body: response_body)
+    when 403
+      AuthorizationError.new(message, status_code: status_code, response_body: response_body)
+    when 404
+      NotFoundError.new(message, status_code: status_code, response_body: response_body)
+    when 409
+      ConflictError.new(message, status_code: status_code, response_body: response_body)
+    when 429
+      RateLimitError.new(message, status_code: status_code, response_body: response_body)
+    when 400..499
+      ClientError.new(message, status_code: status_code, response_body: response_body)
+    when 500..599
+      ServerError.new(message, status_code: status_code, response_body: response_body)
+    else
+      Error.new(message, status_code: status_code, response_body: response_body)
+    end
+  end
+end