openehr 1.1.0

data/lib/openehr/rm/common/directory.rb

@@ -0,0 +1,29 @@
+# This module is based on the UML,
+# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_5_1_76d0249_1140536622627_218703_7149Report.html
+# Ticket refs #63
+include OpenEHR::RM::DataTypes::Text
+module OpenEHR
+  module RM
+    module Common
+      module Directory
+        class Folder < OpenEHR::RM::Common::Archetyped::Locatable
+          attr_accessor :items
+          attr_reader :folders
+
+          def initialize(args = { })
+            super(args)
+            self.folders = args[:folders]
+            self.items = args[:items]
+          end
+
+          def folders=(folders)
+            raise ArgumentError, "empty subfolder" if !folders.nil? and folders.empty?
+            @folders = folders
+          end
+        end        
+        class VersionedFolder < OpenEHR::RM::Common::ChangeControl::VersionedObject
+        end
+      end # of Directory
+    end # of Common
+  end # of RM
+end # of OpenEHR

data/lib/openehr/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/openehr/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/openehr/rm/composition.rb

@@ -0,0 +1,103 @@
+# rm::composition
+# composition module
+# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109005072243_448526_217Report.html
+# refs #79
+include OpenEHR::RM::Common::Archetyped
+module OpenEHR
+  module RM
+    module Composition
+      class Composition < Locatable
+        attr_reader :language, :category, :territory, :composer
+        attr_accessor :content, :context
+
+        def initialize(args = { })
+          super(args)
+          self.language = args[:language]
+          self.category = args[:category]
+          self.territory = args[:territory]
+          self.composer = args[:composer]
+          self.content = args[:content]
+          self.context = args[:context]
+        end
+
+        def language=(language)
+          if language.nil?
+            raise ArgumentError, 'language is mandatory'
+          end
+          @language = language
+        end
+
+        def category=(category)
+          if category.nil?
+            raise ArgumentError, 'category is mandatory'
+          end
+          @category = category
+        end
+
+        def territory=(territory)
+          if territory.nil?
+            raise ArgumentError, 'territory is mandatory'
+          end
+          @territory = territory
+        end
+
+        def composer=(composer)
+          if composer.nil?
+            raise ArgumentError, 'composer is mandatory'
+          end
+          @composer = composer
+        end
+
+        def is_persistent?
+          return category.value == 'persistent'
+        end
+      end
+
+      class EventContext < Pathable
+        attr_reader :start_time, :setting, :participations, :location
+        attr_accessor :end_time, :other_context
+
+        def initialize(args = { })
+          super(args)
+          self.start_time = args[:start_time]
+          self.setting = args[:setting]
+          self.end_time = args[:end_time]
+          self.participations = args[:participations]
+          self.location = args[:location]
+          self.other_context = args[:other_context]
+        end
+
+        def start_time=(start_time)
+          if start_time.nil?
+            raise ArgumentError, 'start_time is mandatory'
+          end
+          @start_time = start_time
+        end
+
+        def setting=(setting)
+          if setting.nil?
+            raise ArgumentError, 'setting is mandatory'
+          end
+          @setting = setting
+        end
+
+        def participations=(participations)
+          if !participations.nil? and participations.empty?
+            raise ArgumentError, 'participations should not be empty'
+          end
+          @participations = participations
+        end
+
+        def location=(location)
+          if !location.nil? and location.empty?
+            raise ArgumentError, 'location should not be empty'
+          end
+          @location = location
+        end
+      end
+
+      autoload :Content, 'composition/content'
+
+    end # end of Composition
+  end # end of RM
+end # end of OpenEHR