roqua-rom-api 0.1.12 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9b191aee54049eed911532caa0bd2d3d16459626
-  data.tar.gz: f5b755d2759a8920984a8f36dca1c0136f721855
+  metadata.gz: 30ed2a42e8a301108183e50522a8f7e9bce394f6
+  data.tar.gz: b50538aa9e6deb136b3bdde1afcf94b2af850824
 SHA512:
-  metadata.gz: f599a248e80d020849a6f2771e13116110895d8ec912daac8a94d8ec7b5271974013fed867b7d3932717580f8b6d0fea725ea0e02e99dd0c514e0799ce0a0a2c
-  data.tar.gz: 14539ad8b98495ec7bdeb86a8084dd08dcd33df26be5af254643a2ef4b04e83657263a1774625954a7fb68b0a931bbf1c1be61c5f91c8040172dd3da99d39306
+  metadata.gz: a11ca264905e5ac7f804526d62d4dd0dd9f34040a2ae698660c7f9da6c7b5bbce405c1a20cd7de7b0631b812760286b73ef6062a33f5e4c9daebc374c9ea963e
+  data.tar.gz: 3b45dc6223a2f27be6eb835421960a9fd51e0f3c971936133a0e81e239b13a8fa563fd626fc97739decea018a1115bce4e0a3eef6e1949fb77eb7b335201dbad

data/ChangeLog.md

@@ -1,6 +1,10 @@
 ### HEAD
 
+### 0.2.0 / 2014-11-11
 
+* Added CreateMeasurementSequence
+* BACKWARD INCOMPATIBLE: Starting a protocol subscription now returns ProtocolSubscription model
+* Add responses to protocol subscriptions
 
 ### 0.1.12 / 2014-10-28
 

data/README.md

@@ -2,20 +2,35 @@
 
 Make sure the following environment variables are defined:
 
-    ENV['ROM_HOST']    # URI of the RoQua application whose API you are targeting
-    ENV['ROM_KEY']     # username used for HTTP basic authentication on the RoQua API
-    ENV['ROM_SECRET']  # password used for HTTP basic authentication on the RoQua API
+    ENV['ROM_HOST']             # URI of the RoQua application whose API you are targeting
+    ENV['ROM_BASICAUTH_ID']     # username used for HTTP basic authentication on the RoQua API
+    ENV['ROM_BASICAUTH_SECRET'] # password used for HTTP basic authentication on the RoQua API
 
 An HTTP basic auth username password combination can be generated in the RoQua admin interface integration tab
 
-## I18n
+## General notes
+
+### I18n
 
 By default the ROM API Gem supports the `:nl` language only. If you use another locale or want to change some of the messages, simply extend your locale file by providing a value for some or all of the keys defined `config/locales/*.yml` in the root of this Gem.
 
 
-## Fill Out Requests
+### Usecases
+
+In general, the use case classes will return an outcome object. You can query this object to find out if the API call was
+successful with `#valid?`. The result of the API call is available under `#result`, and/or the errors under `#errors`. In general,
+this means that you'll usually write a pattern like this:
+
+    outcome = Roqua::RomApi::Something.run param: 1, other: 2
+
+    if outcome.valid?
+      responses = outcome.result
+    else
+      log_or_display outcome.errors.full_messages
+    end
+
 
-See [api](http://roqua.github.io/developer/rom_v1/dossier/fill_out_requests/) for more info what this does and format of callbacks.
+## [Fill Out Requests](http://roqua.github.io/developer/rom/dossier/fill_out_requests/)
 
 To create a fill out request run:
 
@@ -23,18 +38,11 @@ To create a fill out request run:
                                              questionnaire_keys: ['key1', 'key2'],
                                              callback_url: notify_callback_path(token: 'secret')
 
-#### Parameters
+See [api](http://roqua.github.io/developer/rom/dossier/fill_out_requests/) for more info on how callbacks work.
 
-* `dossier_id:`         [Required]  - Unique dossier identifier string for the patient about to fill out questionnaires
-* `questionnaire_keys:` [Required]  - Array of keys of questionnaires to fill out
-* `open_from:`                        Time the patient can start filling out the questionnaires and time.
-* `open_till:`                        Time the patient can no longer fill in the questionnaire.
-* `callback_url:`       [Required]  - Url for event callbacks
-* `reminders:`                        Array of durations after which a reminder should be sent if fill_out_request has not been finished.
-* `respondent_type:`                  Defaults to 'patient_version', each type is a separate list of questionnaires to fill out.
 
 
-## Fill Out Sessions
+## [Fill Out Sessions](http://roqua.github.io/developer/rom/dossier/fill_out_sessions/)
 
 To start filling out a set of questionnaires run:
 
@@ -42,129 +50,46 @@ To start filling out a set of questionnaires run:
                                                      questionnaire_keys: questionnaire_keys,
                                                      return_to: '/some/return/url/or/path'
 
-#### Parameters
-
- * `dossier_id:`         [Required]           - Unique dossier identifier for the patient about to fill out a questionnaire.
- * `questionnaire_keys:`                        Array of keys uniquely identifying the questionnaires to be filled out.
- * `response_ids:`                              Array of ids uniquely identifying aborted responses for which filling out has to be resumed.
- * `return_to:`          [Required]           - Address to return to after filling out the questionnaire.
-
-When questionnaire keys are provided, a set of blank questionnaires will be filled out. When response ids are provided,
-filling out questionnaires for these responses is resumed.
-
 Redirect to the fill_out url received when the outcome is valid:
 
     if outcome.valid?
       redirect_to outcome.result
-
-or do something with the validation errors:
-
     else
       log_or_display outcome.errors.full_messages
     end
 
+## [Protocol Subscriptions](http://roqua.github.io/developer/rom/dossier/protocol_subscriptions/)
 
-## Protocol Subscriptions
+### [List](http://roqua.github.io/developer/rom/dossier/protocol_subscriptions/#list-active-protocol-subscriptions-for-a-patient)
 
-### Index
 To retrieve active protocol subscriptions run:
 
     outcome = Roqua::RomApi::ListProtocolSubscriptions.run dossier_id: dossier_id
 
-#### Parameters
-
- * `dossier_id:`   [Required]                - Unique dossier identifier for the patient you want the subscriptions for.
-
-When the request succeeds, an array of subscriptions is returned:
-
-    if outcome.valid?
-      subscriptions = outcome.result
-
-Else some validation errors can be shown:
+### [Start](http://roqua.github.io/developer/rom/dossier/protocol_subscriptions/#start-a-protocol-subscription)
 
-    else
-      log_or_display outcome.errors.full_messages
-    end
-
-### Create
 To subscribe to a protocol run the following command:
 
     outcome = Roqua::RomApi::StartProtocolSubscription.run dossier_id: dossier_id,
                                                            protocol_key: protocol_key,
                                                            start_at: start_at
 
-#### Parameters
-
- * `dossier_id:`   [Required]                - Unique dossier identifier for the patient to be subscribed.
- * `protocol_key:` [Required]                - Key uniquely identifying the protocol of interest as specified in RoQua.
- * `start_at:`     [Defaults to the present] - Timestamp specifying when the first measurement should be prepared.
- * `flags`                                   - Boolean flags that are passed in when a questionnaire is being filled out.
- * `textvars`                                - String variables that are passed in when a questionnaire is being filled out.
+### [Stop](http://roqua.github.io/developer/rom/dossier/protocol_subscriptions/#stop-a-protocol-subscription)
 
-When the subscription succeeds, the subscription object is available through the `#result` accessor:
-
-    if outcome.valid?
-      subscription = outcome.result
-
-Else the validation errors can be inspected:
-
-    else
-      log_or_display outcome.errors.full_messages
-    end
-
-### Destroy
 To unsubscribe from a protocol run the command:
 
     outcome = Roqua::RomApi::StopProtocolSubscription.run dossier_id: dossier_id,
                                                           protocol_subscription_id: subscription_id
 
-#### Parameters
+## [Responses](http://roqua.github.io/developer/rom/dossier/responses/)
 
-  * `dossier_id:`               [Required]   - Unique dossier identifier for the patient to be unsubscribed.
-  * `protocol_subscription_id:` [Required]   - Unique identifier for the protocolsubscription to be stopped.
-
-When stopping the subscription succeeds, the subscription object is available through the `#result` accessor:
-
-    if outcome.valid?
-      subscription = outcome.result
-
-Else the validation errors can be inspected:
-
-    else
-      log_or_display outcome.errors.full_messages
-    end
-
-## Responses
-
-### Index
+### [List](http://roqua.github.io/developer/rom/dossier/responses/#list-all-responses-for-dossier)
 
 To retrieve filled out, pending or scheduled questionnaires run:
 
     outcome = Roqua::RomApi::ListResponses.run dossier_id: dossier_id
 
-#### Parameters
-
- * `dossier_id:`    [Required] - Unique dossier identifier for the patient you want the responses for.
- * `questionnaire_keys`          Only return responses on questionnaires whose key is listed
- * `completed_before`            Only return responses filled out before the specified time
- * `completed_after`             Only return responses filled out after the specified time
- * `respondent_type`             Only return responses whose `completer_type` equals the given value
- * `status`                      ['completed', 'aborted', 'open', 'scheduled'] Only return responses whose `status` equals the given value
- * `protocol_subscription_id`    Only return responses associated to the protocol subscription with the given id
-
-
-When the request succeeds, an array of responses is returned:
-
-    if outcome.valid?
-      responses = outcome.result
-
-Else some validation errors can be shown:
-
-    else
-      log_or_display outcome.errors.full_messages
-    end
-
-### Create
+### [Create](http://roqua.github.io/developer/rom/dossier/responses/#store-a-new-response)
 
 To store an externally filled out questionnaire run:
 
@@ -172,27 +97,7 @@ To store an externally filled out questionnaire run:
                                                 dossier_id: 'dossier_id',
                                                 answer_data: {some: 'aswer_data'}
 
-#### Parameters
-
- * `questionnaire_key:` [Required]  - Key uniquely identifying the questionnaire in RoQua
- * `dossier_id:`        [Required]  - Unique dossier identifier for the patient you want to store the questionnaire for
- * `answer_data:`       [Required]  - Hash storing the answered option key for every question key
- * `filled_out_at:`                   Timestamp indicating the time the questionnaire was filled out (greater or equal to 31 december 1999)
- * `respondent:`        ['patient'(default)|'parent'|'second_parent'|'teacher'|'caregiver']
-                                    - String identifying the respondent which filled out the questionnaire
-
-When the request succeeds, the stored response is returned:
-
-    if outcome.valid?
-      responses = outcome.result
-
-Else some validation errors are provided:
-
-    else
-      log_or_display outcome.errors.full_messages
-    end
-
-### Update
+### [Update](http://roqua.github.io/developer/rom/dossier/responses/#update-a-response)
 
 To store external data on an existing pending response:
 
@@ -201,25 +106,6 @@ To store external data on an existing pending response:
                                                 id: 230, # response id,
                                                 answer_data: {some: 'aswer_data'}
 
-#### Parameters
-
- * `questionnaire_key:` [Required]  - Key uniquely identifying the questionnaire in RoQua
- * `dossier_id:`        [Required]  - Unique dossier identifier for the patient you want to store the questionnaire for
- * `id:`                [Required]  - Id of the response object to update
- * `answer_data:`       [Required]  - Hash storing the answered option key for every question key
- * `filled_out_at:`                   Timestamp indicating the time the questionnaire was filled out (greater or equal to 31 december 1999)
-
-When the request succeeds, the stored response is returned:
-
-    if outcome.valid?
-      responses = outcome.result
-
-Else some validation errors are provided:
-
-    else
-      log_or_display outcome.errors.full_messages
-    end
-
 ## Contributing to roqua-rom-api
 
  * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
@@ -232,5 +118,5 @@ Else some validation errors are provided:
 
 ## Copyright
 
-Copyright (c) 2014 Samuel Esposito. See LICENSE.txt for further details.
+Copyright (c) 2014 RoQua. See LICENSE.txt for further details.
 

data/lib/roqua/rom_api/create_fill_out_request.rb

@@ -3,6 +3,7 @@ module Roqua
     # @api private
     class CreateFillOutRequest < Endpoint
       string    :dossier_id
+      integer   :measurement_sequence_id, default: nil
       array     :questionnaire_keys, default: [] { string }
       string    :respondent_type, default: nil
       string    :callback_url, default: nil
@@ -13,6 +14,7 @@ module Roqua
       def execute
         validate_response_for do
           fill_out_request = {
+            measurement_sequence_id: measurement_sequence_id,
             questionnaire_keys: questionnaire_keys,
             respondent_type: respondent_type,
             callback_url: callback_url,

data/lib/roqua/rom_api/create_measurement_sequence.rb

@@ -0,0 +1,21 @@
+module Roqua
+  module RomApi
+    # @api private
+    class CreateMeasurementSequence < Endpoint
+      string :dossier_id
+      hash   :flags, default: {}, strip: false
+      hash   :textvars, default: {}, strip: false
+
+      def execute
+        validate_response_for do
+          RomApi.basic_auth_session.post("/dossiers/#{dossier_id}/measurement_sequences",
+                                         measurement_sequence: {flags: flags, textvars: textvars})
+        end
+      end
+
+      def response_to_result(response)
+        Models::MeasurementSequence.new(response)
+      end
+    end
+  end
+end

data/lib/roqua/rom_api/models/measurement_sequence.rb

@@ -0,0 +1,13 @@
+module Roqua
+  module RomApi
+    module Models
+      class MeasurementSequence
+        include Virtus.model
+
+        attribute :id, Integer
+        attribute :flags, Hash
+        attribute :textvars, Hash
+      end
+    end
+  end
+end

data/lib/roqua/rom_api/models/protocol_subscription.rb

@@ -12,6 +12,7 @@ module Roqua
         attribute :protocol_name, String
         attribute :flags, Hash
         attribute :textvars, Hash
+        attribute :responses, Array[Response]
       end
     end
   end

data/lib/roqua/rom_api/models.rb

@@ -1,3 +1,4 @@
 require 'roqua/rom_api/models/response'
 require 'roqua/rom_api/models/fill_out_request'
 require 'roqua/rom_api/models/protocol_subscription'
+require 'roqua/rom_api/models/measurement_sequence'

data/lib/roqua/rom_api/sessions/basic_auth_session.rb

@@ -16,25 +16,35 @@ module Roqua
 
         def get(path, params = {})
           perform_request_or_fail do
-            HTTParty.get(full_url_for(path), query: params, basic_auth: basic_auth)
+            HTTParty.get(full_url_for(path),
+                         query: params,
+                         basic_auth: basic_auth)
           end
         end
 
         def post(path, params = {})
           perform_request_or_fail do
-            HTTParty.post(full_url_for(path), body: params, basic_auth: basic_auth)
+            HTTParty.post(full_url_for(path),
+                          headers: {'Content-Type' => 'application/json'},
+                          body: params.to_json,
+                          basic_auth: basic_auth)
           end
         end
 
         def patch(path, params = {})
           perform_request_or_fail do
-            HTTParty.patch(full_url_for(path), body: params, basic_auth: basic_auth)
+            HTTParty.patch(full_url_for(path),
+                           headers: {'Content-Type' => 'application/json'},
+                           body: params.to_json,
+                           basic_auth: basic_auth)
           end
         end
 
         def delete(path, params = {})
           perform_request_or_fail do
-            HTTParty.delete(full_url_for(path), query: params, basic_auth: basic_auth)
+            HTTParty.delete(full_url_for(path),
+                            query: params,
+                            basic_auth: basic_auth)
           end
         end
 

data/lib/roqua/rom_api/start_protocol_subscription.rb

@@ -15,6 +15,10 @@ module Roqua
           RomApi.basic_auth_session.post("/dossiers/#{dossier_id}/protocol_subscriptions", options)
         end
       end
+
+      def response_to_result(response)
+        Models::ProtocolSubscription.new(response)
+      end
     end
   end
 end

data/lib/roqua/rom_api/version.rb

@@ -1,5 +1,5 @@
 module Roqua
   module RomApi
-    VERSION = '0.1.12'
+    VERSION = '0.2.0'
   end
 end

data/lib/roqua/rom_api.rb

@@ -7,6 +7,7 @@ require 'roqua/rom_api/list_protocol_subscriptions'
 require 'roqua/rom_api/list_responses'
 require 'roqua/rom_api/create_response'
 require 'roqua/rom_api/update_response'
+require 'roqua/rom_api/create_measurement_sequence'
 require 'roqua/rom_api/start_fill_out_session'
 require 'roqua/rom_api/create_fill_out_request'
 require 'roqua/rom_api/start_protocol_subscription'

data/spec/lib/roqua/rom_api/start_protocol_subscription_spec.rb

@@ -29,6 +29,7 @@ describe StartProtocolSubscription do
   end
 
   it 'returns the response' do
-    expect(StartProtocolSubscription.run!(options)).to eq(response)
+    subscription = StartProtocolSubscription.run!(options)
+    expect(subscription).to be_a(Models::ProtocolSubscription)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roqua-rom-api
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.2.0
 platform: ruby
 authors:
 - Samuel Esposito
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-28 00:00:00.000000000 Z
+date: 2014-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -142,12 +142,14 @@ files:
 - lib/roqua-rom-api.rb
 - lib/roqua/rom_api.rb
 - lib/roqua/rom_api/create_fill_out_request.rb
+- lib/roqua/rom_api/create_measurement_sequence.rb
 - lib/roqua/rom_api/create_response.rb
 - lib/roqua/rom_api/endpoint.rb
 - lib/roqua/rom_api/list_protocol_subscriptions.rb
 - lib/roqua/rom_api/list_responses.rb
 - lib/roqua/rom_api/models.rb
 - lib/roqua/rom_api/models/fill_out_request.rb
+- lib/roqua/rom_api/models/measurement_sequence.rb
 - lib/roqua/rom_api/models/protocol_subscription.rb
 - lib/roqua/rom_api/models/response.rb
 - lib/roqua/rom_api/report_calculations.rb
@@ -198,7 +200,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.3.0
 signing_key: 
 specification_version: 4
 summary: API wrapper gem around RoQua's ROM API