notisend 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6089d5fa5baa971c293eb3aff9654bd97b0ddb8745c89e847025e7cdb0d9c067
+  data.tar.gz: 604e5b27507d629e5f1b99bcdb00a8f7186822b3e03e4b961080c7c82dd86f9c
+SHA512:
+  metadata.gz: bb95bf6b3ce3406387c2e235ffa03da81e4e6a20b9df4bac9813d039cf113b491a7b99563137e5a58a23f723411c708563b6d50c315291c87886cbf773094c17
+  data.tar.gz: 225db3327f3c7295f35d20af6dd5d493f9755d8c724bf11a3c6c9680b0851916c99361a88910fdc84881eccb7b58daa3657cfdd220485b06b7609733a90f48d9

data/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-08-12
+
+### Added
+
+- Full coverage of the Notisend email API: balance, messages, templates, lists,
+  parameters, recipients (incl. bulk import and search), segments, organizations,
+  campaigns, webhooks
+- Instance client with per-instance options and a global default client
+  (`Notisend.configure` / `Notisend.client`)
+- Pagination via `Notisend::Collection` with `next_page` and `auto_paging_each`
+- Typed error hierarchy with `retry_after` on 429 responses
+- Multipart attachments support for messages, template messages and campaigns
+- Custom SSL support: `verify_ssl`, `ca_bundle_file` (+ ENV overrides)
+- Reserve base URL constant (`Notisend::RESERVE_BASE_URL`) for RKN-restricted IPs
+- GET-only automatic retries on connection failures; POST is never retried

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Aleksandr Dryzhuk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,298 @@
+# Notisend
+
+[![Gem Version](https://badge.fury.io/rb/notisend.svg)](https://rubygems.org/gems/notisend)
+
+Full-coverage Ruby client for the [Notisend email API](https://notisend.ru/dev/email/api/):
+single messages, templates, recipient lists, parameters, recipients (including bulk import
+and search), segments, organizations, campaigns, webhooks and balance.
+
+Built on Faraday 2.x. Ruby 3.4+ (developed against Ruby 4.0).
+
+Based on stale [notisend-ruby](https://github.com/evserykh/notiesend-ruby) repo.
+
+## Installation
+
+```bash
+bundle add notisend
+```
+
+Or in your Gemfile:
+
+```ruby
+gem 'notisend'
+```
+
+## Configuration
+
+Configure once globally (e.g. in a Rails initializer):
+
+```ruby
+Notisend.configure do |config|
+  config.api_token = 'your-api-token'          # default: ENV['NOTISEND_API_TOKEN']
+  # config.base_url = Notisend::RESERVE_BASE_URL # alternate URL, see below
+  # config.open_timeout = 10                     # seconds
+  # config.timeout = 30                          # seconds
+  # config.verify_ssl = true                     # default: true
+  # config.ca_bundle_file = '/path/to/ca.pem'    # custom CA bundle
+  # config.logger = Logger.new($stdout)          # logs method/path/status, never the token
+end
+
+Notisend.client.balance.get
+```
+
+Or build explicit client instances (each option falls back to the global config):
+
+```ruby
+client = Notisend::Client.new(api_token: 'other-token')
+other  = Notisend::Client.new(api_token: 'second-account', base_url: Notisend::RESERVE_BASE_URL)
+```
+
+### Environment variables
+
+| Variable                  | Meaning                                                 |
+| ------------------------- | ------------------------------------------------------- |
+| `NOTISEND_API_TOKEN`      | API token (used when `api_token` is not set explicitly) |
+| `NOTISEND_VERIFY_SSL`     | Set to `'false'` to disable SSL verification            |
+| `NOTISEND_CA_BUNDLE_FILE` | Path to a custom CA bundle file                         |
+
+### Alternate base URL
+
+If your IP is blocked or restricted (RKN), use the reserve endpoint:
+
+```ruby
+Notisend.configure { |c| c.base_url = Notisend::RESERVE_BASE_URL } # https://api-reserve.msndr.net/v1
+```
+
+### Custom SSL certificates
+
+For environments with a custom certificate chain (e.g. Russian MinTsifra CA or a corporate
+proxy), point the client at your CA bundle:
+
+```ruby
+Notisend.configure do |config|
+  config.ca_bundle_file = '/usr/local/share/ca-certificates/russian_trusted_ca.pem'
+end
+```
+
+SSL verification stays on by default; `Faraday::SSLError` is raised as `Notisend::SSLError`.
+
+## Usage
+
+All methods return parsed JSON as plain hashes with string keys. Paginated endpoints
+return a `Notisend::Collection` (see Pagination below).
+
+### Balance
+
+```ruby
+client.balance.get # => { 'tariff' => {...}, 'balance' => 12965.96 }
+```
+
+### Messages
+
+```ruby
+message = client.messages.deliver(
+  from_email: 'alice@example.org',
+  to: 'bob@example.org',
+  subject: 'Hello',
+  text: 'Hello, Bob!',
+  html: '<h1>Hello, Bob!</h1>',            # text and/or html is required
+  from_name: 'Alice',                       # optional
+  payment: 'credit',                        # optional: subscriber_priority (default),
+                                            #   credit_priority, subscriber, credit
+  smtp_headers: { 'Client-Id' => '123' },   # optional
+  attachments: ['/path/to/file.pdf']        # optional: paths and/or IO objects, total <= 5 MB
+)
+
+client.messages.get(id: message['id']) # => includes 'status' and 'events'
+```
+
+### Templates
+
+```ruby
+template = client.templates.create(from_email: 'hello@world.com', subject: 'Hello [%name%]',
+                                   html: '<h1>Hello [%name%]</h1>', preset_params: ['name'])
+client.templates.to_pending(id: template['id'])  # submit for moderation
+client.templates.list
+client.templates.get(id: template['id'])
+
+client.templates.deliver(template_id: template['id'], to: 'bob@example.org',
+                         params: { 'name' => 'Bob' }, attachments: ['/path/to/file.pdf'])
+```
+
+### Lists (recipient groups)
+
+```ruby
+list = client.lists.create(title: 'My Recipients')
+client.lists.list(page_number: 1, page_size: 100)
+client.lists.get(id: list['id'])
+client.lists.update(id: list['id'], title: 'New Title')
+client.lists.delete(id: list['id']) # => true
+```
+
+### List parameters
+
+```ruby
+param = client.parameters.create(list_id: list['id'], title: 'Age', kind: 'numeric')
+# kinds: string (default), numeric, date, boolean, geo
+client.parameters.list(list_id: list['id'])
+client.parameters.update(list_id: list['id'], id: param['id'], title: 'Years')
+client.parameters.delete(list_id: list['id'], id: param['id']) # => true
+```
+
+### Recipients
+
+```ruby
+recipient = client.recipients.create(
+  list_id: list['id'],
+  email: 'alice@example.org',
+  values: [{ parameter_id: param['id'], value: '22' }], # optional
+  tags: ['buyer'],                                      # optional
+  unconfirmed: true                                     # optional
+)
+
+client.recipients.get(list_id: list['id'], id: recipient['id'])
+client.recipients.update(list_id: list['id'], id: recipient['id'],
+                         email: 'alice@example.org',
+                         values: [{ parameter_id: param['id'], destroy: 'true' }])
+client.recipients.list(list_id: list['id'], page_size: 1000)
+client.recipients.delete(list_id: list['id'], id: recipient['id']) # => true
+
+# Bulk import (up to 10_000 recipients per call)
+import = client.recipients.import(
+  list_id: list['id'],
+  recipients: [
+    { email: 'alice@example.org', values: [{ parameter_id: param['id'], value: '22' }] },
+    { email: 'bob@example.org' }
+  ],
+  run_triggers: 'trigger_fresh',                 # optional: trigger_any | trigger_fresh
+  callback_url: 'https://my.app/import-callback' # optional
+)
+import['status'] # => 'queued'
+
+# Find which lists contain an email
+client.recipients.search(email: 'alice@example.org')
+```
+
+### Segments
+
+```ruby
+client.segments.list
+```
+
+### Organizations
+
+```ruby
+org = client.organizations.create(name: 'My Organization', address: 'Lenina 40',
+                                  country: 'Russia', city: 'Tomsk',
+                                  phone: '+7-3822-123-456', zip: '634000')
+client.organizations.list
+client.organizations.get(id: org['id'])
+client.organizations.current              # default organization
+client.organizations.set_current(id: org['id'])
+client.organizations.update(id: org['id'], city: 'Moscow')
+client.organizations.delete(id: org['id']) # => true
+```
+
+### Campaigns
+
+```ruby
+campaign = client.campaigns.create(
+  from_email: 'hello@world.com',
+  subject: 'Hello World',
+  html: '<h1>Hello World</h1>',
+  lists: [{ id: list['id'] }],   # or segment_id: 5
+  attachments: ['/path/to/file'] # optional
+)
+
+client.campaigns.deliver(id: campaign['id'])                 # send now
+client.campaigns.schedule(id: campaign['id'],                # or send later
+                          start_at: '30.10.2022 13:00', time_zone: 'Moscow')
+client.campaigns.list(statistic: false)                      # statistic: false is much faster
+client.campaigns.get(id: campaign['id'])
+```
+
+### Webhooks
+
+```ruby
+hook = client.webhooks.create(title: 'Delivery hooks', url: 'https://my.app/webhook',
+                              kinds: ['api'], events: %w[delivered hard_bounced])
+client.webhooks.list
+client.webhooks.get(id: hook['id'])
+client.webhooks.update(id: hook['id'], status: 'inactive')
+client.webhooks.delete(id: hook['id']) # => deleted webhook hash
+
+client.webhooks.kinds  # => { 'kinds' => ['campaign', 'campaign_transactional', ...] }
+client.webhooks.events # => { 'events' => ['delivered', 'opened', ...] }
+```
+
+## Pagination
+
+Endpoints that return collections are wrapped in `Notisend::Collection`:
+
+```ruby
+lists = client.lists.list(page_size: 50)
+lists.total_count   # => 123
+lists.total_pages   # => 3
+lists.page_number   # => 1
+lists.each { |l| puts l['title'] }          # Enumerable over the current page
+lists.next_page                             # => Collection or nil
+
+lists.auto_paging_each { |l| puts l['title'] } # lazily walks ALL pages
+client.lists.list.auto_paging_each.map { |l| l['id'] } # as an Enumerator
+```
+
+The raw response envelope (including non-standard keys like `query` in recipient search)
+is available via `collection.raw`.
+
+## Error handling
+
+All errors inherit from `Notisend::Error`:
+
+| Class                           | Raised on                             |
+| ------------------------------- | ------------------------------------- |
+| `Notisend::ConfigurationError`  | Missing API token                     |
+| `Notisend::SSLError`            | SSL verification failure              |
+| `Notisend::ConnectionError`     | Network failure / timeout             |
+| `Notisend::ApiError`            | Any non-2xx API response (base class) |
+| `Notisend::BadRequest`          | 400                                   |
+| `Notisend::Unauthorized`        | 401                                   |
+| `Notisend::Forbidden`           | 403                                   |
+| `Notisend::NotFound`            | 404                                   |
+| `Notisend::PreconditionFailed`  | 412 (e.g. `page_size` over the limit) |
+| `Notisend::UnprocessableEntity` | 422                                   |
+| `Notisend::TooManyRequests`     | 429 (rate limit)                      |
+| `Notisend::ServerError`         | 5xx                                   |
+
+```ruby
+begin
+  client.messages.deliver(from_email: 'a@b.c', to: 'x@y.z', subject: 'Hi', text: 'Hello')
+rescue Notisend::TooManyRequests => e
+  sleep(e.retry_after || 60) # parsed from 'Try again in N seconds'
+  retry
+rescue Notisend::ApiError => e
+  e.status # => HTTP status
+  e.detail # => first error detail from the response
+  e.errors # => full parsed errors array
+end
+```
+
+GET requests are automatically retried (twice) on connection failures and timeouts.
+POST requests are never retried — a delivery must not be sent twice.
+
+## Development
+
+```bash
+bundle install
+bundle exec rake test     # tests
+bundle exec rubocop       # lint
+bundle exec rake          # both
+bin/console               # interactive console
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome at <https://github.com/amdest/notisend>.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/notisend/client.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Notisend
+  # HTTP core: builds Faraday connections, executes requests, maps errors
+  class Client
+    RETRY_OPTIONS = {
+      max: 2, interval: 0.2, backoff_factor: 2, methods: %i[get],
+      exceptions: [Faraday::TimeoutError, Faraday::ConnectionFailed, 'Timeout::Error', Errno::ETIMEDOUT]
+    }.freeze
+    DEFAULT_MIME_TYPE = 'application/octet-stream'
+
+    attr_reader :base_url
+
+    def initialize(api_token: nil, base_url: nil, open_timeout: nil, timeout: nil,
+                   verify_ssl: nil, ca_bundle_file: nil, logger: nil)
+      defaults = Notisend.configuration
+      @api_token = api_token || defaults.api_token
+      @base_url = base_url || defaults.base_url
+      @open_timeout = open_timeout || defaults.open_timeout
+      @timeout = timeout || defaults.timeout
+      @verify_ssl = verify_ssl.nil? ? defaults.verify_ssl : verify_ssl
+      @ca_bundle_file = ca_bundle_file || defaults.ca_bundle_file
+      @logger = logger || defaults.logger
+      ensure_token!
+    end
+
+    def balance = @balance ||= Resources::Balance.new(self)
+    def messages = @messages ||= Resources::Messages.new(self)
+    def templates = @templates ||= Resources::Templates.new(self)
+    def lists = @lists ||= Resources::Lists.new(self)
+    def parameters = @parameters ||= Resources::Parameters.new(self)
+    def recipients = @recipients ||= Resources::Recipients.new(self)
+    def segments = @segments ||= Resources::Segments.new(self)
+    def organizations = @organizations ||= Resources::Organizations.new(self)
+    def campaigns = @campaigns ||= Resources::Campaigns.new(self)
+    def webhooks = @webhooks ||= Resources::Webhooks.new(self)
+
+    def get(path, params = {})
+      run_request { connection.get(path, params.compact) }
+    end
+
+    def post(path, payload = {}, attachments: nil)
+      files = Array(attachments)
+      return run_request { connection.post(path, payload) } if files.empty?
+
+      body = payload.merge(attachments: files.map { |a| file_part(a) })
+      run_request { multipart_connection.post(path, body) }
+    end
+
+    def patch(path, payload = {})
+      run_request { connection.patch(path, payload) }
+    end
+
+    def delete(path)
+      run_request { connection.delete(path) }
+    end
+
+    private
+
+    attr_reader :api_token, :open_timeout, :timeout, :verify_ssl, :ca_bundle_file, :logger
+
+    def ensure_token!
+      return unless api_token.nil? || api_token.strip.empty?
+
+      raise ConfigurationError, 'Notisend API token is missing: set NOTISEND_API_TOKEN, ' \
+                                'use Notisend.configure, or pass api_token:'
+    end
+
+    def connection
+      @connection ||= build_connection do |f|
+        f.request :json
+        f.request :retry, RETRY_OPTIONS
+      end
+    end
+
+    def multipart_connection
+      @multipart_connection ||= build_connection do |f|
+        f.request :multipart
+        f.request :url_encoded
+      end
+    end
+
+    def file_part(attachment)
+      if attachment.respond_to?(:read)
+        name = attachment.respond_to?(:path) ? File.basename(attachment.path) : 'attachment'
+        Faraday::Multipart::FilePart.new(attachment, DEFAULT_MIME_TYPE, name)
+      else
+        Faraday::Multipart::FilePart.new(attachment.to_s, DEFAULT_MIME_TYPE)
+      end
+    end
+
+    def build_connection
+      Faraday.new(url: url_prefix) do |f|
+        f.headers['Authorization'] = "Bearer #{api_token}"
+        f.headers['User-Agent'] = "notisend/#{VERSION}"
+        f.options.open_timeout = open_timeout
+        f.options.timeout = timeout
+        f.ssl.verify = verify_ssl
+        f.ssl.ca_file = ca_bundle_file if ca_bundle_file
+        yield(f)
+        f.response :logger, logger, headers: false, bodies: false if logger
+        f.adapter Faraday.default_adapter
+      end
+    end
+
+    # trailing slash keeps the /v1 path segment when Faraday joins request paths
+    def url_prefix
+      "#{base_url.chomp('/')}/"
+    end
+
+    def run_request
+      handle(yield)
+    rescue Faraday::SSLError => e
+      raise SSLError, "SSL verification failed: #{e.message}"
+    rescue Faraday::TimeoutError, Faraday::ConnectionFailed => e
+      raise ConnectionError, "Connection to Notisend API failed: #{e.message}"
+    end
+
+    def handle(response)
+      raise ApiError.for(status: response.status, body: response.body) unless (200..299).cover?(response.status)
+      return true if response.status == 204 || response.body.to_s.strip.empty?
+
+      JSON.parse(response.body)
+    rescue JSON::ParserError
+      raise Error, "Notisend API returned invalid JSON (status #{response.status})"
+    end
+  end
+end

data/lib/notisend/collection.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Notisend
+  # Wraps paginated API responses; re-fetches further pages through the block
+  class Collection
+    include Enumerable
+
+    attr_reader :raw
+
+    def initialize(raw, &fetch_page)
+      @raw = raw
+      @fetch_page = fetch_page
+    end
+
+    def items = Array(raw['collection'])
+    def total_count = raw['total_count']
+    def total_pages = raw['total_pages']
+    def page_number = raw['page_number']
+    def page_size = raw['page_size']
+
+    def each(&) = items.each(&)
+
+    def next_page?
+      !!(page_number && total_pages && page_number < total_pages)
+    end
+
+    def next_page
+      return unless next_page? && @fetch_page
+
+      @fetch_page.call(page_number + 1)
+    end
+
+    def auto_paging_each(&block)
+      return enum_for(:auto_paging_each) unless block
+
+      page = self
+      while page
+        page.each(&block)
+        page = page.next_page
+      end
+    end
+  end
+end

data/lib/notisend/configuration.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Notisend
+  # Holds client settings; every option can be overridden per Client instance
+  class Configuration
+    DEFAULT_BASE_URL = 'https://api.notisend.ru/v1'
+
+    attr_accessor :api_token, :base_url, :open_timeout, :timeout, :verify_ssl, :ca_bundle_file, :logger
+
+    def initialize
+      @api_token = ENV.fetch('NOTISEND_API_TOKEN', nil)
+      @base_url = DEFAULT_BASE_URL
+      @open_timeout = 10
+      @timeout = 30
+      @verify_ssl = ENV.fetch('NOTISEND_VERIFY_SSL', 'true') != 'false'
+      @ca_bundle_file = ENV.fetch('NOTISEND_CA_BUNDLE_FILE', nil)
+      @logger = nil
+    end
+  end
+end

data/lib/notisend/errors.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Notisend
+  class Error < StandardError
+  end
+
+  class ConfigurationError < Error
+  end
+
+  class SSLError < Error
+  end
+
+  class ConnectionError < Error
+  end
+
+  # Non-2xx API response. Body format: {"errors":[{"code":..,"detail":".."}]}
+  class ApiError < Error
+    STATUS_MAP = {
+      400 => 'Notisend::BadRequest',
+      401 => 'Notisend::Unauthorized',
+      403 => 'Notisend::Forbidden',
+      404 => 'Notisend::NotFound',
+      412 => 'Notisend::PreconditionFailed',
+      422 => 'Notisend::UnprocessableEntity',
+      429 => 'Notisend::TooManyRequests'
+    }.freeze
+
+    attr_reader :status, :errors
+
+    def self.for(status:, body:)
+      klass_name = STATUS_MAP[status] || ((500..599).cover?(status) ? 'Notisend::ServerError' : name)
+      Object.const_get(klass_name).new(status: status, body: body)
+    end
+
+    def initialize(status:, body:)
+      @status = status
+      @errors = parse_errors(body)
+      super(detail || "Notisend API error (status #{status})")
+    end
+
+    def detail
+      errors.first&.fetch('detail', nil)
+    end
+
+    private
+
+    def parse_errors(body)
+      return [] if body.nil? || (body.respond_to?(:empty?) && body.empty?)
+
+      parsed = body.is_a?(String) ? JSON.parse(body) : body
+      parsed.is_a?(Hash) ? Array(parsed['errors']) : []
+    rescue JSON::ParserError
+      [{ 'code' => status, 'detail' => body.to_s }]
+    end
+  end
+
+  class BadRequest < ApiError
+  end
+
+  class Unauthorized < ApiError
+  end
+
+  class Forbidden < ApiError
+  end
+
+  class NotFound < ApiError
+  end
+
+  class PreconditionFailed < ApiError
+  end
+
+  class UnprocessableEntity < ApiError
+  end
+
+  class ServerError < ApiError
+  end
+
+  # 429: exposes the server-suggested wait extracted from the detail text
+  class TooManyRequests < ApiError
+    def retry_after
+      match = detail&.match(/(\d+) seconds?/)
+      match && match[1].to_i
+    end
+  end
+end

data/lib/notisend/resources/balance.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Notisend
+  module Resources
+    # Account balance: GET /email/balance
+    class Balance < Base
+      def get
+        client.get(email_path('balance'))
+      end
+    end
+  end
+end

data/lib/notisend/resources/base.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Notisend
+  module Resources
+    # Shared plumbing for API resources
+    class Base
+      def initialize(client)
+        @client = client
+      end
+
+      private
+
+      attr_reader :client
+
+      def email_path(*segments)
+        ['email', *segments].join('/')
+      end
+
+      def paginated(path, params = {})
+        params = params.compact
+        response = client.get(path, params)
+        Collection.new(response) { |page| paginated(path, params.merge(page_number: page)) }
+      end
+
+      def page_params(page_number: nil, page_size: nil)
+        { page_number: page_number, page_size: page_size }.compact
+      end
+    end
+  end
+end

data/lib/notisend/resources/campaigns.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Notisend
+  module Resources
+    # Bulk campaigns: /email/campaigns
+    class Campaigns < Base
+      def create(from_email:, subject:, html:, text: nil, from_name: nil,
+                 lists: nil, segment_id: nil, attachments: nil)
+        payload = { from_email:, subject:, html:, text:, from_name:, lists:, segment_id: }.compact
+        client.post(email_path('campaigns'), payload, attachments: attachments)
+      end
+
+      def deliver(id:)
+        client.patch(email_path('campaigns', id, 'deliver'))
+      end
+
+      def schedule(id:, start_at: nil, time_zone: nil)
+        client.patch(email_path('campaigns', id, 'schedule'), { start_at:, time_zone: }.compact)
+      end
+
+      def list(statistic: nil, page_number: nil, page_size: nil)
+        params = { statistic: }.compact.merge(page_params(page_number:, page_size:))
+        paginated(email_path('campaigns'), params)
+      end
+
+      def get(id:)
+        client.get(email_path('campaigns', id))
+      end
+    end
+  end
+end

data/lib/notisend/resources/lists.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Notisend
+  module Resources
+    # Recipient lists (groups): /email/lists
+    class Lists < Base
+      def create(title:)
+        client.post(email_path('lists'), { title: })
+      end
+
+      def list(page_number: nil, page_size: nil)
+        paginated(email_path('lists'), page_params(page_number:, page_size:))
+      end
+
+      def get(id:)
+        client.get(email_path('lists', id))
+      end
+
+      def update(id:, title:)
+        client.patch(email_path('lists', id), { title: })
+      end
+
+      def delete(id:)
+        client.delete(email_path('lists', id))
+      end
+    end
+  end
+end

data/lib/notisend/resources/messages.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Notisend
+  module Resources
+    # Single email messages: POST /email/messages, GET /email/messages/:id
+    class Messages < Base
+      def deliver(from_email:, to:, subject:, text: nil, html: nil, from_name: nil,
+                  payment: nil, smtp_headers: nil, attachments: nil)
+        payload = { from_email:, to:, subject:, text:, html:, from_name:,
+                    payment:, smtp_headers: }.compact
+        client.post(email_path('messages'), payload, attachments: attachments)
+      end
+
+      def get(id:)
+        client.get(email_path('messages', id))
+      end
+    end
+  end
+end

data/lib/notisend/resources/organizations.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Notisend
+  module Resources
+    # Sender organizations: /email/organizations
+    class Organizations < Base
+      def create(name:, address:, country:, city:, phone:, zip:)
+        client.post(email_path('organizations'), { name:, address:, country:, city:, phone:, zip: })
+      end
+
+      def list(page_number: nil, page_size: nil)
+        paginated(email_path('organizations'), page_params(page_number:, page_size:))
+      end
+
+      def get(id:)
+        client.get(email_path('organizations', id))
+      end
+
+      def current
+        client.get(email_path('organizations', 'current'))
+      end
+
+      def set_current(id:)
+        client.patch(email_path('organizations', id, 'current'))
+      end
+
+      def update(id:, name: nil, address: nil, country: nil, city: nil, phone: nil, zip: nil)
+        payload = { name:, address:, country:, city:, phone:, zip: }.compact
+        client.patch(email_path('organizations', id), payload)
+      end
+
+      def delete(id:)
+        client.delete(email_path('organizations', id))
+      end
+    end
+  end
+end

data/lib/notisend/resources/parameters.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Notisend
+  module Resources
+    # List parameters: /email/lists/:list_id/parameters
+    class Parameters < Base
+      def create(list_id:, title:, kind: nil)
+        client.post(email_path('lists', list_id, 'parameters'), { title:, kind: }.compact)
+      end
+
+      def list(list_id:, page_number: nil, page_size: nil)
+        paginated(email_path('lists', list_id, 'parameters'), page_params(page_number:, page_size:))
+      end
+
+      def update(list_id:, id:, title: nil, kind: nil)
+        client.patch(email_path('lists', list_id, 'parameters', id), { title:, kind: }.compact)
+      end
+
+      def delete(list_id:, id:)
+        client.delete(email_path('lists', list_id, 'parameters', id))
+      end
+    end
+  end
+end

data/lib/notisend/resources/recipients.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Notisend
+  module Resources
+    # List recipients: /email/lists/:list_id/recipients (+ global /email/recipients/search)
+    class Recipients < Base
+      def create(list_id:, email:, values: nil, tags: nil, unconfirmed: nil)
+        payload = { email:, values:, tags:, unconfirmed: }.compact
+        client.post(email_path('lists', list_id, 'recipients'), payload)
+      end
+
+      def get(list_id:, id:)
+        client.get(email_path('lists', list_id, 'recipients', id))
+      end
+
+      def update(list_id:, id:, email:, values: nil, tags: nil, run_triggers: nil)
+        payload = { email:, values:, tags:, run_triggers: }.compact
+        client.patch(email_path('lists', list_id, 'recipients', id), payload)
+      end
+
+      def list(list_id:, page_number: nil, page_size: nil)
+        paginated(email_path('lists', list_id, 'recipients'), page_params(page_number:, page_size:))
+      end
+
+      def delete(list_id:, id:)
+        client.delete(email_path('lists', list_id, 'recipients', id))
+      end
+
+      def import(list_id:, recipients:, run_triggers: nil, tags: nil, callback_url: nil)
+        payload = { recipients:, run_triggers:, tags:, callback_url: }.compact
+        client.post(email_path('lists', list_id, 'recipients', 'imports'), payload)
+      end
+
+      def search(email:, page_number: nil, page_size: nil)
+        params = { email: }.merge(page_params(page_number:, page_size:))
+        paginated(email_path('recipients', 'search'), params)
+      end
+    end
+  end
+end

data/lib/notisend/resources/segments.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Notisend
+  module Resources
+    # Segments: GET /email/segments
+    class Segments < Base
+      def list(page_number: nil, page_size: nil)
+        paginated(email_path('segments'), page_params(page_number:, page_size:))
+      end
+    end
+  end
+end

data/lib/notisend/resources/templates.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Notisend
+  module Resources
+    # Email templates and template-based sending: /email/templates
+    class Templates < Base
+      def create(from_email:, subject:, html:, text: nil, from_name: nil, name: nil, preset_params: nil)
+        payload = { from_email:, subject:, html:, text:, from_name:, name:, preset_params: }.compact
+        client.post(email_path('templates'), payload)
+      end
+
+      def list(page_number: nil, page_size: nil)
+        paginated(email_path('templates'), page_params(page_number:, page_size:))
+      end
+
+      def get(id:)
+        client.get(email_path('templates', id))
+      end
+
+      def to_pending(id:)
+        client.patch(email_path('templates', id, 'to_pending'))
+      end
+
+      def deliver(template_id:, to:, params: nil, payment: nil, attachments: nil)
+        payload = { to:, params:, payment: }.compact
+        client.post(email_path('templates', template_id, 'messages'), payload, attachments: attachments)
+      end
+    end
+  end
+end

data/lib/notisend/resources/webhooks.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Notisend
+  module Resources
+    # Message webhooks: /email/messages_webhooks
+    class Webhooks < Base
+      def create(title:, url:, kinds:, events:)
+        client.post(email_path('messages_webhooks'), { title:, url:, kinds:, events: })
+      end
+
+      def list(page_number: nil, page_size: nil)
+        paginated(email_path('messages_webhooks'), page_params(page_number:, page_size:))
+      end
+
+      def get(id:)
+        client.get(email_path('messages_webhooks', id))
+      end
+
+      def update(id:, title: nil, url: nil, kinds: nil, events: nil, status: nil)
+        payload = { title:, url:, kinds:, events:, status: }.compact
+        client.patch(email_path('messages_webhooks', id), payload)
+      end
+
+      def delete(id:)
+        client.delete(email_path('messages_webhooks', id))
+      end
+
+      def kinds
+        client.get(email_path('messages_webhooks', 'kinds'))
+      end
+
+      def events
+        client.get(email_path('messages_webhooks', 'events'))
+      end
+    end
+  end
+end

data/lib/notisend/version.rb

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

data/lib/notisend.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'faraday/multipart'
+require 'faraday/retry'
+require 'json'
+
+require_relative 'notisend/version'
+require_relative 'notisend/errors'
+require_relative 'notisend/configuration'
+require_relative 'notisend/collection'
+require_relative 'notisend/client'
+require_relative 'notisend/resources/base'
+require_relative 'notisend/resources/balance'
+require_relative 'notisend/resources/messages'
+require_relative 'notisend/resources/templates'
+require_relative 'notisend/resources/lists'
+require_relative 'notisend/resources/parameters'
+require_relative 'notisend/resources/recipients'
+require_relative 'notisend/resources/segments'
+require_relative 'notisend/resources/organizations'
+require_relative 'notisend/resources/campaigns'
+require_relative 'notisend/resources/webhooks'
+
+# Ruby client for the Notisend email API (https://notisend.ru/dev/email/api/)
+module Notisend
+  RESERVE_BASE_URL = 'https://api-reserve.msndr.net/v1'
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration) if block_given?
+      configuration
+    end
+
+    def client
+      @client ||= Client.new
+    end
+
+    def reset
+      @configuration = nil
+      @client = nil
+    end
+  end
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: notisend
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Aleksandr Dryzhuk
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.13'
+- !ruby/object:Gem::Dependency
+  name: faraday-multipart
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: faraday-retry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+description: 'Full-coverage Ruby client for the Notisend email API: single messages,
+  templates, recipient lists, parameters, recipients, segments, organizations, campaigns,
+  webhooks and balance. Faraday-based, with pagination helpers, typed errors and custom
+  SSL certificate support.'
+email:
+- dev@ad-it.pro
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/notisend.rb
+- lib/notisend/client.rb
+- lib/notisend/collection.rb
+- lib/notisend/configuration.rb
+- lib/notisend/errors.rb
+- lib/notisend/resources/balance.rb
+- lib/notisend/resources/base.rb
+- lib/notisend/resources/campaigns.rb
+- lib/notisend/resources/lists.rb
+- lib/notisend/resources/messages.rb
+- lib/notisend/resources/organizations.rb
+- lib/notisend/resources/parameters.rb
+- lib/notisend/resources/recipients.rb
+- lib/notisend/resources/segments.rb
+- lib/notisend/resources/templates.rb
+- lib/notisend/resources/webhooks.rb
+- lib/notisend/version.rb
+homepage: https://github.com/amdest/notisend
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/amdest/notisend
+  source_code_uri: https://github.com/amdest/notisend
+  changelog_uri: https://github.com/amdest/notisend/blob/master/CHANGELOG.md
+  documentation_uri: https://github.com/amdest/notisend/blob/master/README.md
+  bug_tracker_uri: https://github.com/amdest/notisend/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.18
+specification_version: 4
+summary: Ruby client for the Notisend email API
+test_files: []