licensechain_ruby_sdk 1.0.1

data/lib/licensechain/services/user_service.rb

@@ -0,0 +1,59 @@
+module LicenseChain
+  module Services
+    class UserService
+      def initialize(client)
+        @client = client
+      end
+
+      def create(email, name = nil, metadata = {})
+        validate_email(email)
+        
+        data = {
+          email: email,
+          name: name,
+          password: 'ChangeMe123!',
+          metadata: Utils.sanitize_metadata(metadata)
+        }
+
+        response = @client.post('/auth/register', data)
+        User.new(response[:user] || response[:data] || response)
+      end
+
+      def get(user_id)
+        Utils.validate_not_empty(user_id, 'user_id')
+        response = @client.get('/auth/me')
+        User.new(response[:data] || response)
+      end
+
+      def update(user_id, updates = {})
+        raise ValidationError, 'User update endpoint is not available in API v1'
+      end
+
+      def delete(user_id)
+        raise ValidationError, 'User delete endpoint is not available in API v1'
+      end
+
+      def list(page = 1, limit = 10)
+        page, limit = Utils.validate_pagination(page, limit)
+        {
+          data: [],
+          total: 0,
+          page: page,
+          limit: limit
+        }
+      end
+
+      def stats
+        UserStats.new({ total: 0, active: 0, inactive: 0 })
+      end
+
+      private
+
+      def validate_email(email)
+        Utils.validate_not_empty(email, 'email')
+        raise ValidationError, 'Invalid email format' unless Utils.validate_email(email)
+      end
+
+    end
+  end
+end

data/lib/licensechain/services/webhook_service.rb

@@ -0,0 +1,74 @@
+module LicenseChain
+  module Services
+    class WebhookService
+      def initialize(client)
+        @client = client
+      end
+
+      def create(url, events, secret = nil)
+        validate_webhook_params(url, events)
+        
+        data = {
+          url: url,
+          events: events,
+          secret: secret
+        }
+
+        response = @client.post('/webhooks', data)
+        Webhook.new(normalize_webhook_payload(response[:data] || response))
+      end
+
+      def get(webhook_id)
+        validate_uuid(webhook_id, 'webhook_id')
+        
+        response = @client.get("/webhooks/#{webhook_id}")
+        Webhook.new(normalize_webhook_payload(response[:data] || response))
+      end
+
+      def update(webhook_id, updates = {})
+        validate_uuid(webhook_id, 'webhook_id')
+        
+        response = @client.put("/webhooks/#{webhook_id}", Utils.sanitize_metadata(updates))
+        Webhook.new(normalize_webhook_payload(response[:data] || response))
+      end
+
+      def delete(webhook_id)
+        validate_uuid(webhook_id, 'webhook_id')
+        
+        @client.delete("/webhooks/#{webhook_id}")
+        true
+      end
+
+      def list
+        response = @client.get('/webhooks')
+        (response[:data] || []).map { |webhook| Webhook.new(normalize_webhook_payload(webhook)) }
+      end
+
+      private
+
+      def validate_webhook_params(url, events)
+        Utils.validate_not_empty(url, 'url')
+        raise ValidationError, 'Events must be an array' unless events.is_a?(Array)
+        raise ValidationError, 'Events cannot be empty' if events.empty?
+      end
+
+      def validate_uuid(id, field_name)
+        Utils.validate_not_empty(id, field_name)
+        raise ValidationError, "Invalid #{field_name} format" unless Utils.validate_uuid(id)
+      end
+
+      def normalize_webhook_payload(payload)
+        {
+          id: payload[:id],
+          app_id: payload[:app_id] || '',
+          url: payload[:url] || '',
+          events: payload[:events] || [],
+          secret: payload[:secret],
+          status: ((payload[:active].nil? || payload[:active]) ? 'active' : 'inactive'),
+          created_at: payload[:created_at] || payload[:createdAt],
+          updated_at: payload[:updated_at] || payload[:updatedAt]
+        }
+      end
+    end
+  end
+end

data/lib/licensechain/utils.rb

@@ -0,0 +1,211 @@
+module LicenseChain
+  module Utils
+    def self.validate_email(email)
+      email_regex = /\A[^\s@]+@[^\s@]+\.[^\s@]+\z/
+      email_regex.match?(email)
+    end
+
+    def self.validate_license_key(license_key)
+      return false if license_key.nil? || license_key.length != 32
+      license_key.match?(/\A[A-Z0-9]+\z/)
+    end
+
+    def self.validate_uuid(uuid)
+      uuid_regex = /\A[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\z/i
+      uuid_regex.match?(uuid)
+    end
+
+    def self.validate_amount(amount)
+      amount.is_a?(Numeric) && amount > 0 && amount.finite?
+    end
+
+    def self.validate_currency(currency)
+      valid_currencies = %w[USD EUR GBP CAD AUD JPY CHF CNY]
+      valid_currencies.include?(currency.upcase)
+    end
+
+    def self.validate_status(status, allowed_statuses)
+      allowed_statuses.include?(status)
+    end
+
+    def self.sanitize_input(input)
+      return input unless input.is_a?(String)
+      input.gsub(/[<>&"']/, {
+        '<' => '&lt;',
+        '>' => '&gt;',
+        '&' => '&amp;',
+        '"' => '&quot;',
+        "'" => '&#x27;'
+      })
+    end
+
+    def self.sanitize_metadata(metadata)
+      return metadata unless metadata.is_a?(Hash)
+      metadata.transform_values do |value|
+        if value.is_a?(String)
+          sanitize_input(value)
+        else
+          value
+        end
+      end
+    end
+
+    def self.generate_license_key
+      charset = ('A'..'Z').to_a + ('0'..'9').to_a
+      (0...32).map { charset.sample }.join
+    end
+
+    def self.generate_uuid
+      SecureRandom.uuid
+    end
+
+    def self.format_timestamp(timestamp)
+      Time.at(timestamp).utc.iso8601
+    end
+
+    def self.parse_timestamp(timestamp)
+      Time.parse(timestamp).to_i
+    rescue ArgumentError
+      raise ValidationError, "Invalid timestamp format: #{timestamp}"
+    end
+
+    def self.validate_pagination(page, limit)
+      page = [page || 1, 1].max
+      limit = [[limit || 10, 1].max, 100].min
+      [page, limit]
+    end
+
+    def self.validate_date_range(start_date, end_date)
+      start_time = parse_timestamp(start_date)
+      end_time = parse_timestamp(end_date)
+      
+      if start_time > end_time
+        raise ValidationError, "Start date must be before or equal to end date"
+      end
+    rescue ValidationError
+      raise
+    rescue => e
+      raise ValidationError, "Invalid date format: #{e.message}"
+    end
+
+    def self.create_webhook_signature(payload, secret)
+      require 'openssl'
+      digest = OpenSSL::Digest.new('sha256')
+      OpenSSL::HMAC.hexdigest(digest, secret, payload)
+    end
+
+    def self.verify_webhook_signature(payload, signature, secret)
+      expected_signature = create_webhook_signature(payload, secret)
+      require 'securerandom'
+      SecureRandom.secure_compare(signature, expected_signature)
+    end
+
+    def self.default_hwuid
+      require 'socket'
+      require 'rbconfig'
+      require 'digest'
+      raw = [
+        'licensechain',
+        'ruby',
+        Socket.gethostname,
+        RbConfig::CONFIG['host_os'],
+        RbConfig::CONFIG['host_cpu']
+      ].join('|')
+      Digest::SHA256.hexdigest(raw)
+    end
+
+    def self.retry_with_backoff(max_retries = 3, initial_delay = 1.0)
+      delay = initial_delay
+      
+      (0..max_retries).each do |attempt|
+        begin
+          return yield
+        rescue => e
+          if attempt == max_retries
+            raise e
+          end
+          
+          sleep(delay)
+          delay *= 2
+        end
+      end
+    end
+
+    def self.format_bytes(bytes)
+      units = %w[B KB MB GB TB PB]
+      threshold = 1024
+      
+      return "#{bytes} B" if bytes < threshold
+      
+      size = bytes.to_f
+      unit_index = 0
+      
+      while size >= threshold && unit_index < units.length - 1
+        size /= threshold
+        unit_index += 1
+      end
+      
+      "#{size.round(1)} #{units[unit_index]}"
+    end
+
+    def self.format_duration(seconds)
+      if seconds < 60
+        "#{seconds}s"
+      elsif seconds < 3600
+        minutes = seconds / 60
+        remaining_seconds = seconds % 60
+        "#{minutes}m #{remaining_seconds}s"
+      elsif seconds < 86400
+        hours = seconds / 3600
+        minutes = (seconds % 3600) / 60
+        "#{hours}h #{minutes}m"
+      else
+        days = seconds / 86400
+        hours = (seconds % 86400) / 3600
+        "#{days}d #{hours}h"
+      end
+    end
+
+    def self.capitalize_first(str)
+      return str if str.empty?
+      str[0].upcase + str[1..-1].downcase
+    end
+
+    def self.to_snake_case(str)
+      str.gsub(/([A-Z])/, '_\1').downcase.gsub(/^_/, '')
+    end
+
+    def self.to_pascal_case(str)
+      str.split('_').map(&:capitalize).join
+    end
+
+    def self.truncate_string(str, max_length)
+      return str if str.length <= max_length
+      "#{str[0...max_length - 3]}..."
+    end
+
+    def self.remove_special_chars(str)
+      str.gsub(/[^a-zA-Z0-9\s]/, '')
+    end
+
+    def self.slugify(str)
+      str.downcase
+          .gsub(/[^a-z0-9\s-]/, '')
+          .gsub(/\s+/, '-')
+          .gsub(/-+/, '-')
+          .gsub(/^-|-$/, '')
+    end
+
+    def self.validate_not_empty(str, field_name)
+      raise ValidationError, "#{field_name} cannot be empty" if str.nil? || str.strip.empty?
+    end
+
+    def self.validate_positive(number, field_name)
+      raise ValidationError, "#{field_name} must be positive" if number.nil? || number <= 0
+    end
+
+    def self.validate_range(number, min, max, field_name)
+      raise ValidationError, "#{field_name} must be between #{min} and #{max}" if number < min || number > max
+    end
+  end
+end

data/lib/licensechain/webhook_handler.rb

@@ -0,0 +1,157 @@
+require 'openssl'
+require 'json'
+require 'time'
+
+module LicenseChain
+  class WebhookHandler
+    attr_reader :secret, :tolerance
+
+    def initialize(secret, tolerance = 300)
+      @secret = secret
+      @tolerance = tolerance
+    end
+
+    def verify_signature(payload, signature)
+      Utils.verify_webhook_signature(payload, signature, @secret)
+    end
+
+    def verify_timestamp(timestamp)
+      webhook_time = Time.parse(timestamp)
+      current_time = Time.now
+      time_diff = (current_time - webhook_time).abs
+
+      if time_diff > @tolerance
+        raise ValidationError, "Webhook timestamp too old: #{time_diff} seconds"
+      end
+    rescue ArgumentError => e
+      raise ValidationError, "Invalid timestamp format: #{e.message}"
+    end
+
+    def verify_webhook(payload, signature, timestamp)
+      verify_timestamp(timestamp)
+      
+      unless verify_signature(payload, signature)
+        raise AuthenticationError, "Invalid webhook signature"
+      end
+    end
+
+    def process_event(event_data)
+      payload = event_data[:data].to_json
+      verify_webhook(payload, event_data[:signature], event_data[:timestamp])
+      
+      case event_data[:type]
+      when 'license.created'
+        handle_license_created(event_data)
+      when 'license.updated'
+        handle_license_updated(event_data)
+      when 'license.revoked'
+        handle_license_revoked(event_data)
+      when 'license.expired'
+        handle_license_expired(event_data)
+      when 'user.created'
+        handle_user_created(event_data)
+      when 'user.updated'
+        handle_user_updated(event_data)
+      when 'user.deleted'
+        handle_user_deleted(event_data)
+      when 'product.created'
+        handle_product_created(event_data)
+      when 'product.updated'
+        handle_product_updated(event_data)
+      when 'product.deleted'
+        handle_product_deleted(event_data)
+      when 'payment.completed'
+        handle_payment_completed(event_data)
+      when 'payment.failed'
+        handle_payment_failed(event_data)
+      when 'payment.refunded'
+        handle_payment_refunded(event_data)
+      else
+        puts "Unknown webhook event type: #{event_data[:type]}"
+      end
+    end
+
+    private
+
+    def handle_license_created(event_data)
+      puts "License created: #{event_data[:id]}"
+      # Add custom logic for license created event
+    end
+
+    def handle_license_updated(event_data)
+      puts "License updated: #{event_data[:id]}"
+      # Add custom logic for license updated event
+    end
+
+    def handle_license_revoked(event_data)
+      puts "License revoked: #{event_data[:id]}"
+      # Add custom logic for license revoked event
+    end
+
+    def handle_license_expired(event_data)
+      puts "License expired: #{event_data[:id]}"
+      # Add custom logic for license expired event
+    end
+
+    def handle_user_created(event_data)
+      puts "User created: #{event_data[:id]}"
+      # Add custom logic for user created event
+    end
+
+    def handle_user_updated(event_data)
+      puts "User updated: #{event_data[:id]}"
+      # Add custom logic for user updated event
+    end
+
+    def handle_user_deleted(event_data)
+      puts "User deleted: #{event_data[:id]}"
+      # Add custom logic for user deleted event
+    end
+
+    def handle_product_created(event_data)
+      puts "Product created: #{event_data[:id]}"
+      # Add custom logic for product created event
+    end
+
+    def handle_product_updated(event_data)
+      puts "Product updated: #{event_data[:id]}"
+      # Add custom logic for product updated event
+    end
+
+    def handle_product_deleted(event_data)
+      puts "Product deleted: #{event_data[:id]}"
+      # Add custom logic for product deleted event
+    end
+
+    def handle_payment_completed(event_data)
+      puts "Payment completed: #{event_data[:id]}"
+      # Add custom logic for payment completed event
+    end
+
+    def handle_payment_failed(event_data)
+      puts "Payment failed: #{event_data[:id]}"
+      # Add custom logic for payment failed event
+    end
+
+    def handle_payment_refunded(event_data)
+      puts "Payment refunded: #{event_data[:id]}"
+      # Add custom logic for payment refunded event
+    end
+  end
+
+  module WebhookEvents
+    LICENSE_CREATED = 'license.created'
+    LICENSE_UPDATED = 'license.updated'
+    LICENSE_REVOKED = 'license.revoked'
+    LICENSE_EXPIRED = 'license.expired'
+    USER_CREATED = 'user.created'
+    USER_UPDATED = 'user.updated'
+    USER_DELETED = 'user.deleted'
+    PRODUCT_CREATED = 'product.created'
+    PRODUCT_UPDATED = 'product.updated'
+    PRODUCT_DELETED = 'product.deleted'
+    PAYMENT_COMPLETED = 'payment.completed'
+    PAYMENT_FAILED = 'payment.failed'
+    PAYMENT_REFUNDED = 'payment.refunded'
+  end
+end

data/lib/licensechain/webhook_verifier.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "json"
+
+module LicenseChain
+  class WebhookVerifier
+    attr_reader :secret
+
+    def initialize(secret)
+      @secret = secret
+    end
+
+    # Verify webhook signature
+    def verify_signature(payload, signature, algorithm: "sha256")
+      expected_signature = generate_signature(payload, algorithm)
+      secure_compare(signature, expected_signature)
+    end
+
+    # Parse and verify webhook payload
+    def parse_payload(payload, signature, algorithm: "sha256")
+      raise ValidationError, "Invalid signature" unless verify_signature(payload, signature, algorithm: algorithm)
+      
+      JSON.parse(payload)
+    rescue JSON::ParserError => e
+      raise ValidationError, "Invalid JSON payload: #{e.message}"
+    end
+
+    # Generate signature for testing
+    def generate_signature(payload, algorithm = "sha256")
+      digest = case algorithm.downcase
+               when "sha1"
+                 OpenSSL::Digest::SHA1
+               when "sha256"
+                 OpenSSL::Digest::SHA256
+               when "sha512"
+                 OpenSSL::Digest::SHA512
+               else
+                 raise ArgumentError, "Unsupported algorithm: #{algorithm}"
+               end
+
+      signature = OpenSSL::HMAC.hexdigest(digest.new, @secret, payload)
+      "#{algorithm}=#{signature}"
+    end
+
+    # Verify webhook event type
+    def verify_event_type(payload, expected_type)
+      event_type = payload.dig("type") || payload.dig("event")
+      event_type == expected_type
+    end
+
+    # Extract event data
+    def extract_event_data(payload)
+      {
+        id: payload["id"],
+        type: payload["type"] || payload["event"],
+        created_at: payload["created_at"],
+        data: payload["data"] || payload["object"]
+      }
+    end
+
+    # Verify webhook timestamp (prevent replay attacks)
+    def verify_timestamp(payload, tolerance: 300) # 5 minutes
+      timestamp = payload["timestamp"] || payload["created_at"]
+      return true unless timestamp
+
+      event_time = Time.parse(timestamp)
+      current_time = Time.now
+      
+      (current_time - event_time).abs <= tolerance
+    rescue ArgumentError
+      false
+    end
+
+    private
+
+    def secure_compare(a, b)
+      return false if a.nil? || b.nil?
+      return false if a.length != b.length
+
+      result = 0
+      a.bytes.zip(b.bytes) { |x, y| result |= x ^ y }
+      result == 0
+    end
+  end
+
+  # Webhook event handler
+  class WebhookHandler
+    attr_reader :verifier
+
+    def initialize(secret)
+      @verifier = WebhookVerifier.new(secret)
+    end
+
+    def handle(payload, signature, algorithm: "sha256")
+      # Parse and verify the payload
+      data = @verifier.parse_payload(payload, signature, algorithm: algorithm)
+      
+      # Verify timestamp to prevent replay attacks
+      unless @verifier.verify_timestamp(data)
+        raise ValidationError, "Webhook timestamp is too old"
+      end
+
+      # Extract event information
+      event_data = @verifier.extract_event_data(data)
+      
+      # Route to appropriate handler
+      handle_event(event_data)
+    end
+
+    private
+
+    def handle_event(event_data)
+      case event_data[:type]
+      when "license.created"
+        handle_license_created(event_data)
+      when "license.updated"
+        handle_license_updated(event_data)
+      when "license.revoked"
+        handle_license_revoked(event_data)
+      when "license.expired"
+        handle_license_expired(event_data)
+      when "license.validated"
+        handle_license_validated(event_data)
+      when "app.created"
+        handle_app_created(event_data)
+      when "app.updated"
+        handle_app_updated(event_data)
+      when "app.deleted"
+        handle_app_deleted(event_data)
+      when "user.created"
+        handle_user_created(event_data)
+      when "user.updated"
+        handle_user_updated(event_data)
+      else
+        handle_unknown_event(event_data)
+      end
+    end
+
+    def handle_license_created(event_data)
+      # Override in subclass
+    end
+
+    def handle_license_updated(event_data)
+      # Override in subclass
+    end
+
+    def handle_license_revoked(event_data)
+      # Override in subclass
+    end
+
+    def handle_license_expired(event_data)
+      # Override in subclass
+    end
+
+    def handle_license_validated(event_data)
+      # Override in subclass
+    end
+
+    def handle_app_created(event_data)
+      # Override in subclass
+    end
+
+    def handle_app_updated(event_data)
+      # Override in subclass
+    end
+
+    def handle_app_deleted(event_data)
+      # Override in subclass
+    end
+
+    def handle_user_created(event_data)
+      # Override in subclass
+    end
+
+    def handle_user_updated(event_data)
+      # Override in subclass
+    end
+
+    def handle_unknown_event(event_data)
+      # Override in subclass
+    end
+  end
+end

data/lib/licensechain_ruby_sdk/version.rb

@@ -0,0 +1,3 @@
+module LicenseChainRubySdk
+  VERSION = '1.0.0'
+end