openehr 1.1.0

data/lib/openehr/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

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

@@ -0,0 +1,253 @@
+# 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
+require 'locale/info'
+
+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?
+              unless Locale::Info.language_code? language.code_string
+                raise ArgumentError, 'language code is invalid'
+              end
+              @language = language
+            end
+
+            def encoding=(encoding)
+              if encoding.nil?
+                raise ArgumentError, 'encoding is mandatory'
+              end
+              Encoding.find(encoding.code_string)
+              @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/openehr/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/openehr/rm/data_structures.rb

@@ -0,0 +1,25 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+# rm::data_structures
+# class DATA_STRUCTURE
+# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_5_1_76d0249_1140447518205_872539_864Report.html
+# refs #59
+
+module OpenEHR
+  module RM
+    module DataStructures
+      autoload :ItemStructure, 'data_structures/item_structure'
+      autoload :History, 'data_structures/history'
+
+      class DataStructure < OpenEHR::RM::Common::Archetyped::Locatable
+        def initialize(args = { })
+          super(args)
+        end
+
+        def as_hierarchy
+          raise NotImplementedError, "as_hirarchy must be implemented"
+        end
+      end
+    end # of Data_Structures
+  end # of RM
+end # of OpenEHR

data/lib/openehr/rm/data_structures/history.rb

@@ -0,0 +1,117 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+# rm::data_structures::history
+# history module
+# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109157527311_729550_7234Report.html
+# refs #55
+require 'time'
+require 'active_support/core_ext'
+include OpenEHR::RM::DataStructures
+include OpenEHR::RM::Common::Archetyped
+
+module OpenEHR
+  module RM
+    module DataStructures
+      module History
+        class History < DataStructure
+          attr_reader :origin, :events
+          attr_accessor :duration, :period, :summary
+
+          def initialize(args = { })
+            super(args)
+            self.origin = args[:origin]
+            self.duration = args[:duration]
+            self.period = args[:period]
+            self.events = args[:events]
+            self.summary = args[:summary]
+          end
+
+          def origin=(origin)
+            raise ArgumentError, 'origin is mandatory' if origin.nil?
+            @origin = origin
+          end
+
+          def events=(events)
+            if !events.nil? and events.empty?
+              raise ArgumentError, 'events should not be empty'
+            end
+            @events = events
+          end
+
+          def is_periodic?
+            return !@period.nil?
+          end
+        end
+
+        class Event < Locatable
+          attr_reader :data, :time
+          attr_accessor :state
+
+          def initialize(args = { })
+            super(args)
+            self.data = args[:data]
+            self.time = args[:time]
+            self.state = args[:state]
+          end
+
+          def data=(data)
+            raise ArgumentError, 'data is mandatory' if data.nil?
+            @data = data
+          end
+
+          def time=(time)
+            raise ArgumentError, 'time is mandatory' if time.nil?
+            @time = time
+          end
+
+          def offset
+            return @time.diff(@parent.origin)
+          end
+        end
+
+        class PointEvent < Event
+
+        end
+
+        class IntervalEvent < Event
+          attr_reader :width, :math_function
+          attr_accessor :sample_count
+
+          def initialize(args = { })
+            super(args)
+            self.width = args[:width]
+            self.math_function = args[:math_function]
+            self.sample_count = args[:sample_count]
+          end
+
+          def width=(width)
+            raise ArgumentError, 'width is mandatory' if width.nil?
+            @width = width
+          end
+
+          def math_function=(math_function)
+            if math_function.nil?
+              raise ArgumentError, 'math_function is mandatory'
+            end
+            @math_function = math_function
+          end
+
+          def interval_start_time
+            date_time = ::Time.iso8601(time.as_string)
+            start_time = (@width.years).years.ago date_time
+            start_time = (@width.months).months.ago start_time
+            start_time = (@width.days).days.ago start_time
+            start_time = (@width.hours).hours.ago start_time
+            start_time = (@width.minutes).minutes.ago start_time
+            seconds = @width.seconds
+            unless @width.fractional_second.nil?
+              seconds += @width.fractional_second
+            end
+            start_time = seconds.ago start_time
+            return DvDateTime.new(:value => start_time.iso8601)
+          end
+        end
+      end # end of History
+    end # end of DataStructure
+  end # end of RM
+end # end of OpenEHR