sms_traffic_sdk 0.0.8 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d03f7cface745a7a9ea2df32398b6e295e62c8efc48cf90e41f6eb73624f387
-  data.tar.gz: da2123261e9a4949ba122819135feb6faed7a7ea82006871fb70bc31a12a0c23
+  metadata.gz: 7073f3fdf9537cf98008d5c6fac2bbc28457fbe4ef05852ccfd4e3b3a4606fbc
+  data.tar.gz: 7ad131b8ca90beebf7d4e227fa4031655bdc49d7e5db4f12c7ee11763cde8e0a
 SHA512:
-  metadata.gz: 915582d8ba488e04028588e4b7461ad0c286f74ecc191a397ba600b0a4e3f346199b79f04d9097de837493a12a481451685ff93375979fc72421c9b80b747704
-  data.tar.gz: 6af993a023313a727cf90ae0774fd81646e588ebab585273ac67e2b037a5edd50402889f4d0984586af94f2c74451c594e0a1560e277cbb8c47f8bce03e6b33d
+  metadata.gz: f22009b2e84816ea0ad7294fd80ec8810dfc99c4ad46a7c66e9f9604f837c31fe5d6ae996639e776cb79501523b50257d20390069412993c704b2456ed3b5fb7
+  data.tar.gz: 4dc45cb30d25dd521d716f16bcb7a4ae530ee9fa3b8d14f0b8ec0cfde6a479c81d41268b1015a7518bdd16d79a11fc4f8c5663d2e8266dc7f34c1d0415202843

data/CHANGELOG.md

@@ -0,0 +1,87 @@
+# Changelog
+
+## 0.2.0 - 2026-11-03
+
+### Added
+
+- `Configuration#fallback_host` (default `nil`). When set, the client repeats a request once on that host after a
+  connection failure that proves the server was not reached (`SocketError`, `Errno::ECONNREFUSED`,
+  `Errno::EHOSTUNREACH`, `Errno::ENETUNREACH`, `Net::OpenTimeout`) or after API error 1000. `Client.status` and
+  `Client.balance` also retry after any `ConnectionError` and HTTP 5xx; `Client.deliver` never does, because the
+  provider may already have queued the SMS. With `debug`, the retry is logged in one line without credentials.
+- `Client.balance` returns an `AccountReply`; `AccountReply#balance` is a `BigDecimal` (units as sent by the
+  provider). `bigdecimal` is a runtime dependency.
+- `SmsTraffic::Status` (`FINAL`, `INTERMEDIATE`), `StatusReply::Entry#final?` / `#delivered?`, the same methods on
+  `StatusReply` (optional `sms_id`) and `Sms#final?` / `#delivered?`.
+- `ApiError#retryable?`, `#access_denied?`, `#insufficient_funds?` and `#blocked_phone?`.
+
+### Fixed
+
+- A provider reply with `<result>ERRO</result>` (the spelling in the provider's own example) is now an
+  `ApiError`. `Reply#api_error?` is true for any present `result` other than `OK`.
+- `Sms#update_status` no longer records "No status returned" for an empty `<status>` element (an intermediate
+  provider status); the status stays `sent`. `StatusReply::Entry#status_reported?` tells an empty status from an
+  absent one.
+
+## 0.1.0 - 2026-11-03
+
+### Breaking changes
+
+- Ruby 3.1 or newer is required.
+- Zeitwerk is no longer a dependency; files are loaded with `require_relative`.
+- `SmsTraffic::Configuration` is a plain class, not a `Singleton`. Defaults changed: `logger` is `nil` (was `$stdout`),
+  new `open_timeout` (10) and `read_timeout` (30). `originator` is no longer required by `configure`.
+  `Configuration#values_at` is removed.
+- `SmsTraffic::Client::Response` is removed. `Client.deliver` returns a `DeliverReply` and `Client.status` a
+  `StatusReply` directly, and raise `SmsTraffic::ConnectionError`, `SmsTraffic::HttpError` or `SmsTraffic::ApiError`
+  (all `SmsTraffic::Error`) instead of returning a failed response.
+- `Reply#hash` no longer returns the parsed reply (it is `Object#hash` again); use `Reply#to_h`.
+- `DeliverReply#ok?` is strictly boolean and requires a queued message. `#sms_ids` is an Array of every sms id (it was
+  a Hash keyed by phone). `#message_infos` is replaced by `#messages`. `#error_description` reads
+  `"Sms has not been enqueued: <description>"`.
+- `StatusReply#sms_array` is replaced by `#entries` (`StatusReply::Entry`); `#entry`, `#error?`, `#not_found?`
+  and `#send_date` are new.
+- `Sms#response` is replaced by `Sms#reply`. `Sms#update_status` always returns the status String, and `Sms#deliver`
+  records `SmsTraffic::Error`s in `errors` instead of the HTTP code.
+- The `konsierge-sms.rb` executable is removed.
+- The default XML parser no longer typecasts (`Nori.new(advanced_typecasting: false)`): dates and `true` stay
+  provider strings.
+- `nori` 2.8 or newer is required.
+
+### Fixed
+
+- `Sms` phone validation no longer accepts a newline-separated value (`\A`/`\z` anchors).
+- `Client.status` with several ids sends a flat comma-separated `sms_id` list.
+- The client builds its URI from the current `host` on every request instead of memoizing the first one.
+- `open_timeout` and `read_timeout` are applied to every request.
+- `Reply` no longer mutates (or fails on) frozen input.
+- A multi-part SMS keeps every `sms_id`; a single `<message_info>` with a phone is parsed.
+- `require 'sms_traffic_sdk'` works with `Bundler.require`.
+- Loading the gem without a preloaded `StringIO` no longer fails with `NameError` (nori 2.7.0 missed
+  `require 'stringio'`; fixed in nori 2.8).
+
+### Changed
+
+- CI runs lint and RSpec on Ruby 3.1-3.4, smoke-tests the built gem in a clean Ruby process, uploads Cobertura
+  coverage to Codecov, and publishes to RubyGems through trusted publishing (OIDC) from a published release whose tag
+  matches the gem version. The gem package contains only `lib`, `README.md`, `LICENSE` and `CHANGELOG.md`.
+
+### Security
+
+- `Net::HTTP#set_debug_output` is no longer used, so the login, password and SMS text are never written to the logger.
+  Debug logging emits one request line with `login`, `password` and `message` filtered, and one response line with
+  the HTTP status and body size only.
+
+### Migration
+
+- Replace `Client.deliver(...).reply` / `.success?` with the returned reply and `rescue SmsTraffic::Error`.
+- Replace `reply.hash` with `reply.to_h`, and `sms.response` with `sms.reply`.
+- Treat `reply.sms_ids` as an Array; use `reply.messages` for per-phone data.
+- Set `config.logger` explicitly if you relied on the `$stdout` default with `debug = true`.
+- `Client.deliver` and `Client.status` no longer raise `SocketError`, `SystemCallError` (`Errno::*`), `IOError`,
+  `Net::OpenTimeout`, `Net::ReadTimeout` or `OpenSSL::SSL::SSLError`; rescue `SmsTraffic::ConnectionError` (the
+  original exception is in `cause`). `Sms#deliver` and `Sms#update_status` already rescue `SmsTraffic::Error` into
+  `errors`.
+- Replace `response.as_json` / `sms.response.as_json` with `reply.to_h` / `sms.reply&.to_h`.
+- Replace `response.success?` checks with `rescue SmsTraffic::Error`.
+- Replace `reply.hash["send_date"]` / `reply.hash["status"]` with `reply.send_date` / `reply.status`.

data/README.md

@@ -1,9 +1,9 @@
 # SmsTraffic
 
 [![Gem Version](https://badge.fury.io/rb/sms_traffic_sdk.svg)](https://badge.fury.io/rb/sms_traffic_sdk)
-[![Maintainability](https://api.codeclimate.com/v1/badges/bb4795be5024dd81d927/maintainability)](https://codeclimate.com/github/golifox/sms_traffic/maintainability)
-[![Coverage](https://codecov.io/github/golifox/sms_traffic/graph/badge.svg?token=74C0YBJP3F)](https://codecov.io/github/golifox/sms_traffic)
-[![CI](https://github.com/golifox/sms_traffic/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/golifox/sms_traffic/actions/workflows/ci.yml)
+[![Maintainability](https://api.codeclimate.com/v1/badges/bb4795be5024dd81d927/maintainability)](https://codeclimate.com/github/golifox/sms_traffic_sdk/maintainability)
+[![Coverage](https://codecov.io/github/golifox/sms_traffic_sdk/graph/badge.svg?token=74C0YBJP3F)](https://codecov.io/github/golifox/sms_traffic_sdk)
+[![CI](https://github.com/golifox/sms_traffic_sdk/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/golifox/sms_traffic_sdk/actions/workflows/ci.yml)
 
 Ruby Gem as a software development kit (SDK) that facilitates interaction with the SMS Traffic HTTP API (smstraffic.ru/api).
 This gem provides a convenient wrapper to integrate SMS Traffic services within Ruby applications, allowing for easy 
@@ -13,6 +13,8 @@ sending of SMS messages and checking delivery statuses.
 
 - Send SMS messages to single or multiple recipients.
 - Check the delivery status of sent messages.
+- Read the account balance.
+- Fail over to the provider's backup host.
 - **TODO:** Support for various message formats and encodings.
 
 
@@ -37,63 +39,126 @@ Or install it yourself as:
 Define settings:
 
 ```ruby
-# initializers/sms_traffic.rb
-require 'sms_traffic_sdk'
+# config/initializers/sms_traffic.rb
+require 'sms_traffic'
 
 SmsTraffic.configure do |config|
-  config.login = 'login'
-  config.password = 'password'
-  config.originator = 'default_originator'
-  config.server = 'https://api.smstraffic.ru'
-  config.debug = true
-  config.debugger = Rails.logger
+  config.login          = 'login'
+  config.password       = 'password'
+  config.host           = 'https://api.smstraffic.ru'
+  config.fallback_host  = 'https://api2.smstraffic.ru' # optional backup host, default nil
+  config.originator     = 'default_originator' # optional, can be given per SMS
+  config.open_timeout   = 10                   # seconds, default 10
+  config.read_timeout   = 30                   # seconds, default 30
+  config.validate_phone = true                 # default true: 11+ digits
+  config.debug          = true                 # default false
+  config.logger         = Rails.logger         # required when debug is true
 end
 ```
 
-Initialize sms:
+`login`, `password` and `host` are required; `logger` is required when `debug` is enabled.
+With `debug` on, one request line and one response line are written through `logger.debug`;
+`login`, `password` and `message` are replaced with `[FILTERED]`.
+
+Send an SMS:
+
 ```ruby
-sms = SmsTraffic::Sms.new('phone', 'text', 'originator') # initialize sms, originator by default from settings
-# =>  #<SmsTraffic::Sms:0x0000 @errors=[], @message="text", @originator="default_originator", @phone="phone", @status="not-sent">
+sms = SmsTraffic::Sms.new('79991112233', 'text', originator: 'my_brand') # originator defaults to the configured one
 
+sms.deliver      # => true when the provider enqueued it, false otherwise
+sms.status       # => 'sent' ('not-sent' until delivered)
+sms.id           # => '123456789' (the first sms id of the reply)
+sms.reply        # => #<SmsTraffic::Client::DeliverReply>
+sms.errors       # => [] (messages of failed attempts)
 ```
 
-Send it and get sent sms id and dispatch code:
+`deliver` and `update_status` never raise on provider or network failures; they append the message to `errors`
+and keep the current `status`.
+
+Refresh the status:
+
 ```ruby
-sms.deliver # send sms. returns sms id or dispatch code if something went wrong
-# => true
-sms.id # get sms id
-# => '123456789'
+sms.update_status # => 'delivered' (downcased provider status, or the unchanged status on failure)
 ```
 
-Get current sms status and update it:
+Use the client directly. It raises typed errors:
+
 ```ruby
-sms.status # get sms delivery status
-# => 'sent'
-sms.update_status # updates sms delivery status. returns status or status check response code on error
-# => 'delivered'
+reply = SmsTraffic::Client.deliver('79991112233,79261112233', 'text', 'my_brand')
+reply.ok?        # => true
+reply.sms_ids    # => ['8287366071', '8287366073']
+reply.messages   # => [{ phone: '79991112233', sms_id: '8287366071', push_id: 'a' }, ...]
+reply.sms_id('79261112233') # first sms id for the phone
+
+reply = SmsTraffic::Client.status('8287713301', '8287713303')
+reply.entries    # => [#<struct SmsTraffic::Client::StatusReply::Entry sms_id="8287713301", status="Delivered", ...>]
+reply.statuses   # => { '8287713301' => 'Delivered' }
+reply.errors     # => { '8287713303' => 'no such message or this message does not belong to you' }
+reply.entry('8287713303').not_found? # => true
+reply.status('8287713301')           # => 'Delivered'; the id may be omitted when there is one entry
 ```
 
-Get any sms status:
+Each entry has `sms_id`, `status`, `error`, `submission_date`, `send_date`, `last_status_change_date`
+(strings as sent by the provider), `error?`, `not_found?`, `final?`, `delivered?` and `status_reported?`
+(true when the provider sent a status element, even an empty one).
+
+### Final and delivered statuses
+
+Provider statuses `Delivered`, `Non Delivered`, `Rejected`, `Expired`, `Deleted` and `Unknown status` are final;
+an empty status and `Buffered SMSC` are intermediate (`SmsTraffic::Status::FINAL` / `INTERMEDIATE`).
+Comparison is case-insensitive.
+
 ```ruby
-response = SmsTraffic.status(sms_id) # status - sms delivery status unless error or return error
-reply = response.reply
-# => #<SmsTraffic::Client::StatusReply:0x0000>
-status = reply.status
-# => "Delivered"
-reply.hash
-# => 
-# {"error"=>nil,
-#  "submition_date"=>"2024-07-15 11:36:25",
-#  "send_date"=>"2024-07-15 11:36:25",
-#  "last_status_change_date"=>"2024-07-15 11:36:25",
-#  "sms_id"=>"865149797164801235",
-#  "status"=>"Delivered"}
+reply = SmsTraffic::Client.status('8287713301')
+reply.final?     # => true
+reply.delivered? # => true; pass an sms id when the reply has several entries
+reply.entry.final?
+
+sms.update_status
+sms.final?       # => true for a final stored status; false for 'not-sent' and 'sent'
+sms.delivered?   # => true only for 'delivered'
+```
 
+### Balance
+
+```ruby
+SmsTraffic::Client.balance.balance # => 0.10025e5 (BigDecimal), nil when absent or not a number
+```
+
+The value is returned as the provider sends it; its units are not documented and are not converted.
+
+### Fallback host
+
+Set `config.fallback_host` (the provider documents `https://api2.smstraffic.ru`) to repeat a failed request once
+on the backup host. The request is repeated after `SocketError`, `Errno::ECONNREFUSED`, `Errno::EHOSTUNREACH`,
+`Errno::ENETUNREACH`, `Net::OpenTimeout`, or API error 1000 (temporary server problem). `Client.status` and
+`Client.balance` also retry after any `ConnectionError` (read timeout, reset connection, TLS failure) and HTTP 5xx.
+`Client.deliver` does not, since the provider may already have queued the SMS. The error of the last attempt is raised. With `debug`, the retry is
+logged in one line without credentials.
+
+### Errors
+
+All errors inherit from `SmsTraffic::Error`:
+
+- `SmsTraffic::ConnectionError` - network, timeout or TLS failure (the original exception is `cause`).
+- `SmsTraffic::HttpError` - non-2xx response; has `status` and `body`.
+- `SmsTraffic::ApiError` - the provider replied `ERROR` (or `ERRO`); has `code` and `description`, and the
+  predicates `retryable?` (1000), `access_denied?` (411, 412), `insufficient_funds?` (415) and `blocked_phone?` (432).
+
+```ruby
+begin
+  SmsTraffic::Client.deliver('79991112233', 'text')
+rescue SmsTraffic::ApiError => e
+  e.code        # => '401'
+  e.description # => 'login param is missing'
+rescue SmsTraffic::Error => e
+  e.message
+end
 ```
 
 # Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/golifox/sms_traffic_sdk. 
+Bug reports and pull requests are welcome on GitHub at https://github.com/golifox/sms_traffic_sdk.
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 

data/lib/sms_traffic/client/account_reply.rb

@@ -0,0 +1,14 @@
+require 'bigdecimal'
+
+module SmsTraffic
+  class Client
+    class AccountReply < Reply
+      # @return [BigDecimal, nil] account balance as sent by the provider (units are not converted); nil when absent
+      #   or not a number
+      def balance
+        value = fetch_value(to_h, :account).to_s.strip
+        BigDecimal(value, exception: false) unless value.empty?
+      end
+    end
+  end
+end

data/lib/sms_traffic/client/deliver_reply.rb

@@ -1,62 +1,43 @@
 module SmsTraffic
   class Client
-    class DeliverReply < Client::Reply
-      OK_REPLY = 'OK'.freeze unless const_defined?(:OK_REPLY)
-
+    class DeliverReply < Reply
+      # @return [Boolean] result is OK and at least one message was queued
       def ok?
-        result == OK_REPLY && message_infos
+        result == OK_RESULT && !messages.empty?
       end
 
       def error?
         !ok?
       end
 
-      def result
-        fetch_value(hash, :result)
-      end
-
-      def code
-        fetch_value(hash, :code)
-      end
-
-      def description
-        fetch_value(hash, :description)
-      end
-
-      def message_infos
-        fetch_value(hash, :message_infos)
-      end
-
-      def sms_id(phone = nil)
-        message_info = fetch_value(message_infos, :message_info)
-        return fetch_value(message_info, :sms_id) if message_info.is_a?(Hash) || message_info.nil?
-
-        if phone
-          fetch_value(find_message_info(phone), :sms_id)
-        elsif message_info.is_a?(Array)
-          fetch_value(message_info.first, :sms_id)
+      # @return [Array<Hash>] queued messages as { phone:, sms_id:, push_id: }
+      def messages
+        @messages ||= message_infos.map do |info|
+          { phone: fetch_value(info, :phone), sms_id: fetch_value(info, :sms_id), push_id: fetch_value(info, :push_id) }
         end
       end
 
+      # @return [Array<String>] every sms id in reply order
       def sms_ids
-        message_info = fetch_value(message_infos, :message_info)
-
-        return [fetch_value(message_info, :sms_id)] if message_info&.size == 1
-        return [] if message_info.nil?
+        messages.filter_map { |message| message[:sms_id] }
+      end
 
-        message_info.each_with_object({}) do |info, hash|
-          hash[fetch_value(info, :phone)] = fetch_value(info, :sms_id)
-        end
+      # @param phone [String, nil]
+      # @return [String, nil] the first sms id, or the first one for the phone
+      def sms_id(phone = nil)
+        message = phone ? messages.find { |item| item[:phone].to_s == phone.to_s } : messages.first
+        message&.fetch(:sms_id)
       end
 
       def error_description
-        "#{result}: code: #{code}, description: #{description}" if error?
+        "Sms has not been enqueued: #{description}" if error?
       end
 
       private
 
-      def find_message_info(phone)
-        fetch_value(message_infos, :message_info).find { |info| fetch_value(info, :phone) == phone }
+      def message_infos
+        info = fetch_value(fetch_value(to_h, :message_infos), :message_info)
+        info.is_a?(Array) ? info : [info].compact
       end
     end
   end

data/lib/sms_traffic/client/reply.rb

@@ -1,19 +1,40 @@
 module SmsTraffic
   class Client
     class Reply
-      attr_reader :xml, :hash
+      OK_RESULT = 'OK'.freeze
+      ERROR_RESULT = 'ERROR'.freeze
+
+      attr_reader :xml, :to_h
 
       def initialize(xml, xml_parser: SmsTraffic.configuration.xml_parser)
-        @xml  = xml.gsub!(/\s+/, ' ')
-        @hash = fetch_value(xml_parser.parse(xml), :reply)
+        @xml = xml.gsub(/\s+/, ' ')
+        parsed = fetch_value(xml_parser.parse(@xml), :reply)
+        @to_h  = parsed.is_a?(Hash) ? parsed : {}
+      end
+
+      def result
+        fetch_value(to_h, :result)
+      end
+
+      def code
+        fetch_value(to_h, :code)
+      end
+
+      def description
+        fetch_value(to_h, :description)
+      end
+
+      # The provider documents `ERROR` but its example replies `ERRO`, so any result other than OK is an error.
+      def api_error?
+        !result.nil? && result != OK_RESULT
       end
 
       private
 
-      def fetch_value(hash, key)
-        hash.fetch(key.to_s, nil) || hash.fetch(key.to_sym, nil)
-      rescue NoMethodError
-        nil
+      def fetch_value(source, key)
+        return unless source.is_a?(Hash)
+
+        source.fetch(key.to_s) { source[key.to_sym] }
       end
     end
   end

data/lib/sms_traffic/client/status_reply.rb

@@ -1,43 +1,96 @@
 module SmsTraffic
   class Client
     class StatusReply < Reply
-      def sms_array
-        fetch_value(hash, :sms).is_a?(Array) ? fetch_value(hash, :sms) : [hash]
+      NOT_FOUND = /no such message/i
+
+      Entry = Struct.new(
+        :sms_id, :status, :status_reported, :error, :submission_date, :send_date, :last_status_change_date,
+        keyword_init: true
+      ) do
+        # @return [Boolean] the provider sent a status element, even an empty one (an intermediate status)
+        def status_reported?
+          status_reported == true
+        end
+
+        def error?
+          !error.nil?
+        end
+
+        def not_found?
+          error? && error.match?(NOT_FOUND)
+        end
+
+        def final?
+          Status.final?(status)
+        end
+
+        def delivered?
+          Status.delivered?(status)
+        end
       end
 
-      def status(sms_id = nil)
-        return fetch_value(sms_array.first, :status) if sms_array.size == 1
+      # @return [Array<Entry>]
+      def entries
+        @entries ||= entry_sources.map { |source| build_entry(source) }
+      end
+
+      # @param sms_id [String, nil] required unless the reply has exactly one entry
+      # @return [Entry, nil]
+      def entry(sms_id = nil)
+        return entries.find { |item| item.sms_id.to_s == sms_id.to_s } if sms_id
+        return entries.first if entries.size == 1
+
+        raise ArgumentError, 'sms_id is required'
+      end
 
-        raise ArgumentError, 'sms_id is required' if sms_id.nil?
+      %i[status error send_date].each do |name|
+        define_method(name) { |sms_id = nil| entry(sms_id)&.public_send(name) }
+      end
 
-        statuses[sms_id.to_s]
+      %i[error? not_found? final? delivered?].each do |name|
+        define_method(name) { |sms_id = nil| entry(sms_id)&.public_send(name) || false }
       end
 
-      # @return [Hash] statuses hash (key: sms_id, value: status)
-      # @example
-      #
-      #  {
-      #    '1234567890': 'DELIVERED',
-      #    '0987654321': 'FAILED'
-      #  }
+      # @return [Hash{String => String}] sms_id => status, without nil values
       def statuses
-        sms_array.each_with_object({}) do |sms, hash|
-          hash[fetch_value(sms, :sms_id)] = fetch_value(sms, :status)
-        end.compact
+        entries.to_h { |item| [item.sms_id, item.status] }.compact
       end
 
-      def error(sms_id = nil)
-        return fetch_value(sms_array.first, :error) if sms_array.size == 1
+      # @return [Hash{String => String}] sms_id => error, without nil values
+      def errors
+        entries.to_h { |item| [item.sms_id, item.error] }.compact
+      end
 
-        raise ArgumentError, 'sms_id is required' if sms_id.nil?
+      private
 
-        errors[sms_id.to_s]
+      def entry_sources
+        sms = fetch_value(to_h, :sms)
+        return sms if sms.is_a?(Array)
+        return [sms] if sms.is_a?(Hash)
+
+        to_h.empty? ? [] : [to_h]
       end
 
-      def errors
-        sms_array.each_with_object({}) do |sms, hash|
-          hash[fetch_value(sms, :sms_id)] = fetch_value(sms, :error)&.strip
-        end.compact
+      def key?(source, key)
+        source.is_a?(Hash) && (source.key?(key.to_s) || source.key?(key.to_sym))
+      end
+
+      def blank_to_nil(value)
+        stripped = value&.strip
+        stripped unless stripped.nil? || stripped.empty?
+      end
+
+      def build_entry(source)
+        Entry.new(
+          sms_id:                  fetch_value(source, :sms_id),
+          status:                  fetch_value(source, :status),
+          status_reported:         key?(source, :status),
+          error:                   blank_to_nil(fetch_value(source, :error)),
+          # The provider spells this field "submition_date".
+          submission_date:         fetch_value(source, :submition_date),
+          send_date:               fetch_value(source, :send_date),
+          last_status_change_date: fetch_value(source, :last_status_change_date)
+        )
       end
     end
   end