redox 0.1.6 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4cf3d701269f03a48d3cd1fe870e2f124aeb705c643c4cd3826ad5b352317276
-  data.tar.gz: 562cc78ba951b7a58a3365612e09e38f114d7a7ab8ceb80b6e0e1c73b5592c7a
+  metadata.gz: 63503f81ebcb62da585b095cbe53721f14fd4924b6b7f292db34dc28a1fb58a0
+  data.tar.gz: d79801d7d642ada1dd96952fb00882c858a06b6b3a165e9aa634624cd8580872
 SHA512:
-  metadata.gz: fdd640751e3226609ac29cf6be385b7ae52487df1e46fa925e8e984cdf1e0458066f14e16a464dfa43d1201f9b0efcd988442c4eea26fd770a9b57d10e5cfd48
-  data.tar.gz: a339571774b1058f4b646d0d2667bee605def7683c2aa47e152f41bfb3cb51872915a91d120a8b7da5e75c89da0ff0b46ef7292931c3da9cd5941b74fd31b73e
+  metadata.gz: cc2504239a0515d8d951a7d0d181a260ca7719130fd0fffc40d309cf8938c46ebce2d1c402a1864e019d689836f5988857608d6e19c18326f7d00dcc180985a5
+  data.tar.gz: cf26db2a8ee7d9379c01f2af44aa9b25c2b67a6d6b5fc8d09faa5d449dcfb89b6d8ef32e22cebb2f0dda1b68238f0982103a08e4d5d8accbb5635682f73532bd

data/CHANGELOG.md

@@ -4,7 +4,19 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
-## [0.1.6] - Unreleased
+## [1.0.0] - Unreleased
+### Changed
+- How it works
+
+### Added
+- Connection, RedoxClient, Authorization
+- Global configuration block
+- Gems httparty, hashie
+
+### Removed
+- Identifiers, Demographics
+
+## [0.1.6] - 2019-04-22
 ### Added
 - Meta model
 - Response and Authentication classes
@@ -58,7 +70,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 ### Added
 - Initial Release
 
-[Unreleased]: https://github.com/WeInfuse/redox/compare/v0.1.5...HEAD
+[Unreleased]: https://github.com/WeInfuse/redox/compare/v0.1.6...HEAD
+[0.1.6]: https://github.com/WeInfuse/redox/compare/v0.1.5...v0.1.6
 [0.1.5]: https://github.com/WeInfuse/redox/compare/v0.1.4...v0.1.5
 [0.1.4]: https://github.com/WeInfuse/redox/compare/0.1.3...v0.1.4
 [0.1.3]: https://github.com/WeInfuse/redox/compare/0.1.2...0.1.3

data/README.md

@@ -21,34 +21,90 @@ Or install it yourself as:
 
 ## Usage
 
+### Setup
+
+Make sure you're [configured](#configuration)!
+
 ```ruby
-source = {
-  Name: 'Redox Dev Tools',
-  ID: ENV['REDOX_SRC_ID']
-}
+patient = Redox::Models::Patient.new
+patient.demographics.first_name = 'Joe'
+patient.demographics['LastName'] = 'Joerson'
+patient.add_identifier(type: 'TheType', value: 'x13005')
+
+meta = Redox::Models::Meta.new
+meta.set_source(name: 'MySource', id: '123-584')
+meta.add_destination(name: 'TheDest', id: '973-238')
+```
+
+### Create
+
+```ruby
+response = patient.create(meta: meta)
+```
+
+### Update
+
+```ruby
+response = patient.update(meta: meta)
+```
+
+### Search
+
+```ruby
+response = Redox::Models::Patient.query(patient, meta: meta)
+```
+
+### Response
+
+The response object is a base `Redox::Models::Model` class.
+
+With the HTTParty response object
+```ruby
+response.response
+#<HTTParty::Response:0x7fa354c1fbe8>
+
+response.response.ok?
+true
+```
 
-destinations = [
-  {
-    Name: 'Redox EMR',
-    ID: ENV['REDOX_DEST_ID']
+And any `Model` objects that were returned
+```ruby
+response.patient
+{
+  "Identifiers"=> [
+      {"IDType"=>"MR", "ID"=>"0000000003"},
+      {"ID"=>"e3fedf48-c8bf-4728-845f-cb810001b571", "IDType"=>"EHRID"}
+    ],
+  "Demographics"=> {
+    "Race"=>"Black",
+    "SSN"=>"303-03-0003",
+    "Nickname"=>"Walt"
+...
   }
-]
-
-redox = Redox::Redox.new(
-  api_key: ENV['REDOX_KEY'],
-  secret: ENV['REDOX_SECRET'],
-  source: source,
-  destinations: destinations,
-  test: true
-)
-
-redox.add_patient(
-  Identifiers: [...],
-  Demographics: {
-    FirstName: 'Joe'
-    ...
+  "PCP"=> {
+    "NPI"=>nil,
   }
-)
+}
+
+response.meta
+{
+  "EventDateTime"=>"2019-04-26T20:03:00.304866Z",
+  "DataModel"=>"PatientAdmin",
+  ...
+  "Transmission"=>{"ID"=>797225234},
+  "Message"=>{"ID"=>1095117817}
+}
+```
+
+### Configuration
+
+```ruby
+Redox.configure do |c|
+  c.api_key      = ENV['REDOX_API_KEY']
+  c.secret       = ENV['REDOX_SECRET']
+  c.api_endpoint = 'http://hello.com' # Defaults to Redox endpoint
+  c.token_expiry_padding = 120 # Defaults to 60 seconds
+end
 ```
 
 ## Development

data/lib/redox.rb

@@ -1,160 +1,82 @@
-require 'json'
-require 'net/http'
-require 'uri'
-require 'openssl'
+require 'httparty'
+require 'hashie'
 require 'redox/version'
 require 'redox/redox_exception'
+require 'redox/connection'
 require 'redox/authentication'
-require 'redox/response'
 require 'redox/models/model'
 require 'redox/models/meta'
 require 'redox/models/patient'
-require 'redox/models/demographics'
-require 'redox/models/identifiers'
+require 'redox/models/patient/demographics'
+require 'redox/models/patient/identifier'
+require 'redox/models/patient/insurance'
+require 'redox/models/patient/p_c_p'
 
 module Redox
-  # Redox API client
-  class Redox
-    DEFAULT_URI = 'https://api.redoxengine.com/'.freeze
+  class Configuration
+    attr_accessor :api_key, :secret
 
-    # Instantiates a new Redox connection object
-    #
-    # @param [String] api_key API key for the connection
-    # @param [String] secret API secret for the connection
-    # @param [Hash] source source information
-    # @param [Array<Hash>] destinations list of destinations
-    # @param [Boolean] test whether to use test mode
-    # @example
-    #   redox = Redox::Redox.new(
-    #     api_key: ENV['REDOX_KEY'],
-    #     secret: ENV['REDOX_SECRET'],
-    #     source: source,
-    #     destinations: destinations,
-    #     test: true
-    #   )
-    def initialize(api_key:, secret:, source: nil, destinations: nil, facility_code: nil, test: true, uri: DEFAULT_URI)
-      @api_key = api_key
-      @secret = secret
-      @meta   = Models::Meta.new
-      destinations.each {|dest| @meta.add_destination(dest['Name'], dest['ID']) } if destinations
-      @meta.source = source if source
-      @meta.facility_code = facility_code if facility_code
-      @meta.test   = test
-      @connection = nil
-      @authentication = nil
-      @uri = uri
+    def initialize
+      @api_key  =  nil
+      @secret   =  nil
     end
 
-    # Send NewPatient message
-    #
-    # @param [Hash] patient_params data to send in the Patient JSON object
-    # @return [Hash] parsed response object
-    # @example
-    #   Redox::Redox.new(*connection_params).add_patient(
-    #     Identifiers: [],
-    #     Demographics: {
-    #       FirstName: 'Joe'
-    #     }
-    #   )
-    def add_patient(patient_params, meta = nil)
-      meta = @meta.merge(Models::Meta.from_h(Models::Patient::ADD[:meta]).merge(meta))
-      body = meta.to_h.merge(Patient: patient_params)
-
-      return request(
-        endpoint: Models::Patient::ADD[:endpoint],
-        body: body.to_json,
-        model: Models::Patient
-      )
+    def api_endpoint=(endpoint)
+      Connection.base_uri(endpoint.freeze)
     end
 
-    # Send PatientUpdate message
-    #
-    # @param [Hash] patient_params data to send in the Patient JSON object
-    # @return [Hash] parsed response object
-    # @example
-    #   Redox::Redox.new(*connection_params).update_patient(
-    #     Identifiers: [],
-    #     Demographics: {
-    #       FirstName: 'Joe'
-    #     }
-    #   )
-    def update_patient(patient_params, meta = nil)
-      meta = @meta.merge(Models::Meta.from_h(Models::Patient::UPDATE[:meta]).merge(meta))
-      body = meta.to_h.merge(Patient: patient_params)
-
-      return request(
-        endpoint: Models::Patient::UPDATE[:endpoint],
-        body: body.to_json,
-        model: Models::Patient
-      )
+    def api_endpoint
+      return Connection.base_uri
     end
 
-    # Send PatientSearch query
-    #
-    # @param [Hash] patient_params data to send in the Patient JSON object
-    # @return [Hash] Redox Patient object
-    # @example
-    #   Redox::Redox.new(*connection_params).search_patients(
-    #     Identifiers: [],
-    #     Demographics: {
-    #       FirstName: 'Joe'
-    #     }
-    #   )
-    def search_patients(patient_params, meta = nil)
-      meta = @meta.merge(Models::Meta.from_h(Models::Patient::SEARCH[:meta]).merge(meta))
-      body = meta.to_h.merge(Patient: patient_params)
-
-      return request(
-        endpoint: Models::Patient::SEARCH[:endpoint],
-        body: body.to_json,
-        model: Models::Patient
-      )
+    def token_expiry_padding=(time_in_seconds)
+      Authentication.token_expiry_padding = time_in_seconds
     end
 
-    private
-
-    attr_reader :api_key, :secret, :meta
-
-    def request(endpoint: , body: , header: {}, model: nil, authorize: true)
-      header = {
-        'Content-Type' => 'application/json'
-      }.merge(header)
-
-      header = header.merge(authenticate.access_header) if authorize
-
-      request = Net::HTTP::Post.new(endpoint, header)
-      request.body = body
-
-      return Response.new(connection.request(request), model)
+    def token_expiry_padding
+      return Authentication.token_expiry_padding
     end
 
-    def authenticate
-      return @authentication if @authentication
+    def to_h
+      return {
+        api_key: @api_key,
+        secret: @secret,
+        api_endpoint: api_endpoint,
+        token_expiry_padding: token_expiry_padding
+      }
+    end
 
-      redox_response = request(
-        endpoint: Authentication::ENDPOINT,
-        body: { apiKey: api_key, secret: secret }.to_json,
-        model: Authentication,
-        authorize: false
-      )
+    def from_h(h)
+      self.api_key = h[:api_key]
+      self.secret  = h[:secret]
+      self.api_endpoint = h[:api_endpoint]
+      self.token_expiry_padding = h[:token_expiry_padding]
 
-      if (false == redox_response.success?)
-        raise RedoxException.from_response(redox_response.http_response, msg: 'Authentication')
-      end
+      return self
+    end
+  end
 
-      @authentication = redox_response.model
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
     end
 
-    def connection
-      return @connection if @connection
+    def configure
+      yield(configuration)
+    end
+  end
 
-      uri = URI.parse(@uri)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true
-      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-      http.verify_depth = 5
+  # Redox API client
+  class RedoxClient
+    class << self
+      def connection
+        Redox.configuration.token_expiry_padding = 60 if Redox.configuration.token_expiry_padding.nil?
+        @connection ||= Connection.new
+      end
 
-      @connection = http
+      def release
+        @connection = nil
+      end
     end
   end
 end

data/lib/redox/authentication.rb

@@ -1,19 +1,77 @@
 module Redox
-  class Authentication
-    ENDPOINT = '/auth/authenticate'.freeze
+  class Authentication < Connection
+    attr_accessor :response
 
-    def initialize(response_body)
-      @body = response_body
+    BASE_ENDPOINT    = '/auth'.freeze
+
+    AUTH_ENDPOINT    = "#{BASE_ENDPOINT}/authenticate".freeze
+    REFRESH_ENDPOINT = "#{BASE_ENDPOINT}/refreshToken".freeze
+
+    class << self
+      attr_accessor :token_expiry_padding
+
+      @@token_expiry_padding = 0
+    end
+
+    def initialize
+      @response = nil
+    end
+
+    def authenticate
+      if (self.expires?)
+        if (self.refresh_token)
+          request = {
+            body: { apiKey: Redox.configuration.api_key, refreshToken: self.refresh_token },
+            endpoint: REFRESH_ENDPOINT
+          }
+        else
+          request = {
+            body: { apiKey: Redox.configuration.api_key, secret: Redox.configuration.secret },
+            endpoint: AUTH_ENDPOINT
+          }
+        end
+
+        response = self.request(**request, auth: false)
+
+        if (false == response.ok?)
+          @response = nil
+          raise RedoxException.from_response(response, msg: 'Authentication')
+        else
+          @response = response
+        end
+      end
+
+      return self
     end
 
     def access_token
-      return @body['accessToken']
+      return @response['accessToken'] if @response
+    end
+
+    def expiry
+      return @response['expires'] if @response
+    end
+
+    def refresh_token
+      return @response['refreshToken'] if @response
+    end
+
+    def expires?(seconds_from_now = Authentication.token_expiry_padding)
+      if (self.expiry)
+        return DateTime.strptime(self.expiry, Models::Meta::FROM_DATETIME_FORMAT).to_time.utc <= (Time.now + seconds_from_now).utc
+      else
+        return true
+      end
     end
 
     def access_header
       return {
-        'Authorization' => "Bearer #{access_token}",
+        'Authorization' => "Bearer #{self.access_token}",
       }
     end
+
+    def expire!
+      @response = nil
+    end
   end
 end

data/lib/redox/connection.rb

@@ -0,0 +1,28 @@
+module Redox
+  class Connection
+    DEFAULT_ENDPOINT = '/endpoint'.freeze
+
+    include HTTParty
+
+    base_uri 'https://api.redoxengine.com/'.freeze
+
+    headers 'Content-Type' => 'application/json'
+
+    format :json
+
+    def request(endpoint: DEFAULT_ENDPOINT, body: nil, headers: {}, auth: true)
+      body    = body.to_json if body.is_a?(Hash)
+      headers = auth_header.merge(headers) if auth
+
+      self.class.post(endpoint, body: body, headers: headers)
+    end
+
+    private
+
+    def auth_header
+      @auth ||= Authentication.new
+
+      return @auth.authenticate.access_header
+    end
+  end
+end

data/lib/redox/models/meta.rb

@@ -1,79 +1,45 @@
 module Redox
   module Models
     class Meta < Model
-      KEY = 'Meta'.freeze
-
-      DEFAULT = -> () {
-        return {
-          KEY => {
-            'DataModel' => nil,
-            'EventType' => nil,
-            'EventDateTime' => Time.now.strftime("%Y-%m-%dT%H:%M:%S.%6NZ"),
-            'Test' => true,
-            'Source' => {},
-            'Destinations' => [],
-            'FacilityCode' => nil
-          }
-        }
-      }
-
-      def initialize(data = DEFAULT.call)
-        super(data)
-      end
-
-      def add_destination(name, id)
-        self.inner['Destinations'] << Meta.build_subscription(name, id)
+      TO_DATETIME_FORMAT   = '%Y-%m-%dT%H:%M:%S.%6NZ'.freeze
+      FROM_DATETIME_FORMAT = '%Y-%m-%dT%H:%M:%S.%N%Z'.freeze
+
+      property :DataModel, from: :data_model, required: false
+      property :EventType, from: :event_type, required: false
+      property :EventDateTime, from: :event_date_time, default: ->() { Time.now.utc.strftime(TO_DATETIME_FORMAT) }
+      property :Test, from: :test, default: true
+      property :Source, from: :source, required: false
+      property :Destinations, from: :destinations, required: false
+      property :FacilityCode, from: :facility_code, required: false
+
+      alias_method :data_model, :DataModel
+      alias_method :event_type, :EventType
+      alias_method :event_date_time, :EventDateTime
+      alias_method :test, :Test
+      alias_method :source, :Source
+      alias_method :destinations, :Destinations
+      alias_method :facility_code, :FacilityCode
+
+      def add_destination(name: , id: )
+        self[:Destinations] ||= []
+        self[:Destinations] << Meta.build_subscription(name: name, id: id)
 
         return self
       end
 
-      def set_source(name, id)
-        self.source = Meta.build_subscription(name, id)
-
-        return self
-      end
-
-      def source=(source)
-        self.inner['Source'] = source
-      end
-
-      def facility_code=(facility_code)
-        self.inner['FacilityCode'] = facility_code.to_s
-      end
-
-      def test=(test)
-        self.inner['Test'] = (true == test)
-      end
-
-      def merge(other)
-        if (other.is_a?(Hash))
-          if (other.include?(KEY))
-            self.inner.merge!(other[KEY])
-          else
-            self.inner.merge!(other)
-          end
-        elsif (other.is_a?(self.class))
-          self.inner.merge!(other.inner.select {|k,v| !v.nil?})
-        end
+      def set_source(name: , id: )
+        self[:Source] = Meta.build_subscription(name: name, id: id)
 
         return self
       end
 
-      def to_h
-        return JSON.parse(@data.to_json)
-      end
-
       class << self
-        def build_subscription(name, id)
+        def build_subscription(name: , id:)
           return {
             'ID' => id,
             'Name' => name
           }
         end
-
-        def from_h(hash)
-          return Meta.new.merge(hash)
-        end
       end
     end
   end

data/lib/redox/models/model.rb

@@ -1,27 +1,53 @@
 module Redox
   module Models
-    class Model
-      KEY = nil
+    class Model < Hashie::Trash
+      include Hashie::Extensions::IgnoreUndeclared
+      include Hashie::Extensions::IndifferentAccess
 
-      def initialize(data)
-        @data = data.freeze
+      property :Meta, from: :meta, required: false
+      property :Patient, from: :patient, required: false
+      property :response, required: false
+
+      alias_method :patient, :Patient
+      alias_method :meta, :Meta
+
+      def initialize(data = {})
+        if (data.is_a?(Hash) && data.include?(key))
+          data = data[key]
+        end
+
+        super(data)
       end
 
-      def valid?
-        return @data.is_a?(Hash) && @data.include?(self.class::KEY)
+      def to_h
+        return {"#{key}" => super.to_h}
       end
 
-      def raw
-        return self.inner(key: nil)
+      def to_json
+        return self.to_h.to_json
       end
 
-      def inner(key: self.class::KEY)
-        if key.nil?
-          return @data
-        else
-          return @data[key]
+      class << self
+        def from_response(response)
+          model = Model.new
+          model.response = response
+
+          %w[Meta Patient].each do |k|
+            begin
+              model.send("#{k}=", Module.const_get("Redox::Models::#{k}").new(response[k])) if response[k]
+            rescue
+            end
+          end
+
+          return model
         end
       end
+
+      private
+
+      def key
+        return self.class.to_s.split('::').last
+      end
     end
   end
 end

data/lib/redox/models/patient.rb

@@ -1,40 +1,60 @@
 module Redox
   module Models
     class Patient < Model
-      attr_reader :demographics, :identifiers
-
-      KEY = 'Patient'.freeze
-
-      SEARCH = {
-        meta: {
-          'DataModel' => 'PatientSearch',
-          'EventType' => 'Query'
-        },
-        endpoint: '/query'
-      }
-
-      ADD = {
-        meta: {
-          'DataModel' => 'PatientAdmin',
-          'EventType' => 'NewPatient'
-        },
-        endpoint: '/endpoint'
-      }
-
-      UPDATE = {
-        meta: {
-          'DataModel' => 'PatientAdmin',
-          'EventType' => 'PatientUpdate'
-        },
-        endpoint: '/endpoint'
-      }
-
-      def initialize(data)
-        super(data)
-
-        if (self.valid?)
-          @demographics = Demographics.new(self.inner)
-          @identifiers  = Identifiers.new(self.inner)
+      QUERY_ENDPOINT = '/query'.freeze
+      QUERY_META     = Meta.new(EventType: 'Query', DataModel: 'PatientSearch')
+      CREATE_META    = Meta.new(EventType: 'NewPatient', DataModel: 'PatientAdmin')
+      UPDATE_META    = Meta.new(EventType: 'PatientUpdate', DataModel: 'PatientAdmin')
+
+      property :Identifiers, from: :identifiers, required: false, default: []
+      property :Insurances, from: :insurances, required: false, default: []
+      property :Demographics, from: :demographics, required: false
+      property :PCP, from: :primary_care_provider, required: false
+
+      alias_method :identifiers, :Identifiers
+      alias_method :insurances, :Insurances
+
+      def demographics
+        self[:Demographics] = Demographics.new(self[:Demographics]) unless self[:Demographics].is_a?(Redox::Models::Demographics)
+        self[:Demographics] ||= Demographics.new
+      end
+
+      def primary_care_provider
+        self[:PCP] ||= PCP.new
+      end
+
+      def add_identifier(type: , value: )
+        self[:Identifiers] << Identifier.new({'ID' => value, 'IDType' => type})
+
+        return self
+      end
+
+      def add_insurance(data = {})
+        self[:Insurances] << Insurance.new(data)
+
+        return self
+      end
+
+      def update(meta: Meta.new)
+        meta = UPDATE_META.merge(meta)
+        return Model.from_response((RedoxClient.connection.request(body: Patient.body(self, meta))))
+      end
+
+      def create(meta: Meta.new)
+        meta = CREATE_META.merge(meta)
+        return Model.from_response((RedoxClient.connection.request(body: Patient.body(self, meta))))
+      end
+
+      class << self
+        def query(params, meta: Meta.new)
+          meta = QUERY_META.merge(meta)
+          return Model.from_response((RedoxClient.connection.request(endpoint: QUERY_ENDPOINT, body: Patient.body(params, meta))))
+        end
+
+        def body(params, meta)
+          meta = Meta.new.merge(meta)
+
+          return meta.to_h.merge(params.to_h)
         end
       end
     end

data/lib/redox/models/patient/demographics.rb

@@ -0,0 +1,34 @@
+module Redox
+  module Models
+    class Demographics < Model
+      property :FirstName, required: false, from: :first_name
+      property :MiddleName, required: false, from: :middle_name
+      property :LastName, required: false, from: :last_name
+      property :DOB, required: false, from: :dob
+      property :SSN, required: false, from: :ssn
+      property :Sex, required: false, from: :sex
+      property :Race, required: false, from: :race
+      property :IsHispanic, required: false
+      property :MaritalStatus, required: false, from: :martial_status
+      property :IsDeceased, required: false
+      property :DeathDateTime, required: false
+      property :Language, required: false, from: :language
+      property :EmailAddresses, required: false, default: []
+      property :Citizenship, required: false, default: []
+      property :Address, required: false, default: {}
+      property :PhoneNumber, required: false, default: {}
+
+      alias_method :first_name, :FirstName
+      alias_method :middle_name, :MiddleName
+      alias_method :last_name, :LastName
+      alias_method :dob, :DOB
+      alias_method :ssn, :SSN
+      alias_method :sex, :Sex
+      alias_method :race, :Race
+      alias_method :martial_status, :MaritalStatus
+      alias_method :language, :Language
+      alias_method :address, :Address
+      alias_method :phone_number, :PhoneNumber
+    end
+  end
+end

data/lib/redox/models/patient/identifier.rb

@@ -0,0 +1,11 @@
+module Redox
+  module Models
+    class Identifier < Model
+      property :ID, from: :id
+      property :IDType, from: :id_type
+
+      alias_method :id, :ID
+      alias_method :id_type, :IDType
+    end
+  end
+end

data/lib/redox/models/patient/insurance.rb

@@ -0,0 +1,29 @@
+module Redox
+  module Models
+    class Insurance < Model
+      property :Plan, required: false, from: :plan, default: {}
+      property :MemberNumber, required: false, from: :member_number
+      property :Company, required: false, from: :company, default: {}
+      property :GroupNumber, required: false, from: :group_number
+      property :GroupName, required: false, from: :group_name
+      property :EffectiveDate, required: false, from: :effective_date
+      property :ExpirationDate, required: false, from: :expiration_date
+      property :PolicyNumber, required: false, from: :policy_number
+      property :AgreementType, required: false, from: :agreement_type
+      property :CoverageType, required: false, from: :coverage_type
+      property :Insured, required: false, from: :insured, default: {}
+
+      alias_method :plan, :Plan
+      alias_method :member_number, :MemberNumber
+      alias_method :company, :Company
+      alias_method :group_number, :GroupNumber
+      alias_method :group_name, :GroupName
+      alias_method :effective_date, :EffectiveDate
+      alias_method :expiration_date, :ExpirationDate
+      alias_method :policy_number, :PolicyNumber
+      alias_method :agreement_type, :AgreementType
+      alias_method :coverage_type, :CoverageType
+      alias_method :insured, :Insured
+    end
+  end
+end

data/lib/redox/models/patient/p_c_p.rb

@@ -0,0 +1,13 @@
+module Redox
+  module Models
+    class PCP < Model
+      property :NPI, from: :npi
+      property :FirstName, required: false, from: :first_name
+      property :LastName, required: false, from: :last_name
+
+      alias_method :npi, :NPI
+      alias_method :first_name, :FirstName
+      alias_method :last_name, :LastName
+    end
+  end
+end

data/lib/redox/version.rb

@@ -1,3 +1,3 @@
 module Redox
-  VERSION = '0.1.6'.freeze
+  VERSION = '1.0.0'.freeze
 end

data/redox.gemspec

@@ -26,6 +26,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.add_dependency 'httparty'
+  spec.add_dependency 'hashie'
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'byebug'
   spec.add_development_dependency 'minitest', '~> 5.0'

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: redox
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 1.0.0
 platform: ruby
 authors:
 - Alexander Clark
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-04-22 00:00:00.000000000 Z
+date: 2019-05-01 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -113,11 +141,14 @@ files:
 - bin/setup
 - lib/redox.rb
 - lib/redox/authentication.rb
-- lib/redox/models/demographics.rb
-- lib/redox/models/identifiers.rb
+- lib/redox/connection.rb
 - lib/redox/models/meta.rb
 - lib/redox/models/model.rb
 - lib/redox/models/patient.rb
+- lib/redox/models/patient/demographics.rb
+- lib/redox/models/patient/identifier.rb
+- lib/redox/models/patient/insurance.rb
+- lib/redox/models/patient/p_c_p.rb
 - lib/redox/redox_exception.rb
 - lib/redox/response.rb
 - lib/redox/version.rb

data/lib/redox/models/demographics.rb

@@ -1,7 +0,0 @@
-module Redox
-  module Models
-    class Demographics < Model
-      KEY = 'Demographics'.freeze
-    end
-  end
-end

data/lib/redox/models/identifiers.rb

@@ -1,7 +0,0 @@
-module Redox
-  module Models
-    class Identifiers < Model
-      KEY = 'Identifiers'.freeze
-    end
-  end
-end