pobo-sdk 1.0.0

data/lib/pobo/dto/category.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Pobo
+  module DTO
+    class Category
+      attr_reader :id, :is_visible, :name, :url, :description, :seo_title,
+                  :seo_description, :content, :images, :guid, :is_loaded,
+                  :created_at, :updated_at
+
+      def initialize(
+        id:,
+        is_visible:,
+        name:,
+        url:,
+        description: nil,
+        seo_title: nil,
+        seo_description: nil,
+        content: nil,
+        images: [],
+        guid: nil,
+        is_loaded: nil,
+        created_at: nil,
+        updated_at: nil
+      )
+        @id = id
+        @is_visible = is_visible
+        @name = name
+        @url = url
+        @description = description
+        @seo_title = seo_title
+        @seo_description = seo_description
+        @content = content
+        @images = images
+        @guid = guid
+        @is_loaded = is_loaded
+        @created_at = created_at
+        @updated_at = updated_at
+      end
+
+      def self.from_hash(hash)
+        new(
+          id: hash["id"] || hash[:id],
+          is_visible: hash["is_visible"] || hash[:is_visible],
+          name: LocalizedString.from_hash(hash["name"] || hash[:name]),
+          url: LocalizedString.from_hash(hash["url"] || hash[:url]),
+          description: LocalizedString.from_hash(hash["description"] || hash[:description]),
+          seo_title: LocalizedString.from_hash(hash["seo_title"] || hash[:seo_title]),
+          seo_description: LocalizedString.from_hash(hash["seo_description"] || hash[:seo_description]),
+          content: Content.from_hash(hash["content"] || hash[:content]),
+          images: hash["images"] || hash[:images] || [],
+          guid: hash["guid"] || hash[:guid],
+          is_loaded: hash["is_loaded"] || hash[:is_loaded],
+          created_at: parse_time(hash["created_at"] || hash[:created_at]),
+          updated_at: parse_time(hash["updated_at"] || hash[:updated_at])
+        )
+      end
+
+      def to_hash
+        data = {
+          "id" => @id,
+          "is_visible" => @is_visible,
+          "name" => @name&.to_hash,
+          "url" => @url&.to_hash
+        }
+
+        data["description"] = @description.to_hash if @description
+        data["seo_title"] = @seo_title.to_hash if @seo_title
+        data["seo_description"] = @seo_description.to_hash if @seo_description
+        data["images"] = @images unless @images.empty?
+
+        data
+      end
+
+      alias to_h to_hash
+
+      private
+
+      def self.parse_time(value)
+        return nil if value.nil?
+        return value if value.is_a?(Time)
+
+        Time.parse(value)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/pobo/dto/content.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Pobo
+  module DTO
+    class Content
+      attr_reader :html, :marketplace
+
+      def initialize(html: {}, marketplace: {})
+        @html = html.transform_keys(&:to_s)
+        @marketplace = marketplace.transform_keys(&:to_s)
+      end
+
+      def self.from_hash(hash)
+        return nil if hash.nil?
+
+        new(
+          html: hash["html"] || hash[:html] || {},
+          marketplace: hash["marketplace"] || hash[:marketplace] || {}
+        )
+      end
+
+      def get_html(language)
+        @html[language.to_s]
+      end
+
+      def get_marketplace(language)
+        @marketplace[language.to_s]
+      end
+
+      def html_default
+        @html["default"]
+      end
+
+      def marketplace_default
+        @marketplace["default"]
+      end
+
+      def to_hash
+        {
+          "html" => @html,
+          "marketplace" => @marketplace
+        }
+      end
+
+      alias to_h to_hash
+    end
+  end
+end

data/lib/pobo/dto/import_result.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Pobo
+  module DTO
+    class ImportResult
+      attr_reader :success, :imported, :updated, :skipped, :errors,
+                  :values_imported, :values_updated
+
+      def initialize(
+        success:,
+        imported: 0,
+        updated: 0,
+        skipped: 0,
+        errors: [],
+        values_imported: nil,
+        values_updated: nil
+      )
+        @success = success
+        @imported = imported
+        @updated = updated
+        @skipped = skipped
+        @errors = errors
+        @values_imported = values_imported
+        @values_updated = values_updated
+      end
+
+      def self.from_hash(hash)
+        new(
+          success: hash["success"] || hash[:success] || true,
+          imported: hash["imported"] || hash[:imported] || 0,
+          updated: hash["updated"] || hash[:updated] || 0,
+          skipped: hash["skipped"] || hash[:skipped] || 0,
+          errors: hash["errors"] || hash[:errors] || [],
+          values_imported: hash["values_imported"] || hash[:values_imported],
+          values_updated: hash["values_updated"] || hash[:values_updated]
+        )
+      end
+
+      def errors?
+        !@errors.empty?
+      end
+
+      alias has_errors? errors?
+    end
+  end
+end

data/lib/pobo/dto/localized_string.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Pobo
+  module DTO
+    class LocalizedString
+      attr_reader :translations
+
+      def initialize(default_value = nil, translations: {})
+        @translations = translations.transform_keys(&:to_s)
+        @translations["default"] = default_value if default_value
+      end
+
+      def self.create(default_value)
+        new(default_value)
+      end
+
+      def self.from_hash(hash)
+        return nil if hash.nil?
+
+        instance = new
+        hash.each do |key, value|
+          instance.translations[key.to_s] = value
+        end
+        instance
+      end
+
+      def with_translation(language, value)
+        new_translations = @translations.dup
+        new_translations[language.to_s] = value
+        self.class.new(nil, translations: new_translations)
+      end
+
+      def default
+        @translations["default"]
+      end
+
+      def get(language)
+        @translations[language.to_s]
+      end
+
+      def to_hash
+        @translations.dup
+      end
+
+      alias to_h to_hash
+    end
+  end
+end

data/lib/pobo/dto/paginated_response.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Pobo
+  module DTO
+    class PaginatedResponse
+      attr_reader :data, :current_page, :per_page, :total
+
+      def initialize(data:, current_page:, per_page:, total:)
+        @data = data
+        @current_page = current_page
+        @per_page = per_page
+        @total = total
+      end
+
+      def self.from_hash(hash, item_class)
+        items = (hash["data"] || hash[:data] || []).map do |item|
+          item_class.from_hash(item)
+        end
+
+        meta = hash["meta"] || hash[:meta] || {}
+
+        new(
+          data: items,
+          current_page: meta["current_page"] || meta[:current_page] || 1,
+          per_page: meta["per_page"] || meta[:per_page] || 100,
+          total: meta["total"] || meta[:total] || 0
+        )
+      end
+
+      def total_pages
+        return 0 if @per_page.zero?
+
+        (@total.to_f / @per_page).ceil
+      end
+
+      def more_pages?
+        @current_page < total_pages
+      end
+
+      alias has_more_pages? more_pages?
+    end
+  end
+end

data/lib/pobo/dto/parameter.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Pobo
+  module DTO
+    class ParameterValue
+      attr_reader :id, :value
+
+      def initialize(id:, value:)
+        @id = id
+        @value = value
+      end
+
+      def self.from_hash(hash)
+        new(
+          id: hash["id"] || hash[:id],
+          value: hash["value"] || hash[:value]
+        )
+      end
+
+      def to_hash
+        {
+          "id" => @id,
+          "value" => @value
+        }
+      end
+
+      alias to_h to_hash
+    end
+
+    class Parameter
+      attr_reader :id, :name, :values
+
+      def initialize(id:, name:, values: [])
+        @id = id
+        @name = name
+        @values = values
+      end
+
+      def self.from_hash(hash)
+        values = (hash["values"] || hash[:values] || []).map do |v|
+          ParameterValue.from_hash(v)
+        end
+
+        new(
+          id: hash["id"] || hash[:id],
+          name: hash["name"] || hash[:name],
+          values: values
+        )
+      end
+
+      def to_hash
+        {
+          "id" => @id,
+          "name" => @name,
+          "values" => @values.map(&:to_hash)
+        }
+      end
+
+      alias to_h to_hash
+    end
+  end
+end

data/lib/pobo/dto/product.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Pobo
+  module DTO
+    class Product
+      attr_reader :id, :is_visible, :name, :url, :short_description, :description,
+                  :seo_title, :seo_description, :content, :images, :categories_ids,
+                  :parameters_ids, :guid, :is_loaded, :categories, :created_at, :updated_at
+
+      def initialize(
+        id:,
+        is_visible:,
+        name:,
+        url:,
+        short_description: nil,
+        description: nil,
+        seo_title: nil,
+        seo_description: nil,
+        content: nil,
+        images: [],
+        categories_ids: [],
+        parameters_ids: [],
+        guid: nil,
+        is_loaded: nil,
+        categories: [],
+        created_at: nil,
+        updated_at: nil
+      )
+        @id = id
+        @is_visible = is_visible
+        @name = name
+        @url = url
+        @short_description = short_description
+        @description = description
+        @seo_title = seo_title
+        @seo_description = seo_description
+        @content = content
+        @images = images
+        @categories_ids = categories_ids
+        @parameters_ids = parameters_ids
+        @guid = guid
+        @is_loaded = is_loaded
+        @categories = categories
+        @created_at = created_at
+        @updated_at = updated_at
+      end
+
+      def self.from_hash(hash)
+        new(
+          id: hash["id"] || hash[:id],
+          is_visible: hash["is_visible"] || hash[:is_visible],
+          name: LocalizedString.from_hash(hash["name"] || hash[:name]),
+          url: LocalizedString.from_hash(hash["url"] || hash[:url]),
+          short_description: LocalizedString.from_hash(hash["short_description"] || hash[:short_description]),
+          description: LocalizedString.from_hash(hash["description"] || hash[:description]),
+          seo_title: LocalizedString.from_hash(hash["seo_title"] || hash[:seo_title]),
+          seo_description: LocalizedString.from_hash(hash["seo_description"] || hash[:seo_description]),
+          content: Content.from_hash(hash["content"] || hash[:content]),
+          images: hash["images"] || hash[:images] || [],
+          categories_ids: hash["categories_ids"] || hash[:categories_ids] || [],
+          parameters_ids: hash["parameters_ids"] || hash[:parameters_ids] || [],
+          guid: hash["guid"] || hash[:guid],
+          is_loaded: hash["is_loaded"] || hash[:is_loaded],
+          categories: hash["categories"] || hash[:categories] || [],
+          created_at: parse_time(hash["created_at"] || hash[:created_at]),
+          updated_at: parse_time(hash["updated_at"] || hash[:updated_at])
+        )
+      end
+
+      def to_hash
+        data = {
+          "id" => @id,
+          "is_visible" => @is_visible,
+          "name" => @name&.to_hash,
+          "url" => @url&.to_hash
+        }
+
+        data["short_description"] = @short_description.to_hash if @short_description
+        data["description"] = @description.to_hash if @description
+        data["seo_title"] = @seo_title.to_hash if @seo_title
+        data["seo_description"] = @seo_description.to_hash if @seo_description
+        data["images"] = @images unless @images.empty?
+        data["categories_ids"] = @categories_ids unless @categories_ids.empty?
+        data["parameters_ids"] = @parameters_ids unless @parameters_ids.empty?
+
+        data
+      end
+
+      alias to_h to_hash
+
+      private
+
+      def self.parse_time(value)
+        return nil if value.nil?
+        return value if value.is_a?(Time)
+
+        Time.parse(value)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/pobo/dto/webhook_payload.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Pobo
+  module DTO
+    class WebhookPayload
+      attr_reader :event, :timestamp, :eshop_id
+
+      def initialize(event:, timestamp:, eshop_id:)
+        @event = event
+        @timestamp = timestamp
+        @eshop_id = eshop_id
+      end
+
+      def self.from_hash(hash)
+        timestamp = hash["timestamp"] || hash[:timestamp]
+        timestamp = Time.at(timestamp) if timestamp.is_a?(Integer)
+        timestamp = Time.parse(timestamp) if timestamp.is_a?(String)
+
+        new(
+          event: hash["event"] || hash[:event],
+          timestamp: timestamp,
+          eshop_id: hash["eshop_id"] || hash[:eshop_id]
+        )
+      end
+    end
+  end
+end

data/lib/pobo/enum/language.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pobo
+  module Language
+    DEFAULT = "default"
+    CS = "cs"
+    SK = "sk"
+    EN = "en"
+    DE = "de"
+    PL = "pl"
+    HU = "hu"
+
+    ALL = [DEFAULT, CS, SK, EN, DE, PL, HU].freeze
+
+    def self.valid?(code)
+      ALL.include?(code)
+    end
+  end
+end

data/lib/pobo/enum/webhook_event.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Pobo
+  module WebhookEvent
+    PRODUCTS_UPDATE = "products.update"
+    CATEGORIES_UPDATE = "categories.update"
+
+    ALL = [PRODUCTS_UPDATE, CATEGORIES_UPDATE].freeze
+
+    def self.valid?(event)
+      ALL.include?(event)
+    end
+  end
+end

data/lib/pobo/errors.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Pobo
+  class Error < StandardError; end
+
+  class ApiError < Error
+    attr_reader :http_code, :response_body
+
+    def initialize(message, http_code: nil, response_body: nil)
+      @http_code = http_code
+      @response_body = response_body
+      super(message)
+    end
+
+    def self.unauthorized
+      new("Authorization token required", http_code: 401)
+    end
+
+    def self.from_response(http_code, body)
+      message = body.is_a?(Hash) ? (body["error"] || body["message"] || "API error") : "API error"
+      new(message, http_code: http_code, response_body: body)
+    end
+  end
+
+  class ValidationError < Error
+    attr_reader :errors
+
+    def initialize(message, errors: {})
+      @errors = errors
+      super(message)
+    end
+
+    def self.empty_payload
+      new("Payload cannot be empty")
+    end
+
+    def self.too_many_items(count, max)
+      new("Too many items: #{count} provided, maximum is #{max}")
+    end
+  end
+
+  class WebhookError < Error
+    def self.missing_signature
+      new("Missing webhook signature")
+    end
+
+    def self.invalid_signature
+      new("Invalid webhook signature")
+    end
+
+    def self.invalid_payload
+      new("Invalid webhook payload")
+    end
+  end
+end

data/lib/pobo/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Pobo
+  VERSION = "1.0.0"
+end

data/lib/pobo/webhook_handler.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "json"
+
+module Pobo
+  class WebhookHandler
+    SIGNATURE_HEADER = "X-Webhook-Signature"
+
+    def initialize(webhook_secret:)
+      @webhook_secret = webhook_secret
+    end
+
+    # Handle webhook from Rack request
+    def handle_request(request)
+      payload = request.body.read
+      request.body.rewind if request.body.respond_to?(:rewind)
+
+      signature = request.env["HTTP_X_WEBHOOK_SIGNATURE"] ||
+                  request.get_header("HTTP_X_WEBHOOK_SIGNATURE") rescue nil
+
+      handle(payload: payload, signature: signature)
+    end
+
+    # Handle webhook with raw payload and signature
+    def handle(payload:, signature:)
+      raise WebhookError.missing_signature if signature.nil? || signature.empty?
+      raise WebhookError.invalid_signature unless valid_signature?(payload, signature)
+
+      data = JSON.parse(payload)
+      DTO::WebhookPayload.from_hash(data)
+    rescue JSON::ParserError
+      raise WebhookError.invalid_payload
+    end
+
+    private
+
+    def valid_signature?(payload, signature)
+      expected = OpenSSL::HMAC.hexdigest("SHA256", @webhook_secret, payload)
+      secure_compare(expected, signature)
+    end
+
+    def secure_compare(a, b)
+      return false unless a.bytesize == b.bytesize
+
+      OpenSSL.fixed_length_secure_compare(a, b)
+    rescue NoMethodError
+      # Fallback for older Ruby versions
+      a == b
+    end
+  end
+end

data/lib/pobo.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "pobo/version"
+require_relative "pobo/errors"
+
+require_relative "pobo/enum/language"
+require_relative "pobo/enum/webhook_event"
+
+require_relative "pobo/dto/localized_string"
+require_relative "pobo/dto/content"
+require_relative "pobo/dto/product"
+require_relative "pobo/dto/category"
+require_relative "pobo/dto/blog"
+require_relative "pobo/dto/parameter"
+require_relative "pobo/dto/import_result"
+require_relative "pobo/dto/paginated_response"
+require_relative "pobo/dto/webhook_payload"
+
+require_relative "pobo/client"
+require_relative "pobo/webhook_handler"
+
+module Pobo
+  class << self
+    # Convenience method to create a client
+    def client(api_token:, base_url: Client::DEFAULT_BASE_URL, timeout: Client::DEFAULT_TIMEOUT)
+      Client.new(api_token: api_token, base_url: base_url, timeout: timeout)
+    end
+
+    # Convenience method to create a webhook handler
+    def webhook_handler(webhook_secret:)
+      WebhookHandler.new(webhook_secret: webhook_secret)
+    end
+  end
+end

data/pobo.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "lib/pobo/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "pobo-sdk"
+  spec.version = Pobo::VERSION
+  spec.authors = ["Pobo"]
+  spec.email = ["tomas@pobo.cz"]
+
+  spec.summary = "Official Ruby SDK for Pobo API V2"
+  spec.description = "Ruby SDK for Pobo API V2 - product content management and webhooks"
+  spec.homepage = "https://github.com/pobo-builder/ruby-sdk"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/master/CHANGELOG.md"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
+    end
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "faraday", "~> 2.0"
+  spec.add_dependency "faraday-net_http", "~> 3.0"
+
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "webmock", "~> 3.0"
+  spec.add_development_dependency "rubocop", "~> 1.0"
+end