open_ehr 0.6.1

data/lib/open_ehr/rm/common/generic.rb

@@ -0,0 +1,216 @@
+# This module is a implementation of the bellow UML
+# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_5_1_76d0249_1140169202660_257304_813Report.html
+# Related to the ticket #62
+include OpenEHR::RM::Support::Identification
+include OpenEHR::RM::DataTypes::Basic
+module OpenEHR
+  module RM
+    module Common
+      module Generic
+        class AuditDetails
+          attr_reader :system_id, :committer, :time_committed, :change_type
+          attr_accessor :description
+
+          def initialize(args = { })
+            self.system_id = args[:system_id]
+            self.committer = args[:committer]
+            self.time_committed = args[:time_committed]
+            self.change_type = args[:change_type]
+            self.description = args[:description]
+          end
+
+          def system_id=(system_id)
+            if system_id.nil? or system_id.empty?
+              raise ArgumentError, 'system_id is mandatory'
+            end
+            @system_id = system_id
+          end
+
+          def committer=(committer)
+            raise ArgumentError, 'committer is mandatory' if committer.nil?
+            @committer = committer
+          end
+
+          def time_committed=(time_committed)
+            if time_committed.nil?
+              raise ArgumentError, 'time_committed is mandatory'
+            end
+            @time_committed = time_committed
+          end
+             
+          def change_type=(change_type)
+            raise ArgumentError, 'change_type is mandatory' if change_type.nil?
+            @change_type = change_type
+          end
+        end
+
+        class RevisionHistory
+          attr_reader :items
+
+          def initialize(args = { })
+            self.items = args[:items]
+          end
+
+          def items=(items)
+            if items.nil? or items.empty?
+              raise ArgumentError, 'item(s) is/are mandatory'
+            end
+            @items  = items
+          end
+
+          def most_recent_version
+            return @items.last.version_id.value
+          end
+
+          def most_recent_version_time_committed
+            return @items.last.audits.first.time_committed.value
+          end
+        end # of RevisionHistory
+
+        class RevisionHistoryItem
+          attr_reader :version_id, :audits
+
+          def initialize(args = { })
+            self.version_id = args[:version_id]
+            self.audits = args[:audits]
+          end
+
+          def audits=(audits)
+            if audits.nil? or audits.empty?
+              raise ArgumentError, 'audits is mandatory'
+            end
+            @audits = audits
+          end
+
+          def version_id=(version_id)
+            raise ArgumentError, 'version_id is mandatory' if version_id.nil?
+            @version_id = version_id
+          end
+        end # of RevisionHistory_Item
+
+        class PartyProxy
+          attr_accessor :external_ref
+
+          def initialize(args = { })
+            self.external_ref = args[:external_ref]
+          end
+        end
+
+        class PartySelf < PartyProxy
+
+        end
+
+        class PartyIdentified < PartyProxy
+          attr_reader :name, :identifier
+
+          def initialize(args = { })
+            if args[:external_ref].nil? && args[:name].nil? &&
+                args[:identifier].nil?
+              raise ArgumentError, 'cannot identified'
+            end
+            self.name = args[:name]
+            self.identifier = args[:identifier]
+            super(args)
+          end
+
+          def name=(name)
+            if name.nil? && @external_ref.nil? && @identifier.nil?
+              raise ArgumentError, 'cannot identified'
+            end
+            raise ArgumentError, 'invaild name' unless name.nil? || !name.empty?
+            @name = name
+          end
+
+          def identifier=(identifier)
+            if @name.nil? && @external_ref.nil? && identifier.nil?
+              raise ArgumentError, 'cannot identified'
+            end
+            if !identifier.nil? && identifier.empty?
+              raise ArgumentError, 'invaild identifier'
+            end
+            @identifier = identifier
+          end
+
+          def external_ref=(external_ref)
+            if @name.nil? && @identifier.nil? && external_ref.nil?
+              raise ArgumentError, 'invalid external_ref'
+            end
+            @external_ref = external_ref
+          end
+        end
+
+        class PartyRelated < PartyIdentified
+          attr_reader :relationship
+          def initialize(args = { })
+            super(args)
+            self.relationship = args[:relationship]
+          end
+
+          def relationship=(relationship)
+            if relationship.nil?
+              raise ArgumentError, 'relationship must not be nil'
+            end
+            @relationship = relationship
+          end
+        end
+
+        class Participation
+          attr_reader :performer, :function, :mode
+          attr_accessor :time
+
+          def initialize(args ={ })
+            self.performer = args[:performer]
+            self.function = args[:function]
+            self.mode = args[:mode]
+            self.time = args[:time]
+          end
+
+          def performer=(performer)
+            raise ArgumentError, 'performer is mandatory' if performer.nil?
+            @performer = performer
+          end
+
+          def function=(function)
+            raise ArgumentError, 'function is mandatory' if function.nil?
+            @function = function
+          end
+
+          def mode=(mode)
+            raise ArgumentError, 'mode is mandatory' if mode.nil?
+            @mode = mode
+          end
+        end
+
+        class Attestation < AuditDetails
+          attr_reader :reason
+          attr_accessor :proof, :attested_view, :is_pending, :items
+
+          def initialize(args = { })
+            super(args)
+            self.reason = args[:reason]
+            self.proof = args[:proof]
+            self.items = args[:items]
+            self.attested_view = args[:attested_view]
+            self.is_pending = args[:is_pending]
+          end
+
+          def reason=(reason)
+            raise ArgumentError, 'reason is mandatory' if reason.nil?
+            @reason = reason
+          end
+
+          def items=(items)
+            if !items.nil? && items.empty?
+              raise ArgumentError, 'items should not be empty'
+            end
+            @items = items
+          end
+          
+          def is_pending?
+            return is_pending
+          end
+        end
+      end # of Generic
+    end # of Common
+  end # of RM
+end # of OpenEHR

data/lib/open_ehr/rm/common/resource.rb

@@ -0,0 +1,154 @@
+require 'set'
+module OpenEHR
+  module RM
+    module Common
+      module Resource
+        class AuthoredResource
+          attr_reader  :original_language, :translations
+          attr_accessor :description, :revision_history
+
+          def initialize(args = { })
+            self.original_language = args[:original_language]
+            self.translations = args[:translations]
+            self.revision_history = args[:revision_history]
+            self.description = args[:description]
+          end
+
+          def original_language=(original_language)
+            if original_language.nil?
+              raise ArgumentError, 'original language is mandatory'
+            end
+            @original_language = original_language
+          end
+
+          def translations=(translations)
+            if !translations.nil? && translations.empty?
+              raise ArgumentError, 'translation is empty'
+            end
+            @translations = translations
+          end
+
+          def current_revision
+            @revision_history.most_recent_version
+          end
+
+          def languages_available
+            return Set.new(@translations.keys) << original_language.code_string
+          end
+
+          def is_controlled?
+            return !@revision_history.nil?
+          end
+        end
+
+        class TranslationDetails
+          attr_reader :language, :author
+          attr_accessor :accreditation, :other_details
+
+          def initialize(args = {})
+            self.language = args[:language]
+            self.author = args[:author]
+            self.accreditation = args[:accreditation]
+            self.other_details = args[:other_details]
+          end
+
+          def language=(language)
+            raise ArgumentError, 'language is mandatory' if language.nil?
+            @language = language
+          end
+
+          def author=(author)
+            raise ArgumentError, 'author is mandatory' if author.nil?
+            @author = author
+          end
+        end
+
+        class ResourceDescription
+          attr_reader :original_author, :lifecycle_state, :details
+          attr_accessor :other_contributors, :resource_package_uri,
+                        :other_details, :parent_resource
+
+          def initialize(args = {})
+            self.original_author = args[:original_author]
+            self.lifecycle_state = args[:lifecycle_state]
+            self.details = args[:details]
+            self.other_contributors = args[:other_contributors]
+            self.resource_package_uri = args[:resource_package_uri]
+            self.other_details = args[:other_details]
+            self.parent_resource = args[:parent_resource]
+          end
+
+          def original_author=(original_author)
+            if original_author.nil? || original_author.empty?
+              raise ArgumentError, 'original_author is mandatory'
+            end
+            @original_author = original_author
+          end
+
+          def lifecycle_state=(lifecycle_state)
+            if lifecycle_state.nil? || lifecycle_state.empty?
+              raise ArgumentError, 'lifecycle_state is malformatted'
+            end
+            @lifecycle_state = lifecycle_state
+          end
+
+          def details=(details)
+            if details.nil? || details.empty?
+              raise ArgumentError, 'nil or empty details'
+            end
+            @details = details
+          end
+        end
+
+        class ResourceDescriptionItem
+          attr_reader :language, :purpose, :use, :misuse, :copyright
+          attr_accessor :keywords, :original_resource_uri, :other_details
+
+          def initialize(args = { })
+            self.language = args[:language]
+            self.purpose = args[:purpose]
+            self.keywords = args[:keywords]
+            self.use = args[:use]
+            self.misuse = args[:misuse]
+            self.copyright = args[:copyright]
+            self.original_resource_uri = args[:original_resource_uri]
+            self.other_details = args[:other_details]
+          end
+
+          def language=(language)
+            raise ArgumentError, 'language is mandatory' if language.nil?
+            @language = language
+          end
+
+          def purpose=(purpose)
+            if purpose.nil? || purpose.empty?
+              raise ArgumentError, 'purpose is mandatory'
+            end
+            @purpose = purpose
+          end
+
+          def use=(use)
+            if !use.nil? && use.empty?
+              raise ArgumentError, 'use is invalid'
+            end
+            @use = use
+          end
+
+          def misuse=(misuse)
+            if !misuse.nil? && misuse.empty?
+              raise ArgumentError, 'misuse is invalid'
+            end
+            @misuse = misuse
+          end
+
+          def copyright=(copyright)
+            if !copyright.nil? && copyright.empty?
+              raise ArgumentError, 'copyright is invalid'
+            end
+            @copyright = copyright
+          end
+        end
+      end # end of Resouce
+    end # end of module Common
+  end # end of module RM
+end # end of module OpenEHR

data/lib/open_ehr/rm/common.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 Common
+      autoload :Archetyped, 'common/archetyped'
+      autoload :ChangeControl, 'common/change_control'
+      autoload :Directory, 'common/directory'
+      autoload :Generic, 'common/generic.rb'
+      autoload :Resource, 'common/resource'
+    end
+  end
+end

data/lib/open_ehr/rm/composition/content/entry.rb

@@ -0,0 +1,246 @@
+# rm::composition::content::entry
+# entry module
+# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109264528523_312165_346Report.html
+# refs #56
+include OpenEHR::RM::Composition::Content
+
+module OpenEHR
+  module RM
+    module Composition
+      module Content
+        module Entry
+          class Entry < ContentItem
+            attr_reader :language, :encoding, :subject
+            attr_accessor :provider, :other_participations, :workflow_id
+            def initialize(args = { })
+              super(args)
+              self.language = args[:language]
+              self.encoding = args[:encoding]
+              self.subject = args[:subject]
+              self.provider = args[:provider]
+              self.other_participations = args[:other_participations]
+              self.workflow_id = args[:workflow_id]
+            end
+
+            def language=(language)
+              raise ArgumentError, 'language is mandatory' if language.nil?
+              @language = language
+            end
+
+            def encoding=(encoding)
+              raise ArgumentError, 'encoding is mandatory' if encoding.nil?
+              @encoding = encoding
+            end
+
+            def subject=(subject)
+              raise ArgumentError, 'subject is mandatory' if subject.nil?
+              @subject = subject
+            end
+
+            def subject_is_self?
+              return @subject.instance_of? PartySelf
+            end
+          end
+
+          class AdminEntry < Entry
+            attr_reader :data
+
+            def initialize(args = { })
+              super(args)
+              self.data = args[:data]
+            end
+
+            def data=(data)
+              raise ArgumentError, 'data are mandatory' if data.nil?
+              @data = data
+            end
+          end
+          class CareEntry < Entry
+            attr_accessor :protocol, :guideline_id
+
+            def initialize(args = { })
+              super(args)
+              self.protocol = args[:protocol]
+              self.guideline_id = args[:guideline_id]
+            end
+          end
+
+          class Observation < CareEntry
+            attr_reader :data
+            attr_accessor :state
+
+            def initialize(args = { })
+              super(args)
+              self.data = args[:data]
+              self.state = args[:state]
+            end
+
+            def data=(data)
+              raise ArgumentError, 'data are mandatory' if data.nil?
+              @data = data
+            end
+          end
+
+          class Evaluation < CareEntry
+            attr_reader :data
+
+            def initialize(args = { })
+              super(args)
+              self.data = args[:data]
+            end
+
+            def data=(data)
+              raise ArgumentError, 'data are mandatory' if data.nil?
+              @data = data
+            end
+          end
+
+          class Instruction < CareEntry
+            attr_reader :narrative, :activities
+            attr_accessor :expiry_time, :wf_definition
+
+            def initialize(args = { })
+              super(args)
+              self.narrative = args[:narrative]
+              self.activities = args[:activities]
+              self.expiry_time = args[:expiry_time]
+              self.wf_definition = args[:wf_definition]
+            end
+
+            def narrative=(narrative)
+              if narrative.nil?
+                raise ArgumentError, 'narrative is mandatory'
+              end
+              @narrative = narrative
+            end
+
+            def activities=(activities)
+              if !activities.nil? && activities.empty?
+                raise ArgumentError, 'activities should not be empty'
+              end
+              @activities = activities
+            end
+          end
+
+          class Activity < Locatable
+            attr_reader :description, :timing, :action_archetype_id
+
+            def initialize(args = { })
+              super(args)
+              self.description = args[:description]
+              self.timing = args[:timing]
+              self.action_archetype_id = args[:action_archetype_id]
+            end
+
+            def description=(description)
+              if description.nil?
+                raise ArgumentError, 'description is mandatory'
+              end
+              @description = description
+            end
+
+            def timing=(timing)
+              if timing.nil?
+                raise ArgumentError, 'timing is mandatory'
+              end
+              @timing = timing
+            end
+          end
+
+          def action_archetype_id=(action_archetype_id)
+            if action_archetype_id.nil? || action_archetype_id.empty?
+              raise ArgumentError, 'action_archetype_id is mandatory'
+            end
+            @action_archetype_id = action_archetype_id
+          end
+
+          class Action < CareEntry
+            attr_reader :time, :description, :ism_transition
+            attr_accessor :instruction_details
+            
+            def initialize(args = { })
+              super(args)
+              self.description = args[:description]
+              self.time = args[:time]
+              self.ism_transition = args[:ism_transition]
+              self.instruction_details = args[:instruction_details]
+            end
+
+            def time=(time)
+              if time.nil?
+                raise ArgumentError, 'time is mandatory'
+              end
+              @time = time
+            end
+
+            def description=(description)
+              if description.nil?
+                raise ArgumentError, 'description is mandatory'
+              end
+              @description = description
+            end
+
+            def ism_transition=(ism_transition)
+              if ism_transition.nil?
+                raise ArgumentError
+              end
+              @ism_transition = ism_transition
+            end
+          end
+
+          class InstructionDetails < Pathable
+            attr_reader :instruction_id, :activity_id
+            attr_accessor :wf_details
+
+            def initialize(args = { })
+              super(args)
+              self.instruction_id = args[:instruction_id]
+              self.activity_id = args[:activity_id]
+              self.wf_details = args[:wf_details]
+            end
+
+            def instruction_id=(instruction_id)
+              if instruction_id.nil?
+                raise ArgumentError, 'instruction_id is mandatory'
+              end
+              @instruction_id = instruction_id
+            end
+
+            def activity_id=(activity_id)
+              if activity_id.nil? || activity_id.empty?
+                raise ArgumentError, 'activity_id is mandatory'
+              end
+              @activity_id = activity_id
+            end
+          end
+
+          class IsmTransition < Pathable
+            attr_reader :current_state, :transition
+            attr_accessor :careflow_step
+
+            def initialize(args = { })
+              super(args)
+              self.current_state = args[:current_state]
+              self.transition = args[:transition]
+              self.careflow_step = args[:careflow_step]
+            end
+
+            def current_state=(current_state)
+              if current_state.nil?
+                raise ArgumentError, 'current_state is mandatory'
+              end
+              @current_state = current_state
+            end
+
+            def transition=(transition)
+              if transition.nil?
+                raise ArgumentError, 'transition is mandatory'
+              end
+              @transition = transition
+            end
+          end
+        end # of Entry
+      end # of Content
+    end # of Composition
+  end # of RM
+end # of OpenEHR

data/lib/open_ehr/rm/composition/content/navigation.rb

@@ -0,0 +1,31 @@
+# rm::composition::content::navigation
+# navigation module
+# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109264528523_312165_346Report.html
+# refs #56
+include OpenEHR::RM::Composition::Content
+
+module OpenEHR
+  module RM
+    module Composition
+      module Content
+        module Navigation
+          class Section < ContentItem
+            attr_reader :items 
+
+            def initialize(args = { })
+              super(args)
+              self.items = args[:items]
+            end
+
+            def items=(items)
+              if !items.nil? && items.empty?
+                raise ArgumentError, 'items should not be empty'
+              end
+              @items = items
+            end
+          end
+        end
+      end # end of Content
+    end # end of Composition
+  end # end of RM
+end # end of OpenEHR

data/lib/open_ehr/rm/composition/content.rb

@@ -0,0 +1,22 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+# rm::composition::content
+# content module
+# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_5_1_76d0249_1140524925046_706492_3290Report.html
+# refs #58
+include OpenEHR::RM::Common::Archetyped
+
+module OpenEHR
+  module RM
+    module Composition
+      module Content
+        autoload :Navigation, 'content/navigation'
+        autoload :Entry, 'content/entry'
+
+        class ContentItem < Locatable
+
+        end
+      end # end of Content
+    end # end of Composition
+  end # end of RM
+end # end of OpenEHR