spree_packeta 0.1.0

data/lib/spree_packeta/models/shipping_method.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module SpreePacketa
+  module Models
+    class ShippingMethod < Spree::ShippingMethod
+      def carrier
+        'Packeta'
+      end
+
+      # Check if this shipping method is available for the given package
+      #
+      # @param package [Spree::Stock::Package] The package to check
+      # @return [Boolean] True if available
+      def available?(package, _display_on = nil)
+        super && packeta_available_for_package?(package)
+      end
+
+      # Build tracking URL for a shipment
+      #
+      # @param tracking_number [String] The Packeta packet ID
+      # @return [String] Tracking URL
+      def build_tracking_url(tracking_number)
+        "https://tracking.packeta.com/#{tracking_number}"
+      end
+
+      private
+
+      def packeta_available_for_package?(package)
+        # Check if package destination is supported
+        return false unless package_destination_supported?(package)
+
+        # Check if package weight is acceptable
+        return false unless package_weight_acceptable?(package)
+
+        true
+      end
+
+      def package_destination_supported?(package)
+        # Get the destination country
+        country_code = package.order.ship_address&.country&.iso
+
+        # For now, support Czech Republic and EU countries
+        # This can be expanded based on Packeta's coverage
+        supported_countries = %w[CZ SK PL HU RO AT DE]
+        supported_countries.include?(country_code)
+      end
+
+      def package_weight_acceptable?(package)
+        # Calculate total weight
+        total_weight = package.contents.sum { |item| item.variant.weight.to_f * item.quantity }
+
+        # Packeta typically has a maximum weight limit (e.g., 30kg)
+        # Adjust this based on your needs
+        max_weight = 30.0 # kg
+        total_weight <= max_weight
+      end
+    end
+  end
+end

data/lib/spree_packeta/services/packet_creator.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module SpreePacketa
+  module Services
+    class PacketCreator
+      attr_reader :shipment, :operations
+
+      def initialize(shipment, operations = nil)
+        @shipment = shipment
+        @operations = operations || Soap::Operations.new
+      end
+
+      # Create a Packeta packet from a Spree shipment
+      #
+      # @return [Hash] Packet details with :id, :barcode, :barcode_text
+      # @raise [ValidationError] If packet attributes are invalid
+      def create_packet
+        raise ValidationError, 'Shipment already has a Packeta packet' if shipment.packeta_packet_id.present?
+
+        # Extract attributes from shipment
+        attributes = build_packet_attributes
+
+        # Validate attributes first
+        operations.packet_attributes_valid?(attributes)
+
+        # Create the packet
+        result = operations.create_packet(attributes)
+
+        # Update shipment with packet details
+        update_shipment_with_packet(result)
+
+        result
+      rescue ValidationError => e
+        Rails.logger.error("Failed to create Packeta packet for shipment #{shipment.id}: #{e.message}")
+        raise
+      end
+
+      private
+
+      def build_packet_attributes
+        order = shipment.order
+        address = order.ship_address
+
+        {
+          number: order.number,
+          name: address.firstname,
+          surname: address.lastname,
+          company: address.company,
+          email: order.email,
+          phone: address.phone,
+          address_id: packeta_pickup_point_id,
+          value: order.item_total.to_f,
+          weight: calculate_weight,
+          cod: calculate_cod,
+          currency: order.currency,
+          eshop: SpreePacketa.configuration.eshop
+        }
+      end
+
+      def packeta_pickup_point_id
+        # Get pickup point from order metadata (set by frontend widget)
+        order.packeta_pickup_point_id ||
+          raise(ValidationError, 'No Packeta pickup point selected')
+      end
+
+      def calculate_weight
+        # Calculate total weight in kg
+        shipment.line_items.sum do |line_item|
+          (line_item.variant.weight || 0) * line_item.quantity
+        end
+      end
+
+      def calculate_cod
+        # Cash on delivery amount
+        # Only if payment method is COD
+        payment_method = shipment.order.payments.last&.payment_method
+        if payment_method&.type == 'Spree::PaymentMethod::COD'
+          shipment.order.total.to_f
+        else
+          0
+        end
+      end
+
+      def update_shipment_with_packet(packet_details)
+        shipment.update!(
+          packeta_packet_id: packet_details[:id],
+          packeta_barcode: packet_details[:barcode],
+          packeta_tracking_url: build_tracking_url(packet_details[:id]),
+          tracking: packet_details[:id].to_s
+        )
+      end
+
+      def build_tracking_url(packet_id)
+        "https://tracking.packeta.com/#{packet_id}"
+      end
+    end
+  end
+end

data/lib/spree_packeta/services/tracker.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module SpreePacketa
+  module Services
+    class Tracker
+      attr_reader :shipment, :operations
+
+      def initialize(shipment, operations = nil)
+        @shipment = shipment
+        @operations = operations || Soap::Operations.new
+      end
+
+      # Get current status of the packet
+      #
+      # @return [Hash] Current status details
+      # @raise [NotFoundError] If packet ID is not found
+      def current_status
+        ensure_packet_exists!
+
+        status = operations.packet_status(shipment.packeta_packet_id)
+        update_shipment_status(status)
+        status
+      end
+
+      # Get full tracking history
+      #
+      # @return [Array<Hash>] Array of tracking records
+      # @raise [NotFoundError] If packet ID is not found
+      def tracking_history
+        ensure_packet_exists!
+
+        operations.packet_tracking(shipment.packeta_packet_id)
+      end
+
+      # Sync status from Packeta and update shipment
+      #
+      # @return [Hash] Current status
+      def sync_status!
+        status = current_status
+
+        # Update last sync timestamp
+        shipment.update!(packeta_last_sync_at: Time.current)
+
+        # Update Spree shipment state based on Packeta status
+        update_spree_shipment_state(status)
+
+        status
+      end
+
+      # Check if shipment needs status sync
+      #
+      # @return [Boolean]
+      def needs_sync?
+        return true if shipment.packeta_last_sync_at.nil?
+
+        sync_interval = SpreePacketa.configuration.tracking_sync_interval
+        shipment.packeta_last_sync_at < sync_interval.seconds.ago
+      end
+
+      private
+
+      def ensure_packet_exists!
+        unless shipment.packeta_packet_id
+          raise NotFoundError, "Shipment #{shipment.id} does not have a Packeta packet"
+        end
+      end
+
+      def update_shipment_status(status)
+        shipment.update!(
+          packeta_status_code: status[:status_code],
+          packeta_branch_id: status[:branch_id],
+          packeta_last_sync_at: Time.current
+        )
+      end
+
+      def update_spree_shipment_state(status)
+        # Map Packeta status codes to Spree shipment states
+        # This is a simplified mapping - adjust based on your needs
+        case status[:status_code]
+        when 1, 2 # Packet created, In preparation
+          shipment.update!(state: 'pending') unless shipment.shipped?
+        when 3, 4 # Sent to carrier, In transit
+          shipment.ship! unless shipment.shipped?
+        when 5 # Delivered
+          shipment.ship! unless shipment.shipped?
+        when 6 # Returned
+          # Handle returns - could create a return authorization
+          Rails.logger.info("Packet #{shipment.packeta_packet_id} was returned")
+        end
+      rescue => e
+        Rails.logger.error("Failed to update shipment state: #{e.message}")
+        # Don't fail the sync if state transition fails
+      end
+    end
+  end
+end

data/lib/spree_packeta/soap/client.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'savon'
+
+module SpreePacketa
+  module Soap
+    class Client
+      MAX_RETRIES = 3
+      RETRY_DELAY = 1 # second
+
+      attr_reader :client
+
+      def initialize
+        @client = build_client
+      end
+
+      # Call a SOAP operation with automatic error handling and retries
+      #
+      # @param operation [Symbol] The SOAP operation name
+      # @param message [Hash] The SOAP message body
+      # @return [Savon::Response] The SOAP response
+      # @raise [SpreePacketa::AuthenticationError] If API password is incorrect
+      # @raise [SpreePacketa::ValidationError] If packet attributes are invalid
+      # @raise [SpreePacketa::NotFoundError] If packet ID is not found
+      # @raise [SpreePacketa::NetworkError] If network error occurs
+      def call(operation, message = {})
+        retries = 0
+
+        begin
+          # Always include API password in the message
+          message_with_auth = message.merge(api_password: api_password)
+
+          response = client.call(operation, message: message_with_auth)
+          handle_response(response)
+        rescue Savon::SOAPFault => e
+          handle_soap_fault(e)
+        rescue Savon::HTTPError, Savon::InvalidResponseError => e
+          retries += 1
+          if retries <= MAX_RETRIES
+            sleep(RETRY_DELAY * retries)
+            retry
+          else
+            raise NetworkError, "Network error after #{MAX_RETRIES} retries: #{e.message}"
+          end
+        rescue StandardError => e
+          raise ApiError, "Unexpected error: #{e.message}"
+        end
+      end
+
+      private
+
+      def build_client
+        Savon.client(
+          wsdl: wsdl_path,
+          endpoint: soap_endpoint,
+          namespace: 'http://www.zasilkovna.cz/api/soap.wsdl',
+          namespace_identifier: :tns,
+          env_namespace: :soap,
+          convert_request_keys_to: :none,
+          pretty_print_xml: Rails.env.development?,
+          log: Rails.env.development?,
+          log_level: :debug,
+          logger: Rails.logger,
+          open_timeout: 10,
+          read_timeout: 30,
+          raise_errors: true
+        )
+      end
+
+      def handle_response(response)
+        # Log the response in development
+        Rails.logger.debug("Packeta SOAP Response: #{response.body}") if Rails.env.development?
+        response
+      end
+
+      def handle_soap_fault(fault)
+        fault_code = fault.to_hash.dig(:fault, :faultcode)
+        fault_string = fault.to_hash.dig(:fault, :faultstring)
+
+        case fault_code
+        when /IncorrectApiPasswordFault/
+          raise AuthenticationError, "Incorrect API password: #{fault_string}"
+        when /PacketAttributesFault/
+          raise ValidationError, "Invalid packet attributes: #{fault_string}"
+        when /PacketIdFault/
+          raise NotFoundError, "Packet not found: #{fault_string}"
+        when /CancelNotAllowedFault/
+          raise ValidationError, "Cancel not allowed: #{fault_string}"
+        when /TooLateToUpdateCodFault/
+          raise ValidationError, "Too late to update COD: #{fault_string}"
+        when /ArgumentsFault/
+          raise ValidationError, "Invalid arguments: #{fault_string}"
+        else
+          raise ApiError, "SOAP fault: #{fault_code} - #{fault_string}"
+        end
+      end
+
+      def api_password
+        SpreePacketa.configuration.api_password || raise(AuthenticationError, 'API password not configured')
+      end
+
+      def soap_endpoint
+        SpreePacketa.configuration.soap_endpoint
+      end
+
+      def wsdl_path
+        # Prefer configured path, then bundled local file, finally remote URL
+        SpreePacketa.configuration.wsdl_path.presence || local_wsdl_path || 'https://www.zasilkovna.cz/api/soap.wsdl'
+      end
+
+      def local_wsdl_path
+        path = File.expand_path('packeta.wsdl', __dir__)
+        File.exist?(path) ? path : nil
+      end
+    end
+  end
+end

data/lib/spree_packeta/soap/operations.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module SpreePacketa
+  module Soap
+    class Operations
+      attr_reader :client
+
+      def initialize(client = nil)
+        @client = client || Client.new
+      end
+
+      # Validate packet attributes before creating a packet
+      #
+      # @param attributes [Hash] Packet attributes
+      # @return [Boolean] True if valid
+      # @raise [ValidationError] If attributes are invalid
+      def packet_attributes_valid?(attributes)
+        response = client.call(:packet_attributes_valid, attributes: packet_attributes_hash(attributes))
+        true
+      rescue ValidationError => e
+        Rails.logger.error("Packet attributes validation failed: #{e.message}")
+        raise
+      end
+
+      # Create a new packet
+      #
+      # @param attributes [Hash] Packet attributes
+      # @option attributes [String] :number Order number
+      # @option attributes [String] :name Customer first name
+      # @option attributes [String] :surname Customer last name
+      # @option attributes [String] :email Customer email
+      # @option attributes [String] :phone Customer phone
+      # @option attributes [Integer] :address_id Packeta pickup point ID
+      # @option attributes [BigDecimal] :value Package value
+      # @option attributes [BigDecimal] :weight Package weight in kg
+      # @option attributes [BigDecimal] :cod Cash on delivery amount (optional)
+      # @option attributes [String] :currency Currency code (CZK, EUR, etc.)
+      # @return [Hash] Created packet details with :id, :barcode, :barcode_text
+      def create_packet(attributes)
+        response = client.call(:create_packet, attributes: packet_attributes_hash(attributes))
+
+        result = response.body[:create_packet_response][:create_packet_result]
+
+        {
+          id: result[:id],
+          barcode: result[:barcode],
+          barcode_text: result[:barcode_text]
+        }
+      end
+
+      # Get current status of a packet
+      #
+      # @param packet_id [Integer] Packeta packet ID
+      # @return [Hash] Current status with :date_time, :status_code, :code_text, :status_text, :branch_id
+      def packet_status(packet_id)
+        response = client.call(:packet_status, packet_id: packet_id)
+
+        result = response.body[:packet_status_response][:packet_status_result]
+
+        {
+          date_time: result[:date_time],
+          status_code: result[:status_code],
+          code_text: result[:code_text],
+          status_text: result[:status_text],
+          branch_id: result[:branch_id],
+          destination_branch_id: result[:destination_branch_id],
+          is_returning: result[:is_returning],
+          stored_until: result[:stored_until]
+        }
+      end
+
+      # Get full tracking history for a packet
+      #
+      # @param packet_id [Integer] Packeta packet ID
+      # @return [Array<Hash>] Array of tracking records
+      def packet_tracking(packet_id)
+        response = client.call(:packet_tracking, packet_id: packet_id)
+
+        records = response.body[:packet_tracking_response][:packet_tracking_result][:record]
+        records = [records] unless records.is_a?(Array) # Handle single record
+
+        records.map do |record|
+          {
+            date_time: record[:date_time],
+            status_code: record[:status_code],
+            code_text: record[:code_text],
+            status_text: record[:status_text],
+            branch_id: record[:branch_id],
+            destination_branch_id: record[:destination_branch_id]
+          }
+        end
+      end
+
+      # Cancel a packet (if allowed)
+      #
+      # @param packet_id [Integer] Packeta packet ID
+      # @return [Boolean] True if cancelled successfully
+      def cancel_packet(packet_id)
+        client.call(:cancel_packet, packet_id: packet_id)
+        true
+      end
+
+      # Get packet label as PDF
+      #
+      # @param packet_id [Integer] Packeta packet ID
+      # @param format [String] Label format ('A7 on A4', 'A6 on A4', etc.)
+      # @param offset [Integer] Offset for positioning on page (0-3)
+      # @return [String] Base64 encoded PDF
+      def packet_label_pdf(packet_id, format: 'A7 on A4', offset: 0)
+        response = client.call(
+          :packet_label_pdf,
+          packet_id: packet_id,
+          format: format,
+          offset: offset
+        )
+
+        response.body[:packet_label_pdf_response][:packet_label_pdf_result]
+      end
+
+      private
+
+      # Convert Spree-friendly attributes to Packeta SOAP format
+      def packet_attributes_hash(attributes)
+        {
+          number: attributes[:number],
+          name: attributes[:name],
+          surname: attributes[:surname],
+          email: attributes[:email],
+          phone: attributes[:phone],
+          address_id: attributes[:address_id],
+          cod: attributes[:cod] || 0,
+          currency: attributes[:currency] || 'CZK',
+          value: attributes[:value],
+          weight: attributes[:weight],
+          eshop: attributes[:eshop] || SpreePacketa.configuration.eshop
+        }.compact
+      end
+    end
+  end
+end