cdek_api_client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 389563fd9ba0f235cdc75afdc77906d9e2fb7d3f6da3d4392105758c8ad8756a
+  data.tar.gz: dfa1b6d50ea42547dfdf8c5846a47c9882e8b2ab5f56557b014d122a026c5eb2
+SHA512:
+  metadata.gz: 364b5510d3f833a43ff3ab1d0581844821e1cbce1211a61b81802c3fb1f228d901621552c57e4052aaa88ae6609861ee5a2e1ff6ad759eaa970d51b70de1b3a5
+  data.tar.gz: b982eef2e9d6bb5f268204af574605f7f96a077331cfeb38d58db02a2ef9be601e5cac83439b4aa879b245ac41262c97a3dcb6cc83eca2bf977e5359af989089

data/README.md

@@ -0,0 +1,306 @@
+# CDEK API Client
+
+[![Gem Version](https://badge.fury.io/rb/cdek_api_client.svg)](https://badge.fury.io/rb/cdek_api_client)
+
+A Ruby client for interacting with the CDEK API, providing functionalities for order creation, tracking, tariff calculation, location data retrieval, and webhook management. This gem ensures clean, robust, and maintainable code with proper validations.
+
+This Readme is also available in:
+
+- [Russian](README_RUS.md)
+- [Tatar](README_TAT.md)
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Initialization](#initialization)
+  - [Creating an Order](#creating-an-order)
+  - [Tracking an Order](#tracking-an-order)
+  - [Calculating Tariff](#calculating-tariff)
+  - [Getting Location Data](#getting-location-data)
+  - [Setting Up Webhooks](#setting-up-webhooks)
+- [Entities](#entities)
+  - [OrderData](#orderdata)
+  - [Recipient](#recipient)
+  - [Sender](#sender)
+  - [Package](#package)
+  - [Item](#item)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cdek_api_client'
+```
+
+````
+
+And then execute:
+
+```sh
+bundle install
+```
+
+Or install it yourself as:
+
+```sh
+gem install cdek_api_client
+```
+
+## Usage
+
+### Initialization
+
+To use the CDEK API Client, you need to initialize it with your CDEK API credentials (client ID and client secret):
+
+```ruby
+require 'cdek_api_client'
+
+client_id = 'your_client_id'
+client_secret = 'your_client_secret'
+
+client = CDEKApiClient::Client.new(client_id, client_secret)
+```
+
+### Creating an Order
+
+To create an order, you need to create the necessary entities (`OrderData`, `Recipient`, `Sender`, `Package`, and `Item`) and then pass them to the `create_order` method of the `Order` class:
+
+```ruby
+recipient = CDEKApiClient::Entities::Recipient.new(
+  name: 'John Doe',
+  phones: [{ number: '+79000000000' }],
+  email: 'johndoe@example.com'
+)
+
+sender = CDEKApiClient::Entities::Sender.new(
+  name: 'Sender Name',
+  phones: [{ number: '+79000000001' }],
+  email: 'sender@example.com'
+)
+
+item = CDEKApiClient::Entities::Item.new(
+  name: 'Item 1',
+  ware_key: '00055',
+  payment: 1000,
+  cost: 1000,
+  weight: 500,
+  amount: 1
+)
+
+package = CDEKApiClient::Entities::Package.new(
+  number: '1',
+  weight: 500,
+  length: 10,
+  width: 10,
+  height: 10,
+  comment: 'Package 1',
+  items: [item]
+)
+
+order_data = CDEKApiClient::Entities::OrderData.new(
+  type: 1,
+  number: 'TEST123',
+  tariff_code: 1,
+  comment: 'Test order',
+  recipient: recipient,
+  sender: sender,
+  from_location: { code: 44 },
+  to_location: { code: 270 },
+  packages: [package]
+)
+
+order_client = CDEKApiClient::Order.new(client)
+
+begin
+  order_response = order_client.create(order_data)
+  puts "Order created successfully: #{order_response}"
+rescue => e
+  puts "Error creating order: #{e.message}"
+end
+```
+
+### Tracking an Order
+
+To track an order, use the `track` method of the `Order` class with the order UUID:
+
+```ruby
+order_uuid = 'order_uuid_from_created_order_response'
+
+begin
+  tracking_info = order_client.track(order_uuid)
+  puts "Tracking info: #{tracking_info}"
+rescue => e
+  puts "Error tracking order: #{e.message}"
+end
+```
+
+### Calculating Tariff
+
+To calculate the tariff, use the `calculate` method of the `Tariff` class with the necessary tariff data:
+
+```ruby
+tariff_data = CDEKApiClient::Entities::TariffData.new(
+  type: 1,
+  currency: 'RUB',
+  from_location: { code: 44 },
+  to_location: { code: 137 },
+  packages: [{ weight: 500, length: 10, width: 10, height: 10 }]
+)
+
+tariff_client = CDEKApiClient::Tariff.new(client)
+
+begin
+  tariff_response = tariff_client.calculate(tariff_data)
+  puts "Tariff calculated: #{tariff_response}"
+rescue => e
+  puts "Error calculating tariff: #{e.message}"
+end
+```
+
+### Getting Location Data
+
+To retrieve location data such as cities and regions supported by CDEK, use the `cities` and `regions` methods of the `Location` class:
+
+```ruby
+location_client = CDEKApiClient::Location.new(client)
+
+# Fetching cities
+begin
+  cities = location_client.cities
+  puts "Cities: #{cities}"
+rescue => e
+  puts "Error fetching cities: #{e.message}"
+end
+
+# Fetching regions
+begin
+  regions = location_client.regions
+  puts "Regions: #{regions}"
+rescue => e
+  puts "Error fetching regions: #{e.message}"
+end
+```
+
+### Setting Up Webhooks
+
+Webhooks allow your application to receive real-time notifications about various events related to your shipments. To set up a webhook, register a URL where CDEK will send HTTP POST requests with event data:
+
+```ruby
+webhook_client = CDEKApiClient::Webhook.new(client)
+
+webhook_url = 'https://yourapp.com/webhooks/cdek'
+begin
+  response = webhook_client.register(webhook_url, event_types: ['ORDER_STATUS', 'DELIVERY_STATUS'])
+  puts "Webhook registered: #{response}"
+rescue => e
+  puts "Error registering webhook: #{e.message}"
+end
+```
+
+To retrieve and delete registered webhooks:
+
+```ruby
+# Fetching webhooks
+begin
+  webhooks = webhook_client.get_webhooks
+  puts "Webhooks: #{webhooks}"
+rescue => e
+  puts "Error fetching webhooks: #{e.message}"
+end
+
+# Deleting a webhook
+webhook_id = 'webhook_id_to_delete'
+begin
+  response = webhook_client.delete(webhook_id)
+  puts "Webhook deleted: #{response}"
+rescue => e
+  puts "Error deleting webhook: #{e.message}"
+end
+```
+
+## Entities
+
+### OrderData
+
+Represents the order data.
+
+Attributes:
+
+- `type` (Integer, required): The type of the order.
+- `number` (String, required): The order number.
+- `tariff_code` (Integer, required): The tariff code.
+- `comment` (String): The comment for the order.
+- `recipient` (Recipient, required): The recipient details.
+- `sender` (Sender, required): The sender details.
+- `from_location` (Hash, required): The location details from where the order is shipped.
+- `to_location` (Hash, required): The location details to where the order is shipped.
+- `services` (Array): Additional services.
+- `packages` (Array, required): List of packages.
+
+### Recipient
+
+Represents the recipient details.
+
+Attributes:
+
+- `name` (String, required): The recipient's name.
+- `phones` (Array, required): List of phone numbers.
+- `email` (String, required): The recipient's email address.
+
+### Sender
+
+Represents the sender details.
+
+Attributes:
+
+- `name` (String, required): The sender's name.
+- `phones` (Array, required): List of phone numbers.
+- `email` (String, required): The sender's email address.
+
+### Package
+
+Represents the package details.
+
+Attributes:
+
+- `number` (String, required): The package number.
+- `weight` (Integer, required): The weight of the package.
+- `length` (Integer, required): The length of the package.
+- `width` (Integer, required): The width of the package.
+- `height` (Integer, required): The height of the package.
+- `comment` (String): The comment for the package.
+- `items` (Array, required): List of items in the package.
+
+### Item
+
+Represents the item details.
+
+Attributes:
+
+- `name` (String, required): The name of the item.
+- `ware_key` (String, required): The ware key of the item.
+- `payment` (Integer, required): The payment value of the item.
+- `cost` (Integer, required): The cost of the item.
+- `weight` (Integer, required): The weight of the item.
+- `amount` (Integer, required): The amount of the item.
+
+## TODO List
+
+- [ ] Restructure the codebase for better organization.
+- [ ] Add mappings for CDEK internal codes.
+- [ ] Add more API endpoints and data entities.
+- [ ] Check all attributes for required and optional fields.
+- [ ] Add documentation for all classes and methods.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [https://github.com/your-username/cdek_api_client](https://github.com/your-username/cdek_api_client).
+
+## License
+
+The gem is available as open-source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+````

data/lib/cdek_api_client/client.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'faraday_middleware'
+require 'json'
+require 'logger'
+
+module CDEKApiClient
+  ##
+  # Client class for interacting with the CDEK API.
+  #
+  # This class provides methods for authentication and initializing the API resources
+  # for orders, locations, tariffs, and webhooks.
+  #
+  # @attr_reader [String] token The access token used for authentication.
+  # @attr_reader [Logger] logger The logger used for logging HTTP requests and responses.
+  # @attr_reader [Order] order The Order resource for interacting with order-related API endpoints.
+  # @attr_reader [Location] location The Location resource for interacting with location-related API endpoints.
+  # @attr_reader [Tariff] tariff The Tariff resource for interacting with tariff-related API endpoints.
+  # @attr_reader [Webhook] webhook The Webhook resource for interacting with webhook-related API endpoints.
+  class Client
+    BASE_URL = ENV.fetch('CDEK_API_URL', 'https://api.edu.cdek.ru/v2')
+    TOKEN_URL = "#{BASE_URL}/oauth/token".freeze
+
+    attr_reader :token, :logger, :order, :location, :tariff, :webhook
+
+    ##
+    # Initializes a new Client object.
+    #
+    # @param [String] client_id The client ID for authentication.
+    # @param [String] client_secret The client secret for authentication.
+    # @param [Logger] logger The logger for logging HTTP requests and responses.
+    def initialize(client_id, client_secret, logger: Logger.new($stdout))
+      @client_id = client_id
+      @client_secret = client_secret
+      @logger = logger
+      @token = authenticate
+
+      @order = CDEKApiClient::Order.new(self)
+      @location = CDEKApiClient::Location.new(self)
+      @tariff = CDEKApiClient::Tariff.new(self)
+      @webhook = CDEKApiClient::Webhook.new(self)
+    end
+
+    ##
+    # Authenticates with the CDEK API and retrieves an access token.
+    #
+    # @return [String] The access token.
+    # @raise [Error] if there is an error getting the token.
+    def authenticate
+      response = connection.post(TOKEN_URL) do |req|
+        req.body = {
+          grant_type: 'client_credentials',
+          client_id: @client_id,
+          client_secret: @client_secret
+        }
+      end
+
+      raise Error, "Error getting token: #{response.body}" unless response.success?
+
+      response.body['access_token']
+    end
+
+    ##
+    # Creates a Faraday connection object.
+    #
+    # @return [Faraday::Connection] The Faraday connection object.
+    def connection
+      Faraday.new(url: BASE_URL) do |conn|
+        conn.request :url_encoded
+        conn.response :json, content_type: /\bjson$/
+        conn.adapter Faraday.default_adapter
+        conn.response :logger, @logger, bodies: true
+      end
+    end
+
+    ##
+    # Creates a Faraday connection object with authorization.
+    #
+    # @return [Faraday::Connection] The Faraday connection object with authorization.
+    def auth_connection
+      Faraday.new(url: BASE_URL) do |conn|
+        conn.request :url_encoded
+        conn.response :json, content_type: /\bjson$/
+        conn.authorization :Bearer, @token
+        conn.adapter Faraday.default_adapter
+        conn.response :logger, @logger, bodies: true
+      end
+    end
+
+    ##
+    # Handles the response from the API.
+    #
+    # @param [Faraday::Response] response The response object.
+    # @return [Hash] The parsed response body.
+    # @raise [Error] if the response is not successful.
+    def handle_response(response)
+      raise Error, "Error: #{response.body}" unless response.success?
+
+      response.body
+    end
+
+    ##
+    # Validates the format of a UUID.
+    #
+    # @param [String] uuid The UUID to validate.
+    # @raise [RuntimeError] if the UUID format is invalid.
+    def validate_uuid(uuid)
+      return if uuid.match?(/\A[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}\z/)
+
+      raise 'Invalid UUID format'
+    end
+  end
+end

data/lib/cdek_api_client/entities/currency_mapper.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module CDEKApiClient
+  module Entities
+    module CurrencyMapper
+      CURRENCY_CODES = {
+        'RUB' => 1,
+        'KZT' => 2,
+        'USD' => 3,
+        'EUR' => 4,
+        'GBP' => 5,
+        'CNY' => 6,
+        'BYR' => 7,
+        'UAH' => 8,
+        'KGS' => 9,
+        'AMD' => 10,
+        'TRY' => 11,
+        'THB' => 12,
+        'KRW' => 13,
+        'AED' => 14,
+        'UZS' => 15,
+        'MNT' => 16,
+        'PLN' => 17,
+        'AZN' => 18,
+        'GEL' => 19,
+        'JPY' => 55
+      }.freeze
+
+      def self.to_code(currency)
+        CURRENCY_CODES[currency] || (raise ArgumentError, "Invalid currency code: #{currency}")
+      end
+    end
+  end
+end

data/lib/cdek_api_client/entities/item.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'validatable'
+require_relative 'payment'
+
+module CDEKApiClient
+  module Entities
+    class Item
+      include Validatable
+
+      attr_accessor :ware_key, :payment, :name, :cost, :amount, :weight, :url
+
+      validates :ware_key, type: :string, presence: true
+      validates :payment, type: :object, presence: true
+      validates :name, type: :string, presence: true
+      validates :cost, type: :integer, presence: true
+      validates :amount, type: :integer, presence: true
+      validates :weight, type: :integer, presence: true
+
+      def initialize(ware_key:, payment:, name:, cost:, amount:, weight:, url: nil)
+        @ware_key = ware_key
+        @payment = payment
+        @name = name
+        @cost = cost
+        @amount = amount
+        @weight = weight
+        @url = url
+        validate!
+      end
+
+      def to_json(*_args)
+        {
+          ware_key: @ware_key,
+          payment: @payment,
+          name: @name,
+          cost: @cost,
+          amount: @amount,
+          weight: @weight,
+          url: @url
+        }.to_json
+      end
+    end
+  end
+end

data/lib/cdek_api_client/entities/location.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module CDEKApiClient
+  module Entities
+    class Location
+      include Validatable
+
+      attr_accessor :code, :city, :address
+
+      validates :code, type: :integer, presence: true
+      validates :city, type: :string
+      validates :address, type: :string
+
+      def initialize(code:, city: nil, address: nil)
+        @code = code
+        @city = city
+        @address = address
+        validate!
+      end
+
+      def to_json(*_args)
+        {
+          code: @code,
+          city: @city,
+          address: @address
+        }.to_json
+      end
+    end
+  end
+end

data/lib/cdek_api_client/entities/order_data.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative 'validatable'
+require_relative 'package'
+require_relative 'recipient'
+require_relative 'sender'
+
+module CDEKApiClient
+  module Entities
+    class OrderData
+      include Validatable
+
+      attr_accessor :type, :number, :tariff_code, :comment, :shipment_point, :delivery_point,
+                    :from_location, :to_location, :recipient, :sender, :services, :packages
+
+      validates :type, type: :integer, presence: true
+      validates :number, type: :string, presence: true
+      validates :tariff_code, type: :integer, presence: true
+      validates :from_location, type: :object, presence: true
+      validates :to_location, type: :object, presence: true
+      validates :recipient, type: :object, presence: true
+      validates :sender, type: :object, presence: true
+      validates :packages, type: :array, presence: true, items: [Package]
+      validates :comment, type: :string
+
+      def initialize(type:, number:, tariff_code:, from_location:, to_location:, recipient:, sender:, packages:,
+                     comment: nil, shipment_point: nil, delivery_point: nil, services: [])
+        @type = type
+        @number = number
+        @tariff_code = tariff_code
+        @comment = comment
+        @shipment_point = shipment_point
+        @delivery_point = delivery_point
+        @from_location = from_location
+        @to_location = to_location
+        @recipient = recipient
+        @sender = sender
+        @services = services
+        @packages = packages
+        validate!
+      end
+
+      def to_json(*_args)
+        {
+          type: @type,
+          number: @number,
+          tariff_code: @tariff_code,
+          comment: @comment,
+          shipment_point: @shipment_point,
+          delivery_point: @delivery_point,
+          from_location: @from_location,
+          to_location: @to_location,
+          recipient: @recipient,
+          sender: @sender,
+          services: @services,
+          packages: @packages
+        }.to_json
+      end
+    end
+  end
+end

data/lib/cdek_api_client/entities/package.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'validatable'
+require_relative 'item'
+
+module CDEKApiClient
+  module Entities
+    class Package
+      include Validatable
+
+      attr_accessor :number, :comment, :height, :length, :weight, :width, :items
+
+      validates :number, type: :string, presence: true
+      validates :height, type: :integer, presence: true
+      validates :length, type: :integer, presence: true
+      validates :weight, type: :integer, presence: true
+      validates :width, type: :integer, presence: true
+      validates :items, type: :array, presence: true, items: [Item]
+
+      def initialize(number:, comment:, height:, length:, weight:, width:, items:)
+        @number = number
+        @comment = comment
+        @height = height
+        @length = length
+        @weight = weight
+        @width = width
+        @items = items
+        validate!
+      end
+
+      def to_json(*_args)
+        {
+          number: @number,
+          comment: @comment,
+          height: @height,
+          length: @length,
+          weight: @weight,
+          width: @width,
+          items: @items
+        }.to_json
+      end
+    end
+  end
+end

data/lib/cdek_api_client/entities/payment.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'validatable'
+require_relative 'currency_mapper'
+
+module CDEKApiClient
+  module Entities
+    class Payment
+      include Validatable
+
+      attr_accessor :value, :currency
+
+      validates :value, type: :integer, presence: true, positive: true
+      validates :currency, type: :integer, presence: true
+
+      def initialize(value:, currency:)
+        @value = value
+        @currency = CDEKApiClient::Entities::CurrencyMapper.to_code(currency)
+        validate!
+      end
+
+      def to_json(*_args)
+        {
+          value: @value,
+          currency: @currency
+        }.to_json
+      end
+    end
+  end
+end

data/lib/cdek_api_client/entities/recipient.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'validatable'
+
+module CDEKApiClient
+  module Entities
+    class Recipient
+      include Validatable
+
+      attr_accessor :name, :phones, :email
+
+      validates :name, type: :string, presence: true
+      validates :phones, type: :array, items: [{ type: :hash, schema: { number: { type: :string, presence: true } } }],
+                         presence: true
+      validates :email, type: :string, presence: true
+
+      def initialize(name:, phones:, email:)
+        @name = name
+        @phones = phones
+        @email = email
+        validate!
+      end
+
+      def to_json(*_args)
+        {
+          name: @name,
+          phones: @phones,
+          email: @email
+        }.to_json
+      end
+    end
+  end
+end

data/lib/cdek_api_client/entities/sender.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'validatable'
+
+module CDEKApiClient
+  module Entities
+    class Sender
+      include Validatable
+
+      attr_accessor :name, :phones, :email
+
+      validates :name, type: :string, presence: true
+      validates :phones, type: :array, items: [{ type: :hash, schema: { number: { type: :string, presence: true } } }],
+                         presence: true
+      validates :email, type: :string, presence: true
+
+      def initialize(name:, phones:, email:)
+        @name = name
+        @phones = phones
+        @email = email
+        validate!
+      end
+
+      def to_json(*_args)
+        {
+          name: @name,
+          phones: @phones,
+          email: @email
+        }.to_json
+      end
+    end
+  end
+end

data/lib/cdek_api_client/entities/service.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'validatable'
+require_relative 'payment'
+
+module CDEKApiClient
+  module Entities
+    class Service
+      include Validatable
+
+      attr_accessor :code, :price, :name
+
+      validates :code, type: :string, presence: true
+      validates :price, type: :integer, presence: true
+      validates :name, type: :string, presence: true
+
+      def initialize(code:, price:, name:)
+        @code = code
+        @price = price
+        @name = name
+        validate!
+      end
+
+      def to_json(*_args)
+        {
+          code: @code,
+          price: @price,
+          name: @name
+        }.to_json
+      end
+    end
+  end
+end

data/lib/cdek_api_client/entities/tariff_data.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'validatable'
+require_relative 'currency_mapper'
+
+module CDEKApiClient
+  module Entities
+    class TariffData
+      include Validatable
+
+      attr_accessor :type, :currency, :from_location, :to_location, :packages, :tariff_code
+
+      validates :type, type: :integer, presence: true
+      validates :currency, type: :integer, presence: true
+      validates :tariff_code, type: :integer, presence: true
+      validates :from_location, type: :object, presence: true
+      validates :to_location, type: :object, presence: true
+      validates :packages, type: :array, presence: true, items: [Package]
+
+      def initialize(type:, currency:, from_location:, to_location:, packages:, tariff_code:)
+        @type = type
+        @currency = CurrencyMapper.to_code(currency)
+        @from_location = from_location
+        @to_location = to_location
+        @packages = packages
+        @tariff_code = tariff_code
+        validate!
+      end
+
+      def to_json(*_args)
+        {
+          type: @type,
+          currency: @currency,
+          from_location: @from_location,
+          to_location: @to_location,
+          packages: @packages,
+          tariff_code: @tariff_code
+        }.to_json
+      end
+    end
+  end
+end

data/lib/cdek_api_client/entities/validatable.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module CDEKApiClient
+  module Entities
+    module Validatable
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def validates(attribute, options)
+          @validations ||= {}
+          @validations[attribute] = options
+        end
+
+        def validations
+          @validations
+        end
+      end
+
+      def validate!
+        self.class.validations.each do |attribute, rule|
+          value = send(attribute)
+          validate_presence(attribute, value, rule)
+          validate_type(attribute, value, rule)
+        end
+      end
+
+      private
+
+      def validate_presence(attribute, value, rule)
+        raise "#{attribute} is required" if rule[:presence] && value.nil?
+      end
+
+      def validate_type(attribute, value, rule)
+        case rule[:type]
+        when :string
+          raise "#{attribute} must be a String" unless value.is_a?(String)
+        when :integer
+          raise "#{attribute} must be an Integer" unless value.is_a?(Integer)
+
+          validate_positive(attribute, value, rule)
+        when :array
+          raise "#{attribute} must be an Array" unless value.is_a?(Array)
+
+          validate_array_items(attribute, value, rule)
+        when :object
+          validate_object(attribute, value, rule)
+        when :hash
+          validate_hash(attribute, value, rule)
+        end
+      end
+
+      def validate_positive(attribute, value, rule)
+        raise "#{attribute} must be a positive number" if rule[:positive] && value <= 0
+      end
+
+      def validate_array_items(attribute, array, rule)
+        array.each do |item|
+          if item.is_a?(Hash)
+            validate_hash(attribute, item, rule[:items].first)
+          elsif item.is_a?(self.class || Class)
+            validate_object(attribute, item, rule[:items].first)
+          else
+            rule[:items].each do |key, val_rule|
+              validate_presence(key, item, { type: val_rule })
+              validate_type(key, item, { type: val_rule })
+            end
+          end
+        end
+      end
+
+      def validate_object(_attribute, object, _rule)
+        object.class.validations.each do |attr, validation_rule|
+          value = object.send(attr)
+          validate_presence(attr, value, validation_rule)
+          validate_type(attr, value, validation_rule)
+        end
+      end
+
+      def validate_hash(_attribute, hash, rule)
+        rule[:schema].each do |attr, validation_rule|
+          value = hash[attr]
+          validate_presence(attr, value, validation_rule)
+          validate_type(attr, value, validation_rule)
+        end
+      end
+    end
+  end
+end

data/lib/cdek_api_client/entities/webhook.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'validatable'
+
+module CDEKApiClient
+  module Entities
+    class Webhook
+      include Validatable
+
+      attr_accessor :url, :type, :event_types
+
+      validates :url, type: :string, presence: true
+      validates :type, type: :string, presence: true
+      validates :event_types, type: :array, presence: true, items: [{ type: :string, presence: true }]
+
+      def initialize(url:, type:, event_types:)
+        @url = url
+        @type = type
+        @event_types = event_types
+        validate!
+      end
+
+      def to_json(*_args)
+        {
+          url: @url,
+          type: @type,
+          event_types: @event_types
+        }.to_json
+      end
+    end
+  end
+end

data/lib/cdek_api_client/location.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module CDEKApiClient
+  class Location
+    CITIES_URL = 'location/cities'
+    REGIONS_URL = 'location/regions'
+
+    def initialize(client)
+      @client = client
+    end
+
+    def cities
+      response = @client.auth_connection.get(CITIES_URL) do |req|
+        req.headers['Content-Type'] = 'application/json'
+      end
+      handle_response(response)
+    end
+
+    def regions
+      response = @client.auth_connection.get(REGIONS_URL) do |req|
+        req.headers['Content-Type'] = 'application/json'
+      end
+      handle_response(response)
+    end
+
+    private
+
+    def handle_response(response)
+      @client.send(:handle_response, response)
+    end
+  end
+end

data/lib/cdek_api_client/order.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'cdek_api_client/entities/order_data'
+
+module CDEKApiClient
+  class Order
+    BASE_URL = ENV.fetch('CDEK_API_URL', 'https://api.edu.cdek.ru/v2')
+    ORDERS_URL = "#{BASE_URL}/orders".freeze
+
+    def initialize(client)
+      @client = client
+    end
+
+    def create(order_data)
+      validate_order_data(order_data)
+
+      response = @client.auth_connection.post(ORDERS_URL) do |req|
+        req.headers['Content-Type'] = 'application/json'
+        req.body = order_data.to_json
+      end
+      handle_response(response)
+    end
+
+    def track(order_uuid)
+      @client.validate_uuid(order_uuid)
+
+      response = @client.auth_connection.get("#{ORDERS_URL}/#{order_uuid}") do |req|
+        req.headers['Content-Type'] = 'application/json'
+      end
+      handle_response(response)
+    end
+
+    private
+
+    def validate_order_data(order_data)
+      raise 'order_data must be a Hash' unless order_data.is_a?(Entities::OrderData)
+    end
+
+    def handle_response(response)
+      @client.send(:handle_response, response)
+    end
+  end
+end

data/lib/cdek_api_client/recipient.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module CDEKApiClient
+  module Entities
+    class Recipient
+      attr_accessor :name, :phones, :email
+
+      VALIDATION_RULES = {
+        name: { type: :string, presence: true },
+        phones: { type: :array, presence: true, items: [{ type: :string, presence: true }] },
+        email: { type: :string, presence: true }
+      }.freeze
+
+      def initialize(name:, phones:, email:)
+        @name = name
+        @phones = phones
+        @email = email
+
+        Validator.validate(
+          {
+            name: @name,
+            phones: @phones,
+            email: @email
+          }, VALIDATION_RULES
+        )
+      end
+
+      def to_json(*_args)
+        {
+          name: @name,
+          phones: @phones,
+          email: @email
+        }.to_json
+      end
+    end
+  end
+end

data/lib/cdek_api_client/tariff.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module CDEKApiClient
+  class Tariff
+    BASE_URL = ENV.fetch('CDEK_API_URL', 'https://api.edu.cdek.ru/v2')
+    TARIFF_URL = "#{BASE_URL}/calculator/tariff".freeze
+
+    def initialize(client)
+      @client = client
+    end
+
+    def calculate(tariff_data)
+      validate_tariff_data(tariff_data)
+
+      response = @client.auth_connection.post(TARIFF_URL) do |req|
+        req.headers['Content-Type'] = 'application/json'
+        req.body = tariff_data.to_json
+      end
+      handle_response(response)
+    end
+
+    private
+
+    def validate_tariff_data(tariff_data)
+      raise 'tariff_data must be a Hash' unless tariff_data.is_a?(Entities::TariffData)
+    end
+
+    def handle_response(response)
+      @client.send(:handle_response, response)
+    end
+  end
+end

data/lib/cdek_api_client/track_order.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module CDEKApiClient
+  class TrackOrder
+    BASE_URL = ENV.fetch('CDEK_API_URL', 'https://api.edu.cdek.ru/v2')
+    TRACK_ORDER_URL = "#{BASE_URL}/orders/%<uuid>s".freeze
+
+    def initialize(client)
+      @client = client
+    end
+
+    def get(order_uuid)
+      validate_uuid(order_uuid)
+
+      response = @client.auth_connection.get(format(TRACK_ORDER_URL, uuid: order_uuid))
+      handle_response(response)
+    end
+
+    private
+
+    def validate_uuid(uuid)
+      @client.send(:validate_uuid, uuid)
+    end
+
+    def handle_response(response)
+      @client.send(:handle_response, response)
+    end
+  end
+end

data/lib/cdek_api_client/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CDEKApiClient
+  VERSION = '0.1.0'
+end

data/lib/cdek_api_client/webhook.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module CDEKApiClient
+  class Webhook
+    BASE_URL = ENV.fetch('CDEK_API_URL', 'https://api.edu.cdek.ru/v2')
+    WEBHOOKS_URL = "#{BASE_URL}/webhooks".freeze
+
+    def initialize(client)
+      @client = client
+    end
+
+    def register(webhook_data)
+      validate_webhook_data(webhook_data)
+
+      response = @client.auth_connection.post(WEBHOOKS_URL) do |req|
+        req.headers['Content-Type'] = 'application/json'
+        req.body = webhook_data.to_json
+      end
+      handle_response(response)
+    end
+
+    def list
+      response = @client.auth_connection.get(WEBHOOKS_URL) do |req|
+        req.headers['Content-Type'] = 'application/json'
+      end
+      handle_response(response)
+    end
+
+    def delete(webhook_id)
+      validate_uuid(webhook_id)
+
+      response = @client.auth_connection.delete("#{WEBHOOKS_URL}/#{webhook_id}") do |req|
+        req.headers['Content-Type'] = 'application/json'
+      end
+      handle_response(response)
+    end
+
+    private
+
+    def validate_webhook_data(webhook_data)
+      raise 'webhook_data must be a Webhook' unless webhook_data.is_a?(CDEKApiClient::Entities::Webhook)
+    end
+
+    def validate_uuid(uuid)
+      return if uuid.match?(/\A[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}\z/)
+
+      raise 'Invalid UUID format'
+    end
+
+    def handle_response(response)
+      @client.send(:handle_response, response)
+    end
+  end
+end

data/lib/cdek_api_client.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'cdek_api_client/client'
+require_relative 'cdek_api_client/order'
+require_relative 'cdek_api_client/track_order'
+require_relative 'cdek_api_client/tariff'
+require_relative 'cdek_api_client/version'
+require_relative 'cdek_api_client/location'
+require_relative 'cdek_api_client/webhook'
+require_relative 'cdek_api_client/entities/order_data'
+require_relative 'cdek_api_client/entities/location'
+require_relative 'cdek_api_client/entities/package'
+require_relative 'cdek_api_client/entities/recipient'
+require_relative 'cdek_api_client/entities/item'
+require_relative 'cdek_api_client/entities/validatable'
+require_relative 'cdek_api_client/entities/sender'
+require_relative 'cdek_api_client/entities/currency_mapper'
+require_relative 'cdek_api_client/entities/tariff_data'
+require_relative 'cdek_api_client/entities/payment'
+require_relative 'cdek_api_client/entities/service'
+require_relative 'cdek_api_client/entities/webhook'
+
+module CDEKApiClient
+  class Error < StandardError; end
+
+  class << self
+    def configure
+      yield self
+    end
+
+    attr_accessor :client_id, :client_secret
+  end
+
+  def self.client
+    @client ||= CDEKApiClient::Client.new(client_id, client_secret)
+  end
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: cdek_api_client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Damir Mukimov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-07-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.10.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.10.3
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+description: This gem provides a Ruby client for interacting with the CDEK API, including
+  order creation, tracking, and tariff calculation.
+email:
+- mukimov.d@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/cdek_api_client.rb
+- lib/cdek_api_client/client.rb
+- lib/cdek_api_client/entities/currency_mapper.rb
+- lib/cdek_api_client/entities/item.rb
+- lib/cdek_api_client/entities/location.rb
+- lib/cdek_api_client/entities/order_data.rb
+- lib/cdek_api_client/entities/package.rb
+- lib/cdek_api_client/entities/payment.rb
+- lib/cdek_api_client/entities/recipient.rb
+- lib/cdek_api_client/entities/sender.rb
+- lib/cdek_api_client/entities/service.rb
+- lib/cdek_api_client/entities/tariff_data.rb
+- lib/cdek_api_client/entities/validatable.rb
+- lib/cdek_api_client/entities/webhook.rb
+- lib/cdek_api_client/location.rb
+- lib/cdek_api_client/order.rb
+- lib/cdek_api_client/recipient.rb
+- lib/cdek_api_client/tariff.rb
+- lib/cdek_api_client/track_order.rb
+- lib/cdek_api_client/version.rb
+- lib/cdek_api_client/webhook.rb
+homepage: http://glowing-pixels.com/cdek_api_client
+licenses:
+- MIT
+metadata:
+  github_repo: git@github.com/SamyRai/cdek_api_client.git
+  homepage_uri: http://glowing-pixels.com/cdek_api_client
+  source_code_uri: http://github.com/SamyRai/cdek_api_client
+  changelog_uri: http://www.glowing-pixels.com/cdek_api_client/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key: 
+specification_version: 4
+summary: A Ruby client for the CDEK API
+test_files: []