notifications-ruby-client 1.1.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c878b94e8c21c7ab8709764b27e242de18dccc1e
-  data.tar.gz: 4a3a9fad24a4b0685841bf7bfceadb05efe8339b
+  metadata.gz: 24ed09fc74d72afa42d20c723df34402b6d4d50d
+  data.tar.gz: f99c8a7ee09d01734af27f95c32d76cecd416be8
 SHA512:
-  metadata.gz: f03bef489bf792cf544f05c457a07066fd93cdb4a80be7fa8a83fc9ecda165f19a7ddacac5095fad24b93db92d5d62bc2c31c33fbd02e536f25caa3b5bad49d7
-  data.tar.gz: 6702179d9bb960e7935060b87185dcc1f6eeaf77b4887e52acee009715807d0a00282fc2f52bb6cb1bfab8f3e4b2bcaecd9e55c9f756e656a493d626e78aa17b
+  metadata.gz: a2d80bf886dc3b2a846e23842e49401d28d06595eb7f734ec9849b67e8c9be0fee81ce1f88409eede2ba4dd43baced5381f29dbce59bd8bc0c859966d4f8a5f2
+  data.tar.gz: 289479f21c94313ff77e24c5bc2e1906a9c7b71a8f7d02cc222593c8f6a872b51fdbf4039dd98fc1b3edd11baaa0c1420c9f0818f92e892242464e2118a923b4

data/CHANGELOG.md

@@ -0,0 +1,18 @@
+##2.0.0
+
+###Changed
+* Using version 2 of the notification-api.
+* A new `Notifications::Client` no longer requires the `service_id`, only the `api_key` is required.
+* `Notifications::Client.send_sms()` input parameters and the response object has changed, see the README for more information.
+ ```ruby
+    client.sendSms(phone_number, template_id, personalisation, reference)
+  ```
+* `Notifications::Client.send_email()`  input parameters has changed and the response object, see the README for more information.
+   ```ruby
+      client.sendSms(phone_number, template_id, personalisation, reference)
+    ```
+* `reference` is a new optional argument of the send methods. The `reference` can be used as a unique reference for the notification. Because Notify does not require this reference to be unique you could also use this reference to identify a batch or group of notifications.
+* `Notifications::Client.get_all_notifications()` => the response object has changed.
+  * You can also filter the collection of `Notifications` by `reference`. See the README for more information.
+* `Notifications::Client.get_notification(id)` => the response object has changed. See the README for more information.
+* Initializing a client only requires the api key.

data/README.md

@@ -28,43 +28,224 @@ Generate an API key by logging in to GOV.UK Notify [GOV.UK Notify](https://www.n
 Text message:
 
 ```ruby
-sms = client.send_sms(to: number, 
-                      template: template_id,
-                      personalisation: {
-                      name: "name",
-                      year: "2016"
-  }
-)
+require 'notifications/client/response_notification'
+sms = client.send_sms(phone_number: number,
+                      template_id: template_id,
+                      personalisation: Hash[name: "name",
+                                        year: "2016",                      
+                                      ],
+                      reference: "your_reference_string"
+                      ) # => Notifications::Client::ResponseNotification
+```
+
+<details>
+<summary>
+Response
+</summary>
+
+If the request is successful, a `Notifications::Client:ResponseNotification` is returned
 
+```ruby
+sms => Notifications::Client::ResponseNotification
+
+sms.id         # => uuid for the notification
+sms.reference  # => Reference string you supplied in the request
+sms.type       # => sms
+sms.status     # => status of the message "created|pending|sent|delivered|permanent-failure|temporary-failure"
+content        # => Hash containing body => the message sent to the recipient, with placeholders replaced.
+               #                    from_number => the sms sender number of your service found **Settings** page
+template       # => Hash containing id => id of the template
+               #                    version => version of the template
+               #                    uri => url of the template    
+uri            # => URL of the notification
 ```
 
+Otherwise the client will raise a `Notifications::Client::RequestError`:
+<table>
+ <thead>
+   <tr>
+    <th>error.code</th>
+    <th>error.message</th>
+   </tr>
+ </thead>
+ <tbody>
+   <tr>
+    <td>
+      <pre>429</pre>
+    </td>
+    <td>
+      <pre>
+      [{
+          "error": "TooManyRequestsError",
+          "message": "Exceeded send limits (50) for today"
+      }]
+      </pre>
+    </td>
+  </tr>
+  <tr>
+    <td>
+      <pre>400</pre>
+    </td>
+    <td>
+      <pre>
+      [{
+          "error": "BadRequestError",
+          "message": "Can"t send to this recipient using a team-only API key"
+      ]}
+      </pre>
+    </td>
+  </tr>
+  <tr>
+    <td>
+      <pre>400</pre>
+    </td>
+    <td>
+      <pre>
+      [{
+          "error": "BadRequestError",
+          "message": "Can"t send to this recipient when service is in trial mode
+                      - see https://www.notifications.service.gov.uk/trial-mode"
+      }]
+      </pre>
+    </td>
+  </tr>
+</tbody>
+</table>
+</details>                  
+
+
 Email:
+
 ```ruby
-email = client.send_email(
-  to: email_address, 
-  template: template_id,
-  personalisation: {
-    name: "name",
-    year: "2016"
-  }
-) # => Notifications::Client::ResponseNotification
+require 'notifications/client/response_notification'
+email = client.send_email(email_address: email_address,
+                          template: template_id,
+                          personalisation: Hash[name: "name",
+                                            year: "2016"
+                                          ],
+                          reference: "your_reference_string"
+                        ) # => Notifications::Client::ResponseNotification
 ```
 
-Find `template_id` by clicking **API info** for the template you want to send.
+<details>
+<summary>
+Response
+</summary>
+
+If the request is successful, a `Notifications::Client:ResponseNotification` is returned
+
+```ruby
+email => Notifications::Client::ResponseNotification
+
+email.id         # => uuid for the notification
+email.reference  # => Reference string you supplied in the request
+email.type       # => sms
+email.status     # => status of the message "created|pending|sent|delivered|permanent-failure|temporary-failure"
+email.content    # => Hash containing body => the message sent to the recipient, with placeholders replaced.
+                 #                    subject => subject of the message sent to the recipient, with placeholders replaced.
+                 #                    from_email => the from email of your service found **Settings** page
+email.template   # => Hash containing id => id of the template
+                 #                    version => version of the template
+                 #                    uri => url of the template    
+email.uri        # => URL of the notification
+```
+
+Otherwise the client will raise a `Notifications::Client::RequestError`:
+<table>
+ <thead>
+   <tr>
+    <th>error.code</th>
+    <th>error.message</th>
+   </tr>
+ </thead>
+ <tbody>
+   <tr>
+    <td>
+      <pre>429</pre>
+    </td>
+    <td>
+      <pre>
+      [{
+          "error": "TooManyRequestsError",
+          "message": "Exceeded send limits (50) for today"
+      }]
+      </pre>
+    </td>
+  </tr>
+  <tr>
+    <td>
+      <pre>400</pre>
+    </td>
+    <td>
+      <pre>
+      [{
+          "error": "BadRequestError",
+          "message": "Can"t send to this recipient using a team-only API key"
+      ]}
+      </pre>
+    </td>
+  </tr>
+  <tr>
+    <td>
+      <pre>400</pre>
+    </td>
+    <td>
+      <pre>
+      [{
+          "error": "BadRequestError",
+          "message": "Can"t send to this recipient when service is in trial mode
+                      - see https://www.notifications.service.gov.uk/trial-mode"
+      }]
+      </pre>
+    </td>
+  </tr>
+</tbody>
+</table>
+</details>
+
+### Arguments
+#### `phone_number`
+The phone number of the recipient, only required when using `client.send_sms`.
+
+#### `email_address`
+The email address of the recipient, only required when using `client.send_email`.
+
+#### `template_id`
+Find by clicking **API info** for the template you want to send.
 
-If a template has placeholders, you need to provide their values in `personalisation`. Otherwise do not pass in `personalisation`
+#### `reference`
+An optional identifier you generate. The `reference` can be used as a unique reference for the notification. Because Notify does not require this reference to be unique you could also use this reference to identify a batch or group of notifications.
 
-If successful the response is a `Notifications::Client::ResponseNotification`, which has the notification id.
-Otherwise a Notifications::Client::RequestError is returned.
+You can omit this argument if you do not require a reference for the notification.
 
+#### `personalisation`
+If the template has placeholders you need to provide their values as a Hash, for example:
+
+```ruby
+  personalisation=Hash[
+                        'first_name': 'Amala',
+                        'reference_number': '300241',
+                      ]
+```
+
+You can omit this argument if the template does not contain placeholders.
 
 ### Get the status of one message
 
 ```ruby
 notification = client.get_notification(id) # => Notifications::Client::Notification
+```
+
+<details>
+<summary>
+Response
+</summary>
+If successful a `Notifications::Client::Notification is returned.
+
+```ruby
 notification.id         # => uuid for the notification
 notification.to         # => recipient email address or mobile number
-notification.status     # => status of the message "created|pending|sent|delivered|permanent-failure|temporary-failure" 
+notification.status     # => status of the message "created|pending|sent|delivered|permanent-failure|temporary-failure"
 notification.created_at # => Date time the message was created
 notification.api_key    # => uuid for the api key (not the actual api key)
 notification.billable_units # => units billable or nil for email
@@ -80,69 +261,141 @@ notification.template_version # Template version number
 notification.reference  # => reference of the email or nil for sms
 notification.updated_at # => Date time that the notification was last updated
 ```
+Otherwise a `Notification::Client::RequestError` is raised
+
+<table>
+<thead>
+<tr>
+<th>`error.code`</th>
+<th>`error.message`</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td>
+<pre>404</pre>
+</td>
+<td>
+<pre>
+[{
+    "error": "NoResultFound",
+    "message": "No result found"
+}]
+</pre>
+</td>
+</tr>
+<tr>
+<td>
+<pre>400</pre>
+</td>
+<td>
+<pre>
+[{
+    "error": "ValidationError",
+    "message": "id is not a valid UUID"
+}]
+</pre>
+</td>
+</tr>
+</tbody>
+</table>
+</details>
 
+</details>
 ### Get the status of all messages
 
 ```ruby
-notifications = client.get_notifications
-notifications.links # => {"last"=>"/notifications?page=4", "next"=>"/notifications?page=2"}
-notifications.total # => 202
-notifications.page_size # => 50
-notifications.collection # => [] (array of notification objects)
-
+# See section below for a description of the arguments.
+args = Hash[
+            'template_type', 'sms',
+            'status', 'failed',
+            'reference', 'your reference string'
+            'olderThanId', 'e194efd1-c34d-49c9-9915-e4267e01e92e' # => Notifications::Client::Notification
+            ]
+notifications = client.get_notifications(args)
 ```
-
-Query parameters are also supported
+<details>
+<summary>
+Response
+</summary>
+If the request is successful a `Notifications::Client::NotificationsCollection` is returned.
 
 ```ruby
-client.get_notifications(
-  page: 2,
-  limit_days: 3,
-  page_size: 20,
-  status: "delivered",
-  template_type: "sms"
-)
+notifications.links # => Hash containing current=>"/notifications?template_type=sms&status=delivered"
+next=>"/notifications?other_than=last_id_in_list&template_type=sms&status=delivered"}
+notifications.collection # => [] (array of notification objects)
 ```
+Otherwise the client will raise a `Notifications::Client::RequestError`:
+<table>
+<thead>
+<tr>
+<th>error.status_code</th>
+<th>error.message</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td>
+<pre>400</pre>
+</td>
+<td>
+<pre>
+[{
+	'error': 'ValidationError',
+    'message': 'bad status is not one of [created, sending, delivered, pending, failed, technical-failure, temporary-failure, permanent-failure]'
+}]
+</pre>
+</td>
+</tr>
+<tr>
+<td>
+<pre>400</pre>
+</td>
+<td>
+<pre>
+[{
+    "error": "ValidationError",
+    "message": "Apple is not one of [sms, email, letter]"
+}]
+</pre>
+</td>
+</tr>
+</tbody>
+</table>
+</details>
 
-### Exceptions
+### Arguments
+Omit the argument Hash if you do not want to filter the results.
+#### `template_type`
 
-Raised exceptions will contain error message and response status code
+You can filter by:
 
-```ruby
-client = Notifications::Client.new(base_url, invalid, invalid)
-rescue Notifications::Client::RequestError => e
-e.code # => 403
-e.message # => Invalid credentials
-```
-<table>
-  <thead>
-    <tr>
-      <td> Code </td>
-      <td> Message </td>
-     </tr>
-  </thead>
-  <tbdoy>
-  <tr>
-    <td> 403 </td>
-    <td> {"token"=>["Invalid token: signature"]} </td>
-  </tr>
-  <tr>
-    <td> 403 </td>
-    <td> {"token"=>["Invalid token: expired"]} </td>
-  </tr>
-  <tr>
-    <td> 429 </td>
-    <td> Exceeded send limits (50) for today </td>
-  </tr>
-  <tr>
-    <td> 400 </td>
-    <td> Can’t send to this recipient using a team-only API key </td>
-  </tr>
-  <tr>
-    <td> 400 </td>
-    <td> Can’t send to this recipient when service is in trial 
-          mode - see https://www.notifications.service.gov.uk/trial-mode
-    </td>
-  </tr>
-  </tbody>
-</table>
+* `email`
+* `sms`
+* `letter`
+
+You can omit this argument to ignore the filter.
+
+#### `status`
+
+You can filter by:
+
+* `sending` - the message is queued to be sent by the provider.
+* `delivered` - the message was successfully delivered.
+* `failed` - this will return all failure statuses `permanent-failure`, `temporary-failure` and `technical-failure`.
+* `permanent-failure` - the provider was unable to deliver message, email or phone number does not exist; remove this recipient from your list.
+* `temporary-failure` - the provider was unable to deliver message, email box was full or the phone was turned off; you can try to send the message again.
+* `technical-failure` - Notify had a technical failure; you can try to send the message again.
+
+You can omit this argument to ignore the filter.
+
+### `reference`
+
+This is the `reference` you gave at the time of sending the notification. The `reference` can be a unique identifier for the notification or an identifier for a batch of notifications.
+
+You can omit this argument to ignore the filter.
+
+
+#### `olderThanId`
+You can get the notifications older than a given `Notification.id`.
+You can omit this argument to ignore this filter.

data/bin/test_client.rb

@@ -5,7 +5,7 @@ require 'notifications/client/response_notification'
 require 'notifications/client/notification'
 
 def main
-  client = Notifications::Client.new(ENV['SERVICE_ID'], ENV['API_KEY'], ENV['NOTIFY_API_URL'])
+  client = Notifications::Client.new(ENV['API_KEY'], ENV['NOTIFY_API_URL'])
   email_notification = test_send_email_endpoint(client)
   sms_notification = test_send_sms_endpoint(client)
   test_get_notification_by_id_endpoint(client, email_notification.id, 'email')
@@ -16,15 +16,17 @@ def main
 end
 
 def test_send_email_endpoint(client)
-  email_resp = client.send_email(to: ENV['FUNCTIONAL_TEST_EMAIL'], template: ENV['EMAIL_TEMPLATE_ID'],
-                                 personalisation:Hash["name", "some name"])
+  email_resp = client.send_email(email_address: ENV['FUNCTIONAL_TEST_EMAIL'], template_id: ENV['EMAIL_TEMPLATE_ID'],
+                                 personalisation:Hash["name", "some name"],
+                                 reference: "some reference")
   test_notification_response_data_type(email_resp, 'email')
   email_resp
 end
 
 def test_send_sms_endpoint(client)
-  sms_resp = client.send_sms(to: ENV['FUNCTIONAL_TEST_NUMBER'], template: ENV['SMS_TEMPLATE_ID'],
-                             personalisation:Hash["name", "some name"])
+  sms_resp = client.send_sms(phone_number: ENV['FUNCTIONAL_TEST_NUMBER'], template_id: ENV['SMS_TEMPLATE_ID'],
+                             personalisation:Hash["name", "some name"],
+                             reference: "some reference")
   test_notification_response_data_type(sms_resp, 'sms')
   sms_resp
 end
@@ -38,6 +40,15 @@ def test_notification_response_data_type(notification, message_type)
     p 'failed '+ message_type + 'id is not a String'
     exit 1
   end
+  field_should_not_be_nil(expected_fields_in_notification_response, notification, 'send_'+message_type)
+  hash_key_should_not_be_nil(expected_fields_in_template, notification.send('template'), 'send_'+message_type+'.template')
+  if message_type == 'email' then
+    hash_key_should_not_be_nil(expected_fields_in_email_content, notification.send('content'), 'send_'+message_type+'.content')
+  end
+  if message_type == 'sms' then
+    hash_key_should_not_be_nil(expected_fields_in_sms_content, notification.send('content'),'send_'+message_type+'.content')
+  end
+
 end
 
 def test_get_notification_by_id_endpoint(client, id, message_type)
@@ -47,13 +58,16 @@ def test_get_notification_by_id_endpoint(client, id, message_type)
     exit 1
   end
   if message_type == 'email' then
-    field_should_not_be_nil(expected_fields_in_email_resp, get_notification_response, 'send_email')
-    field_should_be_nil(expected_fields_in_email_resp_that_are_nil, get_notification_response, 'send_email')
+    field_should_not_be_nil(expected_fields_in_email_notification, get_notification_response, 'Notifications::Client::Notification for type email')
+    field_should_be_nil(expected_fields_in_email_notification_that_are_nil, get_notification_response, 'Notifications::Client::Notification for type email')
+    hash_key_should_not_be_nil(expected_fields_in_template, get_notification_response.send('template'), 'Notifications::Client::Notification.template for type email')
   end
   if message_type == 'sms' then
-    field_should_not_be_nil(expected_fields_in_sms_resp, get_notification_response, 'send_sms')
-    field_should_be_nil(expected_fields_in_sms_resp_that_are_nil, get_notification_response, 'send_sms')
+    field_should_not_be_nil(expected_fields_in_sms_notification, get_notification_response, 'Notifications::Client::Notification for type sms')
+    field_should_be_nil(expected_fields_in_sms_notification_that_are_nil, get_notification_response, 'Notifications::Client::Notification for type sms')
+    hash_key_should_not_be_nil(expected_fields_in_template, get_notification_response.send('template'), 'Notifications::Client::Notification.template for type sms')
   end
+
 end
 
 
@@ -86,6 +100,15 @@ def get_notification_for_id(client, id, message_type)
   get_notification_response
 end
 
+def hash_key_should_not_be_nil(fields, obj, method_name)
+  fields.each do |field|
+    if obj.has_value?(:"#{field}") then
+      p 'contract test failed because ' + field + ' should not be nil for ' + method_name + ' response'
+      exit 1
+    end
+  end
+end
+
 def field_should_not_be_nil(fields, obj, method_name)
   fields.each do |field|
     if obj.send(:"#{field}") == nil then
@@ -104,51 +127,84 @@ def field_should_be_nil(fields, obj, method_name)
   end
 end
 
-def expected_fields_in_email_resp
+
+def expected_fields_in_notification_response
   %w(id
-     api_key
-     billable_units
-     to
-     subject
+     reference
+     content
+     template
+     uri
+)
+end
+
+def expected_fields_in_email_content
+  %w(from_email
      body
-     notification_type
+     subject
+)
+end
+
+def expected_fields_in_sms_content
+  %w(body
+     )
+end
+
+def expected_fields_in_email_notification
+  %w(id
+     reference
+     email_address
+     type
      status
-     service
      sent_at
-     sent_by
      template
-     template_version
+     body
+     subject
      created_at
-     updated_at
 )
 end
 
-def expected_fields_in_email_resp_that_are_nil
-  %w(job)
+def expected_fields_in_email_notification_that_are_nil
+  %w(phone_number
+     line_1
+     line_2
+     line_3
+     line_4
+     line_5
+     line_5
+     line_6
+     postcode
+     )
 end
 
-def expected_fields_in_sms_resp
+def expected_fields_in_sms_notification
   %w(id
-   api_key
-   billable_units
-   to
-   body
-   notification_type
-   status
-   service
-   sent_at
-   sent_by
-   template
-   template_version
-   created_at
-   updated_at
+     phone_number
+     type
+     status
+     sent_at
+     template
+     body
+     created_at
    )
 end
 
-def expected_fields_in_sms_resp_that_are_nil
-  %w(job
-  subject
-	reference)
+def expected_fields_in_sms_notification_that_are_nil
+  %w(email_address
+     line_1
+     line_2
+     line_3
+     line_4
+     line_5
+     line_5
+     line_6
+     postcode
+     subject)
+end
+
+def expected_fields_in_template
+  %w(id
+     version
+     uri)
 end
 
 def test_get_all_notifications(client, first_id, second_id)
@@ -173,8 +229,6 @@ end
 
 def expected_fields_for_get_all_notifications
   %W(links
-	total
-	page_size
 	collection
 	)
 end

data/docker/Dockerfile

@@ -1,10 +1,12 @@
 FROM ruby:2.3.1-slim
 
-ARG APT_HTTP_PROXY
+ARG HTTP_PROXY
+ARG HTTPS_PROXY
+ARG NO_PROXY
 
 RUN \
 	echo "Install Debian packages" \
-	&& ([ -z "$APT_HTTP_PROXY" ] || echo "Acquire::http::Proxy \"${APT_HTTP_PROXY}\";\n" > /etc/apt/apt.conf.d/99HttpProxy) \
+	&& ([ -z "$HTTP_PROXY" ] || echo "Acquire::http::Proxy \"${HTTP_PROXY}\";" > /etc/apt/apt.conf.d/99HttpProxy) \
 	&& apt-get update \
 	&& apt-get install -y --no-install-recommends \
 		make \

data/docker/Makefile

@@ -7,4 +7,10 @@ help:
 
 .PHONY: build
 build:
-	docker build --pull -t govuk/notify-ruby-client-builder --build-arg APT_HTTP_PROXY="${HTTP_PROXY}" .
+	docker build \
+		--pull \
+		--build-arg HTTP_PROXY="${HTTP_PROXY}" \
+		--build-arg HTTPS_PROXY="${HTTP_PROXY}" \
+		--build-arg NO_PROXY="${NO_PROXY}" \
+		-t govuk/notify-ruby-client-builder \
+		.

data/lib/notifications/client.rb

@@ -55,9 +55,10 @@ module Notifications
     # @option options [String] :status
     #   sending, delivered, permanently failed,
     #   temporarily failed, or technical failure
-    # @option options [String] :page
-    # @option options [String] :page_size
-    # @option options [String] :limit_days
+    # @option options [String] :reference
+    #   your reference for the notification
+    # @option options [String] :olderThanId
+    #   notification id to return notificaitons that are older than this id.
     # @see Notifications::Client::Speaker#get
     # @return [NotificationsCollection]
     def get_notifications(options = {})

data/lib/notifications/client/notification.rb

@@ -3,28 +3,29 @@ module Notifications
     class Notification
       FIELDS = [
         :id,
-        :api_key,
-        :billable_units,
-        :to,
-        :subject,
-        :body,
-        :job,
-        :notification_type,
+        :reference,
+        :email_address,
+        :phone_number,
+        :line_1,
+        :line_2,
+        :line_3,
+        :line_4,
+        :line_5,
+        :line_6,
+        :postcode,
+        :type,
         :status,
-        :service,
-        :sent_at,
-        :sent_by,
         :template,
-        :template_version,
-        :reference,
+        :body,
+        :subject,
+        :sent_at,
         :created_at,
-        :updated_at
+        :completed_at
       ].freeze
 
       attr_reader(*FIELDS)
 
       def initialize(notification)
-        notification = normalize(notification)
 
         FIELDS.each do |field|
             instance_variable_set(:"@#{field}", notification.fetch(field.to_s, nil)
@@ -35,7 +36,7 @@ module Notifications
       [
         :sent_at,
         :created_at,
-        :updated_at
+        :completed_at
       ].each do |field|
         define_method field do
           begin
@@ -47,11 +48,6 @@ module Notifications
         end
       end
 
-      private
-
-      def normalize(notification)
-        notification.key?('data') ? notification['data']['notification'] : notification
-      end
     end
   end
 end

data/lib/notifications/client/notifications_collection.rb

@@ -2,14 +2,10 @@ module Notifications
   class Client
     class NotificationsCollection
       attr_reader :links,
-                  :total,
-                  :page_size,
                   :collection
 
       def initialize(response)
         @links = response["links"]
-        @total = response["total"]
-        @page_size = response["page_size"]
         @collection = collection_from(response["notifications"])
       end
 

data/lib/notifications/client/request_error.rb

@@ -13,7 +13,7 @@ module Notifications
       end
 
       def message_from(body)
-        JSON.parse(body).fetch("message")
+        JSON.parse(body).fetch('errors')
       rescue JSON::ParserError
         body
       end

data/lib/notifications/client/response_notification.rb

@@ -1,11 +1,25 @@
 module Notifications
   class Client
     class ResponseNotification
-      attr_reader :id
+      FIELDS = [
+      :id,
+      :reference,
+      :content,
+      :template,
+      :uri
+    ].freeze
 
-      def initialize(response)
-        @id = response["data"]["notification"]["id"]
+
+      attr_reader(*FIELDS)
+
+      def initialize(notification)
+
+        FIELDS.each do |field|
+            instance_variable_set(:"@#{field}", notification.fetch(field.to_s, nil)
+            )
+        end
       end
+
     end
   end
 end

data/lib/notifications/client/speaker.rb

@@ -10,41 +10,34 @@ module Notifications
       attr_reader :service_id
       attr_reader :secret_token
 
-      BASE_PATH = "/notifications".freeze
+      BASE_PATH = "/v2/notifications".freeze
       USER_AGENT = "NOTIFY-API-RUBY-CLIENT/#{Notifications::Client::VERSION}".freeze
 
       ##
-      # @param service_id [String] your service
-      #   API identifier
-      # @param secret [String] your service API
-      #   secret
-      # @param base_url [String] host URL. This is
-      #   the address to perform the requests
-      def initialize(service_id, secret_token = nil, base_url = nil)
-        if secret_token == nil and base_url == nil
-          @service_id = service_id[service_id.length - 73..service_id.length - 38]
-          @secret_token = service_id[service_id.length - 36..service_id.length]
-          @base_url = PRODUCTION_BASE_URL
-        elsif secret_token.start_with?("http") and base_url == nil
-          @service_id = service_id[service_id.length - 73..service_id.length - 38]
-          @secret_token = service_id[service_id.length - 36..service_id.length]
-          @base_url = secret_token
-        else
-          @service_id = service_id
-          @secret_token = secret_token[secret_token.length - 36..secret_token.length]
-          @base_url = base_url || PRODUCTION_BASE_URL
-        end
+      # @param secret [String] your service API secret
+      # @param base_url [String] host URL. This is the address to perform the requests.
+      #                          If left nil the production url is used.
+      def initialize(secret_token = nil, base_url = nil)
+        @service_id = secret_token[secret_token.length - 73..secret_token.length - 38]
+        @secret_token = secret_token[secret_token.length - 36..secret_token.length]
+        @base_url = base_url || PRODUCTION_BASE_URL
       end
 
       ##
       # @param kind [String] 'email' or 'sms'
       # @param form_data [Hash]
-      # @option form_data [String] :to recipient
-      #   to notify (sms or email)
+      # @option form_data [String] :phone_number
+      #   phone number of the sms recipient
+      # @option form_data [String] :email_address
+      #   email address of the email recipent
       # @option form_data [String] :template
       #   template to render in notification
       # @option form_data [Hash] :personalisation
       #   fields to use in the template
+      # @option form_data [String] :reference
+      #   A reference specified by the service for the notification. Get all notifications can be filtered by this reference.
+      #   This reference can be unique or used used to refer to a batch of notifications.
+      #   Can be an empty string or nil, when you do not require a reference for the notifications.
       # @see #perform_request!
       def post(kind, form_data)
         request = Net::HTTP::Post.new(

data/lib/notifications/client/version.rb

@@ -1,5 +1,5 @@
 module Notifications
   class Client
-    VERSION = "1.1.2".freeze
+    VERSION = "2.0.0".freeze
   end
 end

data/notifications-ruby-client.gemspec

@@ -7,11 +7,10 @@ Gem::Specification.new do |spec|
   spec.name          = "notifications-ruby-client"
   spec.version       = Notifications::Client::VERSION
   spec.authors       = [
-    "bitzesty",
-    "dazahern"
+    "Government Digital Service"
   ]
 
-  spec.email         = ["info@bitzesty.com", "daz.ahern@digital.cabinet-office.gov.uk"]
+  spec.email         = ["notify@digital.cabinet-office.gov.uk"]
 
   spec.summary       = "Ruby client for GOV.UK Notifications API"
   spec.homepage      = "https://github.com/alphagov/notifications-ruby-client"

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: notifications-ruby-client
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 2.0.0
 platform: ruby
 authors:
-- bitzesty
-- dazahern
+- Government Digital Service
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-12-02 00:00:00.000000000 Z
+date: 2017-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jwt
@@ -111,14 +110,14 @@ dependencies:
         version: 1.1.0
 description: 
 email:
-- info@bitzesty.com
-- daz.ahern@digital.cabinet-office.gov.uk
+- notify@digital.cabinet-office.gov.uk
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - Makefile