open_ehr 0.6.1

data/lib/open_ehr/rm/data_types/uri.rb

@@ -0,0 +1,82 @@
+# This module is implemented from this UML:
+#http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109701308832_384250_6986Report.html
+# Ticket refs #46
+require 'uri/generic'
+
+module URI
+  class EHR < ::URI::Generic
+    COMPONENT = [
+      :scheme, :path, :fragment, :query
+    ].freeze
+
+    def self.build(args)
+      tmp = Util::make_components_hash(self, args)
+      super(tmp)
+    end
+
+    def initialize(*arg)
+      super(*arg)
+    end
+
+    def self.use_registry
+      true
+    end
+  end
+  @@schemes['EHR'] = EHR
+end
+
+module OpenEHR
+  module RM
+    module DataTypes
+      module URI
+        class DvUri < OpenEHR::RM::DataTypes::Basic::DataValue
+          def initialize(args = {})
+            self.value = args[:value]
+          end
+
+          def value
+            @value.to_s
+          end
+
+          def fragment_id
+            @value.fragment
+          end
+
+          def path
+            @value.path
+          end
+
+          def query
+            @value.query
+          end
+
+          def scheme
+            @value.scheme
+          end
+
+          def value=(value)
+            raise ArgumentError, "value is empty" if value.nil?
+            parse(value)
+          end
+
+          private
+
+          def parse(value)
+            @value = ::URI.parse(value)
+          end
+        end
+
+        class DvEhrUri < DvUri
+          def initialize(value)
+            super(value)
+          end
+
+          def value=(value)
+            raise ArgumentError, "scheme must be ehr" if !(value =~ /^ehr/i)
+            @value = parse(value)
+          end
+        end # of DV_EHR_URI
+      end # of URI
+    end # of DataTypes
+  end # of RM
+end # of OpenEHR

data/lib/open_ehr/rm/data_types.rb

@@ -0,0 +1,14 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+module OpenEHR
+  module RM
+    module DataTypes
+      autoload :Basic, 'data_types/basic'
+      autoload :Encapsulated, 'data_types/encapsulated'
+      autoload :Quantity, 'data_types/quantity'
+      autoload :Text, 'data_types/text'
+      autoload :TimeSpecification, 'data_types/time_specification'
+      autoload :URI, 'data_types/uri'
+    end
+  end
+end

data/lib/open_ehr/rm/demographic.rb

@@ -0,0 +1,269 @@
+# This module is based on the UML,
+# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_5_76d0249_1118674798473_6021_0Report.html
+# Ticket refs #45
+include OpenEHR::RM::Common::Archetyped
+
+module OpenEHR
+  module RM
+    module Demographic
+      class Party < Locatable
+        attr_reader :uid, :identities, :contacts, :relationships,
+                    :reverse_relationships
+        attr_accessor :details
+        alias :type :name
+
+        def initialize(args = { })
+          super(args)
+          self.uid = args[:uid]
+          self.identities = args[:identities]
+          self.contacts = args[:contacts]
+          self.relationships = args[:relationships]
+          self.reverse_relationships =
+            args[:reverse_relationships]
+          self.details = args[:details]
+        end
+
+        def uid=(uid)
+          raise ArgumentError, 'uid is mandatory' if uid.nil?
+          @uid = uid
+        end
+
+        def identities=(identities)
+          if identities.nil? || identities.empty?
+            raise ArgumentError, 'identities are mandatory'
+          end
+          @identities = identities
+        end
+
+        def contacts=(contacts)
+          if !contacts.nil? && contacts.empty?
+            raise ArgumentError, 'contacts should not be empty'
+          end
+          @contacts = contacts
+        end
+
+        def parent=(parent)
+          @parent = nil
+        end
+
+        def relationships=(relationships)
+          unless relationships.nil?
+            if relationships.empty?
+              raise ArgumentError, 'relationships should not be empty?'
+            else
+              relationships.each do |rel|
+                if rel.source.id.value != @uid.value
+                  raise ArgumentError, 'invalid source of relationships'
+                end
+              end
+            end
+          end
+          @relationships = relationships
+        end
+
+        def reverse_relationships=(reverse_relationships)
+          if !reverse_relationships.nil? && reverse_relationships.empty?
+            raise ArgumentError, 'reverse_relationships should not be empty'
+          end
+          @reverse_relationships = reverse_relationships
+        end
+      end
+
+      class PartyIdentity < Locatable
+        attr_reader :details
+
+        def initialize(args = { })
+          super(args)
+          self.details = args[:details]
+        end
+
+        def details=(details)
+          if details.nil?
+            raise ArgumentError, 'details are mandatory'
+          end
+          @details = details
+        end
+
+        def purpose
+          return @name
+        end
+      end
+
+      class Contact < Locatable
+        attr_accessor :time_validity
+        attr_reader :addresses
+
+        def initialize(args = { })
+          super(args)
+          self.addresses = args[:addresses]
+          self.time_validity = args[:time_validity]
+        end
+
+        def purpose
+          return @name
+        end
+
+        def addresses=(addresses)
+          if addresses.nil? || addresses.empty?
+            raise ArgumentError, 'address is mandatory'
+          end
+          @addresses = addresses
+        end
+      end
+
+      class Address < Locatable
+        attr_reader :details
+
+        def initialize(args = { })
+          super(args)
+          self.details = args[:details]
+        end
+
+        def details=(details)
+          if details.nil?
+            raise ArgumentError, 'details are mandatory'
+          end
+          @details = details
+        end
+
+        def type
+          return @name
+        end
+      end
+
+      class Actor < Party
+        LEAGAL_IDENTITY = 'legal identity'
+        attr_reader :languages, :roles
+
+        def initialize(args = { })
+          super(args)
+          self.roles = args[:roles]
+          self.languages = args[:languages]
+        end
+
+        def roles=(roles)
+          if !roles.nil? && roles.empty?
+            raise ArgumentError, 'roles should not be empty'
+          end
+          @roles = roles
+        end
+
+        def has_legal_identity?
+          @identities.each do |identity|
+            if identity.purpose.value == LEAGAL_IDENTITY
+              return true
+            end
+          end
+          return false
+        end
+
+        def languages=(languages)
+          if !languages.nil? && languages.empty?
+            raise ArgumentError, 'languages should not be empty.'
+          end
+          @languages = languages
+        end
+      end
+
+      class Person < Actor
+
+      end
+
+      class Organisation < Actor
+
+      end
+
+      class Group < Actor
+
+      end
+
+      class Agent < Actor
+
+      end
+
+      class Role < Party
+        attr_reader :performer, :capabilities
+        attr_accessor :time_validity
+
+        def initialize(args = { })
+          super(args)
+          self.performer = args[:performer]
+          self.capabilities = args[:capabilities]
+          self.time_validity = args[:time_validity]
+        end
+
+        def performer=(performer)
+          if performer.nil?
+            raise ArgumentError, 'performer is mandatory'
+          end
+          @performer = performer
+        end
+
+        def capabilities=(capabilities)
+          if !capabilities.nil? && capabilities.empty?
+            raise ArgumentError, 'capability should not be empty'
+          end
+          @capabilities = capabilities
+        end
+      end
+
+      class Capability < Locatable
+        attr_reader :credentials
+        attr_accessor :time_validity
+
+        def initialize(args = { })
+          super(args)
+          self.credentials = args[:credentials]
+          self.time_validity = args[:time_validity]
+        end
+
+        def credentials=(credentials)
+          if credentials.nil?
+            raise ArgumentError, 'credentials are mandatory'
+          end
+          @credentials = credentials
+        end
+      end
+
+      class PartyRelationship < Locatable
+        attr_accessor :details, :time_validity
+        attr_reader :source, :target
+        alias :type :name
+
+        def initialize(args = { })
+          super(args)
+          self.uid = args[:uid]
+          self.details = args[:details]
+          self.time_validity = args[:time_validity]
+          self.source = args[:source]
+          self.target = args[:target]
+        end
+
+        def uid=(uid)
+          if uid.nil?
+            raise ArgumentError, 'uid is mandatory'
+          end
+          @uid = uid
+        end
+
+        def source=(source)
+          if source.nil? or source.id.value != @uid.value
+            raise ArgumentError, 'source is invalid'
+          end
+          @source = source
+        end
+
+        def target=(target)
+          if target.nil?
+            raise ArgumentError, 'taraget is invalid'
+          end
+          @target = target
+        end
+      end
+
+      class VersionedParty < Locatable
+
+      end
+    end # of Demographic
+  end # of RM
+end # of OpenEHR

data/lib/open_ehr/rm/ehr.rb

@@ -0,0 +1,162 @@
+# rm::ehr
+# ehr module
+# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109004889781_854011_47Report.html
+# refs #44
+include OpenEHR::RM::Common::ChangeControl
+include OpenEHR::RM::Common::Archetyped
+include OpenEHR::RM::Security
+
+module OpenEHR
+  module RM
+    module EHR
+      class EHR
+        attr_reader :system_id, :ehr_id, :time_created, :contributions,
+                    :ehr_access, :ehr_status, :compositions, :directory
+
+        def initialize(args = { })
+          self.system_id = args[:system_id]
+          self.ehr_id = args[:ehr_id]
+          self.time_created = args[:time_created]
+          self.contributions = args[:contributions]
+          self.ehr_access = args[:ehr_access]
+          self.ehr_status = args[:ehr_status]
+          self.compositions = args[:compositions]
+          self.directory = args[:directory]
+        end
+
+        def system_id=(system_id)
+          if system_id.nil?
+            raise ArgumentError, 'system_id is mandatory'
+          end
+          @system_id = system_id
+        end
+
+        def ehr_id=(ehr_id)
+          if ehr_id.nil?
+            raise ArgumentError, 'ehr_id is mandatory'
+          end
+          @ehr_id = ehr_id
+        end
+
+        def time_created=(time_created)
+          if time_created.nil?
+            raise ArgumentError, 'time_created is mandatory'
+          end
+          @time_created = time_created
+        end
+
+        def contributions=(contributions)
+          unless contributions.nil?
+            contributions.each do |contrib|
+              unless contrib.type == 'CONTRIBUTION'
+                raise ArgumentError, 'contribution type should be CONTRIBUTION'
+              end
+            end
+            @contributions = contributions
+          else
+            raise ArgumentError, 'contributions are mandatory'
+          end
+        end
+
+        def ehr_access=(ehr_access)
+          if ehr_access.nil? || ehr_access.type != 'VERSIONED_EHR_ACCESS'
+            raise ArgumentError, 'ehr_access is invalid'
+          end
+          @ehr_access = ehr_access
+        end
+
+        def ehr_status=(ehr_status)
+          if ehr_status.nil? || ehr_status.type != 'VERSIONED_EHR_STATUS'
+            raise ArgumentError, 'ehr_status is invalid'
+          end
+          @ehr_status = ehr_status
+        end
+
+        def compositions=(compositions)
+          unless compositions.nil?
+            compositions.each do |compo|
+              unless compo.type == 'VERSIONED_COMPOSITION'
+                raise ArgumentError, 'composition type should be VERSIONED_COMPOSITION'
+              end
+            end
+            @compositions = compositions
+          else
+            raise ArgumentError, 'compositions are mandatory'
+          end
+        end
+
+        def directory=(directory)
+          if !directory.nil? && directory.type != 'VERSIONED_FOLDER'
+            raise ArgumentError, 'invalid directory'
+          end
+          @directory = directory
+        end
+      end
+
+      class VersionedEHRAccesss < VersionedObject
+
+      end
+
+      class EHRAccess < Locatable
+        attr_accessor :settings
+        attr_reader :scheme
+
+        def initialize(args = { })
+          super(args)
+          self.settings = args[:settings]
+          self.scheme = args[:scheme]
+        end
+
+        def scheme=(scheme)
+          if scheme.nil? || scheme.empty?
+            raise ArgumentError, 'scheme is mandatory'
+          end
+          @scheme = scheme
+        end
+      end
+
+      class VersionedEHRStatus < VersionedObject
+
+      end
+
+      class EHRStatus < Locatable
+        attr_reader :subject
+        attr_accessor :is_modifiable, :is_queryable, :other_details
+
+        def initialize(args = { })
+          super(args)
+          self.subject = args[:subject]
+          self.is_queryable = args[:is_queryable]
+          self.is_modifiable = args[:is_modifiable]
+          self.other_details = args[:other_details]
+        end
+
+        def subject=(subject)
+          raise ArgumentError, 'subject is mandatory' if subject.nil?
+          @subject = subject
+        end
+
+        def is_queryable?
+          return @is_queryable
+        end
+
+        def is_modifiable?
+          return @is_modifiable
+        end
+
+        def parent=(parent)
+          unless parent.nil?
+            raise ArgumentError, 'parent should be nil'
+          end
+          @parent = parent
+        end
+      end
+
+      class VersionedComposition < VersionedObject
+        def is_persistent?
+          return @all_versions.first.data.is_persistent?
+        end
+      end
+    end # of EHR
+  end # of RM
+end # of OpenEHR

data/lib/open_ehr/rm/integration.rb

@@ -0,0 +1,27 @@
+# rm::integration
+# integration module
+# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_5_1_76d0249_1140530578205_529440_4046Report.html
+# refs #42
+include OpenEHR::RM::Composition::Content
+
+module OpenEHR
+  module RM
+    module Integration
+      class GenericEntry < ContentItem
+        attr_reader :data
+
+        def initialize(args = { })
+          super(args)
+          self.data = args[:data]
+        end
+
+        def data=(data)
+          if data.nil?
+            raise ArgumentError, 'data are mandatory'
+          end
+          @data = data
+        end
+      end
+    end # of Integration
+  end # of RM
+end # of OpenEHR

data/lib/open_ehr/rm/security.rb

@@ -0,0 +1,12 @@
+# This module is based on the UML,
+# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_5_1_76d0249_1155650882301_836618_5314Report.html
+# Ticket refs #41
+module OpenEHR
+  module RM
+    module Security
+      class AccessControlSettings
+        
+      end
+    end
+  end
+end

data/lib/open_ehr/rm/support/assumed_types.rb

@@ -0,0 +1,81 @@
+# Because his module utilise common methods in both rm
+# and am, I will integrated to /lib/models/assumed_types.rb.
+# By Shinji KOBAYASHI, 2008-07-20
+module OpenEhr
+  module RM
+    module Support
+      module AssumedTypes
+        class Interval
+          attr_accessor :lower, :upper
+#          attr_accessor :lower_included, :lower_unbounded
+#          attr_accessor :upper_included, :upper_unbounded
+          def initialize(lower, upper,
+                         lower_included = nil, upper_included = nil)
+            if ((lower !=nil) && (upper !=nil)) && lower>upper
+              raise ArgumentError, "upper < lower"
+            end
+            @lower = lower
+            @upper = upper
+          end
+        end
+
+        class List
+          attr_reader :content
+
+          def initialize(arg)
+            @content = arg
+          end
+
+          def first
+            @content.first
+          end
+
+          def last
+            @content.last
+          end
+        end
+
+        class TIME_DEFINITIONS
+        end
+
+
+        class ISO8601_DATE < TIME_DEFINITIONS
+        end
+
+        class ISO8601_TIME < TIME_DEFINITIONS
+        end
+
+        class ISO8601_DURATION < TIME_DEFINITIONS
+        end
+
+        class ISO8601_DATE_TIME < TIME_DEFINITIONS
+        end
+
+        class ISO8601_TIMEZONE < TIME_DEFINITIONS
+        end
+
+        class String
+          attr_reader :content
+          def initialize(arg)
+            @content = arg
+          end
+
+          def as_integer
+            is_integer if is_integer
+          end
+
+          def is_empty
+          end
+
+          def is_integer
+            begin
+              Integer(@content)
+            rescue
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/open_ehr/rm/support/definition.rb

@@ -0,0 +1,15 @@
+module OpenEHR
+  module RM
+    module Support
+      module Definition
+        module BasicDefinition
+          CR = "\015"
+          LF = "\012"
+        end
+        class OpenEHRDefinitions
+          include BasicDefinition
+        end
+      end
+    end
+  end
+end