belpost 0.9.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9573611d63a9e36e61ada02613b8e8764fb2a45125a17f5938f2521b0a80586d
-  data.tar.gz: 1db61fe84045560aac6dc7e362aeb5698413851d23851c1b2601f84ca1ff6bc3
+  metadata.gz: 43a87cdb950f04f9508bd0facb45918b68d17fc2442f6dd6ef9a0698e350950d
+  data.tar.gz: 24fe3c8cbde4d7ddc4e5cd5d21f03a6f9001c5820fdad7fcea0dcb06013c5909
 SHA512:
-  metadata.gz: 4ee356c1da9fad9db8b62a6d5bbe135c317b4c49cd818e856f8a81e70c8452dc98deeb03ffc59dd4d108efac8434c4ed1e9ce0ba5dcca41b23485f327255a26c
-  data.tar.gz: 40826b94cf8e911fc7930c5dae67412f4688ccc68f43bed53d5d5317d3146c848fd0f95111e24706cca2a5907b76d54fadf3d53c93eaa6a91aef8dc11f7190f9
+  metadata.gz: 8a90de8d13d830d5eb68b0fbbfa9374495f699cd66932b4c2d6e422348a494e6f9f4b46d30b3e8444f50e7d73fc28175cc1fe78036927b878a14c95108131dd1
+  data.tar.gz: c9bedc78bd654b6624ee3f20b7e292e78c4a0de11ed957763c367d7eadcd3ca719a65f4f2a805b2b1a8951d9afac621a05f97a5864cfc805d2161193d00f5e31

data/CHANGELOG.md

@@ -1,7 +1,31 @@
-# Changelog
+## [0.11.0] - 2025-04-23
+### Added
+- Added support for finding addresses by postal code via `find_addresses_by_postcode` method
+- Added new validation schema for postal codes
+- Added comprehensive tests for the new endpoint
 
-## [0.9.0] - 2025-04-15
+## [0.9.3] - 2025-04-18
+### Added
+- A new `list_batches` method in the Client class that:
+  - Supports pagination with the page parameter
+  - Allows filtering by batch status (committed or uncommitted)
+  - Enables limiting results per page with the per_page parameter
+  - Provides search functionality by batch number
+
+## [0.9.2] - 2025-04-17
+### Added
+- Added support for ecommerce-specific parameters:
+  - `negotiated_rate`
+  - `is_declared_value`
+  - `is_partial_receipt`
+  - `postal_items_in_ops`
+
+## [0.9.1] - 2025-04-16
+### Added
+- New `PostalDeliveryTypes` module for centralized management of postal delivery types
+- Tests for the `PostalDeliveryTypes` module
 
+## [0.9.0] - 2025-04-15
 ### Changed
 - Refactored API paths into a separate module `Belpost::ApiPaths` for better maintainability
 - Moved all hardcoded API endpoints into constants in `api_paths.rb`

data/README.md

@@ -308,6 +308,14 @@ postcodes = client.search_postcode(
 puts postcodes
 ```
 
+### Finding addresses by postal code
+
+```ruby
+client = Belpost::Client.new
+addresses = client.find_addresses_by_postcode("210001")
+puts addresses
+```
+
 ### Finding a batch by ID
 
 ```ruby
@@ -316,6 +324,38 @@ batch = client.find_batch_by_id(123)
 puts batch
 ```
 
+### Listing and searching for batches
+
+```ruby
+client = Belpost::Client.new
+
+# Get all batches with default pagination
+batches = client.list_batches
+puts "Total batches: #{batches["total"]}"
+
+# Get a specific page of results
+batches = client.list_batches(page: 2)
+
+# Filter by status (committed or uncommitted)
+committed_batches = client.list_batches(status: "committed")
+uncommitted_batches = client.list_batches(status: "uncommitted")
+
+# Set the number of batches per page
+batches = client.list_batches(per_page: 50)
+
+# Search for a specific batch by number
+batch_number = 12345
+search_results = client.list_batches(search: batch_number)
+
+# Combine multiple parameters
+filtered_batches = client.list_batches(
+  page: 2,
+  status: "committed",
+  per_page: 25,
+  search: 12345
+)
+```
+
 ## Error handling
 
 The client may throw the following exceptions:

data/belpost.gemspec

@@ -33,6 +33,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "dotenv"
-  spec.add_dependency "dry-validation", "~> 1.0"
   spec.add_dependency "dry-schema", "~> 1.0"
+  spec.add_dependency "dry-validation", "~> 1.0"
 end

data/lib/belpost/api_paths.rb

@@ -11,6 +11,7 @@ module Belpost
     BATCH_MAILING_DUPLICATE_FULL = "/api/v1/business/batch-mailing/list/:id/duplicate-full"
     BATCH_MAILING_COMMIT = "/api/v1/business/batch-mailing/list/:id/commit"
     BATCH_MAILING_GENERATE_BLANK = "/api/v1/business/batch-mailing/list/:id/generate-blank"
+    BATCH_MAILING_LIST_ITEM = "/api/v1/business/batch-mailing/list/:id/item"
 
     # Postal deliveries paths
     POSTAL_DELIVERIES = "/api/v1/business/postal-deliveries"
@@ -21,5 +22,6 @@ module Belpost
     # Geo directory paths
     GEO_DIRECTORY_SEARCH_ADDRESS = "/api/v1/business/geo-directory/search-address"
     GEO_DIRECTORY_POSTCODE = "/api/v1/business/geo-directory/postcode"
+    GEO_DIRECTORY_ADDRESSES = "/api/v1/business/geo-directory/addresses"
   end
-end 
+end

data/lib/belpost/client.rb

@@ -3,9 +3,12 @@
 require_relative "api_service"
 require_relative "models/parcel"
 require_relative "models/batch"
+require_relative "models/batch_item"
 require_relative "models/api_response"
 require_relative "validations/address_schema"
 require_relative "validations/batch_schema"
+require_relative "validations/batch_item_schema"
+require_relative "validations/postcode_schema"
 require_relative "api_paths"
 
 module Belpost
@@ -34,15 +37,33 @@ module Belpost
     # @raise [Belpost::ApiError] If the API returns an error response.
     def create_batch(batch_data)
       validation_result = Validation::BatchSchema.new.call(batch_data)
-      unless validation_result.success?
-        raise ValidationError, "Invalid batch data: #{validation_result.errors.to_h}"
-      end
+      raise ValidationError, "Invalid batch data: #{validation_result.errors.to_h}" unless validation_result.success?
 
       batch = Models::Batch.new(batch_data)
       response = @api_service.post(ApiPaths::BATCH_MAILING_LIST, batch.to_h)
       response.to_h
     end
 
+    # Creates new items in a batch by sending a POST request to the API.
+    #
+    # @param batch_id [Integer] The ID of the batch where items should be added.
+    # @param items_data [Hash] The data for the batch items to create.
+    # @return [Hash] The parsed JSON response from the API.
+    # @raise [Belpost::InvalidRequestError] If the request data is invalid.
+    # @raise [Belpost::ApiError] If the API returns an error response.
+    def create_batch_items(batch_id, items_data)
+      raise ValidationError, "Batch ID must be provided" if batch_id.nil?
+      raise ValidationError, "Batch ID must be a positive integer" unless batch_id.is_a?(Integer) && batch_id.positive?
+
+      validation_result = Validation::BatchItemSchema.call(items_data)
+      raise ValidationError, "Invalid batch item data: #{validation_result.errors.to_h}" unless validation_result.success?
+
+      batch_item = Models::BatchItem.new(items_data)
+      path = ApiPaths::BATCH_MAILING_LIST_ITEM.gsub(':id', batch_id.to_s)
+      response = @api_service.post(path, batch_item.to_h)
+      response.to_h
+    end
+
     # Creates a new postal parcel by sending a POST request to the API.
     #
     # @param parcel_data [Hash] The data for the postal parcel.
@@ -51,9 +72,7 @@ module Belpost
     # @raise [Belpost::ApiError] If the API returns an error response.
     def create_parcel(parcel_data)
       validation_result = Validation::ParcelSchema.call(parcel_data)
-      unless validation_result.success?
-        raise ValidationError, "Invalid parcel data: #{validation_result.errors.to_h}"
-      end
+      raise ValidationError, "Invalid parcel data: #{validation_result.errors.to_h}" unless validation_result.success?
 
       parcel = Models::Parcel.new(parcel_data)
       response = @api_service.post(ApiPaths::POSTAL_DELIVERIES, parcel.to_h)
@@ -123,6 +142,20 @@ module Belpost
       response.to_h
     end
 
+    # Searches for addresses belonging to a specific postal code (postcode).
+    #
+    # @param postcode [String] The postal code to search for (6 digits)
+    # @return [Array<Hash>] An array of addresses belonging to the specified postal code
+    # @raise [Belpost::ValidationError] If the postcode is invalid
+    # @raise [Belpost::ApiError] If the API returns an error response
+    def find_addresses_by_postcode(postcode)
+      validation_result = Validation::PostcodeSchema.new.call(postcode: postcode)
+      raise ValidationError, "Invalid postcode: #{validation_result.errors.to_h}" unless validation_result.success?
+
+      response = @api_service.get(ApiPaths::GEO_DIRECTORY_ADDRESSES, { postcode: postcode })
+      response.to_h
+    end
+
     # Searches for postal codes by city, street, and building number.
     #
     # @param city [String] The city name (required)
@@ -150,6 +183,54 @@ module Belpost
       response.to_h
     end
 
+    # Lists all batches with optional filtering.
+    #
+    # @param page [Integer] The page number for pagination (optional, default: 1, must be > 0)
+    # @param status [String] Filter by status: 'committed' or 'uncommitted' (optional)
+    # @param per_page [Integer] Number of items per page (optional)
+    # @param search [Integer] Search by batch number (optional)
+    # @return [Hash] The parsed JSON response containing batch list with pagination details
+    # @raise [Belpost::ValidationError] If   parameters are invalid
+    # @raise [Belpost::ApiError] If the API returns an error response
+    def list_batches(page: 1, status: nil, per_page: nil, search: nil)
+      params = {}
+
+      # Validate page parameter
+      if page
+        raise ValidationError, "Page must be an integer" unless page.is_a?(Integer)
+        raise ValidationError, "Page must be greater than 0" unless page.positive?
+
+        params[:page] = page
+      end
+
+      # Validate status parameter
+      if status
+        unless %w[committed uncommitted].include?(status)
+          raise ValidationError, "Status must be 'committed' or 'uncommitted'"
+        end
+
+        params[:status] = status
+      end
+
+      # Validate per_page parameter
+      if per_page
+        raise ValidationError, "Per page must be an integer" unless per_page.is_a?(Integer)
+        raise ValidationError, "Per page must be positive" unless per_page.positive?
+
+        params[:perPage] = per_page
+      end
+
+      # Validate search parameter
+      if search
+        raise ValidationError, "Search must be an integer" unless search.is_a?(Integer)
+
+        params[:search] = search
+      end
+
+      response = @api_service.get(ApiPaths::BATCH_MAILING_LIST, params)
+      response.to_h
+    end
+
     private
 
     def format_address(address)
@@ -165,11 +246,11 @@ module Belpost
       return building unless building
 
       building.gsub(/\s+/, " ")
-             .gsub(/\s*корпус\s*(\d+)\s*/i, '/\1')
-             .gsub(/\s*корп\s*(\d+)\s*/i, '/\1')
-             .gsub(/\s*кор\s*(\d+)\s*/i, '/\1')
-             .gsub(/\s*к\s*(\d+)\s*/i, '/\1')
-             .strip
+              .gsub(/\s*корпус\s*(\d+)\s*/i, '/\1')
+              .gsub(/\s*корп\s*(\d+)\s*/i, '/\1')
+              .gsub(/\s*кор\s*(\d+)\s*/i, '/\1')
+              .gsub(/\s*к\s*(\d+)\s*/i, '/\1')
+              .strip
     end
   end
 end

data/lib/belpost/configuration.rb

@@ -9,7 +9,7 @@ module Belpost
     def initialize
       @base_url = ENV.fetch("BELPOST_API_URL", "https://api.belpost.by")
       @jwt_token = ENV.fetch("BELPOST_JWT_TOKEN", nil)
-      
+
       # Convert timeout to integer with a fallback to default
       begin
         @timeout = Integer(ENV.fetch("BELPOST_TIMEOUT", 10))
@@ -17,14 +17,14 @@ module Belpost
         @timeout = 10
       end
     end
-    
+
     # Validates that all required configuration is present
     # @raise [Belpost::ConfigurationError] If required configuration is missing
     def validate!
       raise ConfigurationError, "Base URL is required" if base_url.nil?
       raise ConfigurationError, "JWT token is required" if jwt_token.nil?
     end
-    
+
     # Returns a hash representation of the configuration
     # @return [Hash] The configuration as a hash
     def to_h

data/lib/belpost/models/batch.rb

@@ -39,4 +39,4 @@ module Belpost
       end
     end
   end
-end 
+end

data/lib/belpost/models/batch_item.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Belpost
+  module Models
+    # Model class for batch item
+    class BatchItem
+      attr_reader :data
+
+      def initialize(data)
+        @data = data
+      end
+
+      def to_h
+        data
+      end
+
+      def to_json(*_args)
+        data.to_json
+      end
+    end
+  end
+end 

data/lib/belpost/models/customs_declaration.rb

@@ -50,8 +50,7 @@ module Belpost
       def valid?
         return false if @category && !VALID_CATEGORIES.include?(@category)
         return false if @category == "other" && @explanation.nil?
-        
-        # Проверка наличия обязательных полей для коммерческих отправлений
+
         if %w[merchandise sample returned_goods].include?(@category)
           return false if @items.empty?
           return false if @price.empty?
@@ -61,4 +60,4 @@ module Belpost
       end
     end
   end
-end 
+end

data/lib/belpost/models/parcel_builder.rb

@@ -194,23 +194,19 @@ module Belpost
       private
 
       def validate!
-        # Проверка обязательных полей
         raise ValidationError, "Weight is required" unless @data.dig(:parcel, :measures, :weight)
         raise ValidationError, "Sender type is required" unless @data.dig(:sender, :type)
         raise ValidationError, "Recipient type is required" unless @data.dig(:recipient, :type)
 
-        # Проверка логики
         if @data.dig(:addons, :cash_on_delivery) && !@data.dig(:addons, :declared_value)
           raise ValidationError, "Declared value is required when cash on delivery is set"
         end
 
-        # Проверка международных отправлений
-        if @data.dig(:parcel, :arrival, :country) != "BY"
-          if @data[:cp72].nil? || @data[:cp72].empty?
-            raise ValidationError, "Customs declaration is required for international parcels"
-          end
-        end
+        return unless @data.dig(:parcel, :arrival, :country) != "BY"
+        return unless @data[:cp72].nil? || @data[:cp72].empty?
+
+        raise ValidationError, "Customs declaration is required for international parcels"
       end
     end
   end
-end 
+end

data/lib/belpost/postal_delivery_types.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Belpost
+  # Module for managing postal delivery types in the Belpost system.
+  # Provides a centralized way to handle and validate different types of postal deliveries.
+  #
+  # @example Validating a postal delivery type
+  #   Belpost::PostalDeliveryTypes.valid?("ordered_small_package") # => true
+  #
+  # @example Getting all available types
+  #   Belpost::PostalDeliveryTypes.all # => [:ordered_small_package, :letter_declare_value, ...]
+  #
+  # @example Getting a description for a type
+  #   Belpost::PostalDeliveryTypes.description("ordered_small_package") # => "Заказной мелкий пакет республиканский"
+  #
+  # @note All types are frozen to prevent modification at runtime
+  module PostalDeliveryTypes
+    # Hash containing all valid postal delivery types with their Russian descriptions
+    # @return [Hash<Symbol, String>] frozen hash of postal delivery types and their descriptions
+    TYPES = {
+      ordered_small_package: "Заказной мелкий пакет республиканский",
+      letter_declare_value: "Письмо с объявленной ценностью республиканское",
+      package: "Простая посылка республиканская (без ОЦ)",
+      ems: "Республиканское отправление EMS",
+      ordered_parcel_post: "Заказная бандероль республиканская",
+      ordered_letter: "Заказное письмо республиканское",
+      ordered_postcard: "Заказная почтовая карточка республиканская",
+      small_package_declare_value: "Мелкий пакет с объявленной ценностью республиканский",
+      package_declare_value: "Посылка с объявленной ценностью республиканская",
+      ecommerce_economical: "Отправление E-commerce Эконом",
+      ecommerce_standard: "Отправление E-commerce Стандарт",
+      ecommerce_elite: "Отправление E-commerce Элит",
+      ecommerce_express: "Отправление E-commerce Экспресс",
+      ecommerce_light: "Отправление E-commerce Лайт",
+      ecommerce_optima: "Отправление E-commerce Оптима"
+    }.freeze
+
+    # Validation rules for each postal delivery type
+    # @return [Hash<Symbol, Hash>] frozen hash of validation rules for each type
+    VALIDATION_RULES = {
+      ecommerce_economical: {
+        negotiated_rate: false,
+        declared_value: [true, false],
+        partial_receipt: false,
+        postal_items_in_ops: true
+      },
+      ecommerce_standard: {
+        negotiated_rate: false,
+        declared_value: [true, false],
+        partial_receipt: false,
+        postal_items_in_ops: [true, false]
+      },
+      ecommerce_elite: {
+        negotiated_rate: false,
+        declared_value: [true, false],
+        partial_receipt: false,
+        postal_items_in_ops: [true, false]
+      },
+      ecommerce_express: {
+        negotiated_rate: false,
+        declared_value: [true, false],
+        partial_receipt: false,
+        postal_items_in_ops: [true, false]
+      },
+      ecommerce_light: {
+        negotiated_rate: false,
+        declared_value: [true, false],
+        partial_receipt: false,
+        postal_items_in_ops: true
+      },
+      ecommerce_optima: {
+        negotiated_rate: false,
+        declared_value: [true, false],
+        partial_receipt: false,
+        postal_items_in_ops: [true, false]
+      }
+    }.freeze
+
+    # Checks if the given type is a valid postal delivery type
+    # @param type [String, Symbol, nil] the type to validate
+    # @return [Boolean] true if the type is valid, false otherwise
+    def self.valid?(type)
+      return false if type.nil?
+
+      TYPES.key?(type.to_sym)
+    rescue NoMethodError
+      false
+    end
+
+    # Returns all valid postal delivery types
+    # @return [Array<Symbol>] array of all valid postal delivery type symbols
+    def self.all
+      TYPES.keys
+    end
+
+    # Returns the Russian description for a given postal delivery type
+    # @param type [String, Symbol] the type to get the description for
+    # @return [String, nil] the description if the type is valid, nil otherwise
+    def self.description(type)
+      TYPES[type.to_sym]
+    rescue NoMethodError
+      nil
+    end
+
+    # Returns validation rules for a given postal delivery type
+    # @param type [String, Symbol] the type to get rules for
+    # @return [Hash, nil] the validation rules if the type has them, nil otherwise
+    def self.validation_rules(type)
+      VALIDATION_RULES[type.to_sym]
+    rescue NoMethodError
+      nil
+    end
+
+    # Validates if the given parameters match the rules for the given type
+    # @param type [String, Symbol] the postal delivery type
+    # @param params [Hash] the parameters to validate
+    # @return [Array<String>] array of error messages, empty if validation passes
+    def self.validate_params(type, params)
+      rules = validation_rules(type)
+      return [] unless rules
+
+      errors = []
+      type_sym = type.to_sym
+
+      # Check negotiated_rate
+      if rules[:negotiated_rate] != params[:negotiated_rate]
+        errors << "negotiated_rate must be #{rules[:negotiated_rate]} for #{type_sym}"
+      end
+
+      # Check declared_value
+      if rules[:declared_value] && !rules[:declared_value].include?(params[:is_declared_value])
+        errors << "is_declared_value must be one of #{rules[:declared_value]} for #{type_sym}"
+      end
+
+      # Check partial_receipt
+      if rules[:partial_receipt] != params[:is_partial_receipt]
+        errors << "is_partial_receipt must be #{rules[:partial_receipt]} for #{type_sym}"
+      end
+
+      # Check postal_items_in_ops
+      if rules[:postal_items_in_ops]
+        if rules[:postal_items_in_ops].is_a?(Array)
+          unless rules[:postal_items_in_ops].include?(params[:postal_items_in_ops])
+            errors << "postal_items_in_ops must be one of #{rules[:postal_items_in_ops]} for #{type_sym}"
+          end
+        elsif rules[:postal_items_in_ops] != params[:postal_items_in_ops]
+          errors << if rules[:postal_items_in_ops] == true
+                      "postal_items_in_ops must be one of [true] for #{type_sym}"
+                    else
+                      "postal_items_in_ops must be #{rules[:postal_items_in_ops]} for #{type_sym}"
+                    end
+        end
+      end
+
+      errors
+    end
+  end
+end

data/lib/belpost/validations/batch_item_schema.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "dry-validation"
+
+module Belpost
+  module Validation
+    # Schema for validating batch item data
+    class BatchItemSchema < Dry::Validation::Contract
+      params do
+        required(:items).array(:hash) do
+          optional(:recipient_id).maybe(:integer)
+          optional(:recipient_foreign_id).maybe(:string)
+          optional(:recipient_object).maybe(:hash) do
+            optional(:foreign_id).maybe(:string)
+            required(:type).filled(:string, included_in?: %w[legal individual individual_entrepreneur])
+
+            optional(:first_name).maybe(:string)
+            optional(:last_name).maybe(:string)
+            optional(:second_name).maybe(:string)
+
+            optional(:company_name).maybe(:string)
+
+            required(:address).hash do
+              required(:address_type).filled(:string, included_in?: %w[address on_demand subscriber_box])
+              required(:postcode).filled(:string)
+              optional(:ops_id).maybe(:string)
+              required(:country_code).filled(:string)
+              optional(:region).maybe(:string)
+              optional(:district).maybe(:string)
+              required(:city).filled(:string)
+              optional(:building).maybe(:string)
+              optional(:housing).maybe(:string)
+              optional(:apartment).maybe(:string)
+              optional(:cell_number).maybe(:string)
+            end
+
+            optional(:phone).maybe(:string)
+          end
+
+          optional(:s10code).maybe(:string)
+          optional(:notification_s10code).maybe(:string)
+          required(:notification).filled(:integer, included_in?: [0, 1, 2, 5, 7])
+          required(:category).filled(:integer, included_in?: [0, 1, 2])
+          required(:weight).filled(:integer, gt?: 0)
+
+          optional(:addons).maybe(:hash) do
+            optional(:declared_value).maybe(:float, gt?: 0)
+            optional(:cash_on_delivery).maybe(:float, gt?: 0)
+            optional(:careful_fragile).maybe(:bool)
+            optional(:hand_over_personally).maybe(:bool)
+            optional(:subpoena).maybe(:bool)
+            optional(:description).maybe(:bool)
+            optional(:bulky).maybe(:bool)
+            optional(:recipient_payment).maybe(:bool)
+            optional(:documents_return).maybe(:bool)
+            optional(:deliver_to_work).maybe(:bool)
+            optional(:open_upon_delivery).maybe(:bool)
+            optional(:time_of_delivery).maybe(:hash) do
+              required(:type).filled(:string, included_in?: %w[level1 level2 level3 level4])
+              optional(:time_interval).hash do
+                required(:from).filled(:string)
+                required(:to).filled(:string)
+              end
+            end
+            optional(:free_return).maybe(:bool)
+            optional(:partial_return).maybe(:bool)
+            optional(:government).maybe(:bool)
+            optional(:military).maybe(:bool)
+            optional(:service).maybe(:bool)
+            optional(:shelf_life).maybe(:integer, included_in?: (10..30))
+            optional(:email).maybe(:string)
+            optional(:phone).maybe(:string)
+            optional(:coordinate_delivery_interval).maybe(:bool)
+          end
+        end
+      end
+
+      rule('items[].recipient_object.first_name') do
+        if key? && value.is_a?(Array)
+          value.each_with_index do |item, idx|
+            if item[:recipient_object] && item[:recipient_object][:type] == 'individual' && item[:recipient_object][:first_name].nil?
+              key(:"items.#{idx}.recipient_object.first_name").failure('must be filled for individual type')
+            end
+          end
+        end
+      end
+
+      rule('items[].recipient_object.last_name') do
+        if key? && value.is_a?(Array)
+          value.each_with_index do |item, idx|
+            if item[:recipient_object] && item[:recipient_object][:type] == 'individual' && item[:recipient_object][:last_name].nil?
+              key(:"items.#{idx}.recipient_object.last_name").failure('must be filled for individual type')
+            end
+          end
+        end
+      end
+
+      rule('items[].recipient_object.company_name') do
+        if key? && value.is_a?(Array)
+          value.each_with_index do |item, idx|
+            if item[:recipient_object] &&
+               (item[:recipient_object][:type] == 'legal' || item[:recipient_object][:type] == 'individual_entrepreneur') &&
+               item[:recipient_object][:company_name].nil?
+              key(:"items.#{idx}.recipient_object.company_name").failure('must be filled for legal or individual_entrepreneur type')
+            end
+          end
+        end
+      end
+
+      rule('items[].recipient_object.address.ops_id') do
+        if key? && value.is_a?(Array)
+          value.each_with_index do |item, idx|
+            if item[:recipient_object] &&
+               item[:recipient_object][:address] &&
+               item[:recipient_object][:address][:address_type] == 'address' &&
+               item[:recipient_object][:address][:ops_id].nil?
+              key(:"items.#{idx}.recipient_object.address.ops_id").failure('must be filled for address type')
+            end
+          end
+        end
+      end
+
+      rule('items[].recipient_object.address.cell_number') do
+        if key? && value.is_a?(Array)
+          value.each_with_index do |item, idx|
+            if item[:recipient_object] &&
+               item[:recipient_object][:address] &&
+               item[:recipient_object][:address][:address_type] == 'subscriber_box' &&
+               item[:recipient_object][:address][:cell_number].nil?
+              key(:"items.#{idx}.recipient_object.address.cell_number").failure('must be filled for subscriber_box type')
+            end
+          end
+        end
+      end
+
+      rule('items[].recipient_object') do
+        if key? && value.is_a?(Array)
+          value.each_with_index do |item, idx|
+            if item[:recipient_id].nil? && item[:recipient_foreign_id].nil? && item[:recipient_object].nil?
+              key(:"items.#{idx}.recipient_object").failure('must be provided if recipient_id and recipient_foreign_id are null')
+            end
+          end
+        end
+      end
+
+      # Add validation to ensure e-commerce has the proper notifications
+      rule('items[].notification') do
+        if key? && value.is_a?(Array)
+          value.each_with_index do |item, idx|
+            if item[:notification] == 5 && (!item[:addons] || !item[:addons][:email])
+              key(:"items.#{idx}.addons.email").failure('email is required for electronic notification (5)')
+            end
+          end
+        end
+      end
+
+      # Add class method to make it callable directly
+      def self.call(params)
+        new.call(params)
+      end
+    end
+  end
+end

data/lib/belpost/validations/batch_schema.rb

@@ -8,23 +8,7 @@ module Belpost
     class BatchSchema < Dry::Validation::Contract
       params do
         required(:postal_delivery_type).filled(:str?).value(
-          included_in?: %w[
-            ordered_small_package
-            letter_declare_value
-            package
-            ems
-            ordered_parcel_post
-            ordered_letter
-            ordered_postcard
-            small_package_declare_value
-            package_declare_value
-            ecommerce_economical
-            ecommerce_standard
-            ecommerce_elite
-            ecommerce_express
-            ecommerce_light
-            ecommerce_optima
-          ]
+          included_in?: Belpost::PostalDeliveryTypes.all.map(&:to_s)
         )
 
         required(:direction).filled(:str?).value(
@@ -53,6 +37,16 @@ module Belpost
         optional(:is_declared_value).maybe(:bool?)
         optional(:is_partial_receipt).maybe(:bool?)
       end
+
+      rule(:postal_delivery_type) do
+        if key? && value
+          errors = Belpost::PostalDeliveryTypes.validate_params(
+            value,
+            values
+          )
+          errors.each { |error| key.failure(error) }
+        end
+      end
     end
   end
 end 

data/lib/belpost/validations/postcode_schema.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "dry-validation"
+
+module Belpost
+  module Validation
+    # Schema for validating postcode parameters
+    class PostcodeSchema < Dry::Validation::Contract
+      params do
+        required(:postcode).filled(:string)
+      end
+
+      rule(:postcode) do
+        key.failure("must be 6 digits") unless value.match?(/^\d{6}$/)
+      end
+    end
+  end
+end 

data/lib/belpost/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Belpost
-  VERSION = "0.9.0"
+  VERSION = "0.11.0"
 end

data/lib/belpost.rb

@@ -1,17 +1,28 @@
 # frozen_string_literal: true
 
-require "dotenv/load"
-
 require_relative "belpost/version"
 require_relative "belpost/configuration"
-require_relative "belpost/client"
 require_relative "belpost/errors"
 require_relative "belpost/retry"
-require_relative "belpost/models/parcel"
+require_relative "belpost/api_paths"
+require_relative "belpost/api_service"
+
+# Load models
 require_relative "belpost/models/api_response"
+require_relative "belpost/models/batch"
 require_relative "belpost/models/customs_declaration"
+require_relative "belpost/models/parcel"
 require_relative "belpost/models/parcel_builder"
+
+# Load types and validations
+require_relative "belpost/postal_delivery_types"
+require_relative "belpost/validations/batch_schema"
 require_relative "belpost/validations/parcel_schema"
+require_relative "belpost/validations/address_schema"
+require_relative "belpost/validations/postcode_schema"
+
+# Load client last as it depends on other files
+require_relative "belpost/client"
 
 # Module for working with Belpochta API.
 # Provides an interface for configuring and interacting with the API.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: belpost
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.11.0
 platform: ruby
 authors:
 - KuberLite
@@ -24,7 +24,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: dry-validation
+  name: dry-schema
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -38,7 +38,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: dry-schema
+  name: dry-validation
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -76,13 +76,17 @@ files:
 - lib/belpost/errors.rb
 - lib/belpost/models/api_response.rb
 - lib/belpost/models/batch.rb
+- lib/belpost/models/batch_item.rb
 - lib/belpost/models/customs_declaration.rb
 - lib/belpost/models/parcel.rb
 - lib/belpost/models/parcel_builder.rb
+- lib/belpost/postal_delivery_types.rb
 - lib/belpost/retry.rb
 - lib/belpost/validations/address_schema.rb
+- lib/belpost/validations/batch_item_schema.rb
 - lib/belpost/validations/batch_schema.rb
 - lib/belpost/validations/parcel_schema.rb
+- lib/belpost/validations/postcode_schema.rb
 - lib/belpost/version.rb
 homepage: https://github.com/KuberLite/belpost
 licenses: