ion_orders_engine_mockingjay 1.0.1.SNAPSHOT → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2383f21b8f36036b4fa090ac0e169bc477ebbde5
-  data.tar.gz: 69615d474475d3da7ae02f0c002d06219e1f8305
+  metadata.gz: 09186104869a21657277807bfcccb3f0d85b4ac1
+  data.tar.gz: b11ee2ade83e151b3159d832806f0ab0e0cd47de
 SHA512:
-  metadata.gz: 43622fb16862f27ba16489d80f4d62afdd102d2275a77d5cd3642c392dda96e8ab48bae5e9f256dc00f7c9b37eee5110d1df5adbc69fa218231afbff61e3845d
-  data.tar.gz: 0cfe073c305f02403ae085babef6350788e3838b052fc3c3ce0c13151c2140074e63602a92b34524955d75622424249ad51b4c1fe1b800653b8bb1106db39b6d
+  metadata.gz: cc2e73a77bf98a169ff2a3e74f8ebc324e44b8f2cd1b692698f430d0a20e5cedc80310945a427b0a0bf488fc618b01b806758420ec94eb2dc3de4e0d16fea261
+  data.tar.gz: 202a3931a931c60cf12b27c54c038e04270e6ba36fa950b2a46b20a8a55ee7710933ec5de26deff931f3094a9b73f33d3acf3f874d8b232b60a7ee5dfe8eb542

data/app/models/concerns/mock/import_concern.rb

@@ -0,0 +1,332 @@
+# Public: We provide behavior that allows for the creation of new instances
+# of a model from either a JSON String or a Ruby Hash. 
+#
+# Include this module on every model built in this app. 
+module Mock::ImportConcern
+  # Extensions
+  extend ActiveSupport::Concern
+
+  included do
+  end
+
+  # ---------- Instance Methods ----------
+
+  # No instance methods present in this mixin.
+
+
+  # Public: Checks to see if we have a has_one relation of the specified name.
+  # The perspective is that we are the owning resource and we are advising
+  # if we have a has_one association with the given name.
+  #
+  # relation_name - A String or Symbol, such as 'policy' or :policy
+  #
+  # Returns Boolean true if the model we're mixed into has a 'has_one' relation with the given name.
+  def has_a_has_one_relation?(relation_name)
+    has_one_keys = self.class.has_one_relations_hash.keys
+    sanitized_relation_name = relation_name.to_s
+    has_one_keys.include? sanitized_relation_name
+  end
+
+
+  # Public: Determines if we are the destination of a has_one relation from our parent
+  # resource, assuming we even have a parent resource.
+  def is_singular_child_resource?
+    parent_model = self.parent_resource_model_object
+    if parent_model
+      parent_model.has_a_has_one_relation? self.class.to_s.tableize.singularize
+    end
+  end
+
+
+
+  # ---------- Class Methods ----------
+
+  module ClassMethods
+
+    # Public: Provides an array of those attributes whose values together, determine non-synthetic uniqueness.
+    # We define an empty array here. Classes that use this module mixin should override with there own list of 
+    # keys as symbols. Never include the :id attribute, because that is synthetic.
+    #
+    # Returns Array of symbols representing attributes that together, are a business compound primary key.
+    def uniqueness_attributes
+      []
+    end
+
+
+    # Public: Takes a hash of attributes and pulls out just those that match our uniqueness attributes.
+    # The resultant hash can be used as conditions in a <emphasis>where</emphasis> clause to query with.
+    #
+    #   contents_hash - The hash of attributes for a candidate instance of this model.
+    # 
+    # Returns Hash containing properties as key-value pairs, which uniquely identify an instance of the mixed
+    #   in model.
+    def uniqueness_conditions(contents_hash)
+      conditions_hash = {}
+      log_info "Mock::ImportConcern: uniqueness_conditions(): uniqueness_attributes to work with is: #{uniqueness_attributes}"
+      uniqueness_attributes.each do | unique_attribute_key |
+        #log "Mock::ImportConcern: uniqueness_conditions(): Searching for key: #{unique_attribute_key}"
+        # The contents hash we'll be looking through is JSON, with string keys instead of symbol keys,
+        # and from testing, apparently that matters! Hence, we do a 'to_s' on each key before looking
+        # through the contents_hash for it:
+        search_value = contents_hash[unique_attribute_key.to_s]
+        if search_value
+          #log "Mock::ImportConcern: uniqueness_conditions(): Found value #{search_value} for key: #{unique_attribute_key}"
+          conditions_hash[unique_attribute_key] = search_value
+        end
+      end
+
+      conditions_hash
+    end
+
+
+    # Public: Creates a hash that maps relationship name to model class constant, for our has_one relations.
+    #
+    # Returns Hash of the mixing in model's ActiveRecord has_one relations with relation names as keys 
+    #   and destination classes as values.
+    def has_one_relations_hash
+      relations_reflection = self.reflect_on_all_associations(:has_one)
+      relations_hash = {}
+      relations_reflection.each do |relation|
+        relations_hash[relation.name.to_s] = relation.class_name.constantize
+      end
+
+      #log "has_one_relations_hash: #{relations_hash}"
+      relations_hash
+    end
+
+
+    # Public: Creates a hash that maps relationship name to model class constant, for our has_many relations.
+    #
+    # Returns Hash of the mixing in model's ActiveRecord has_many relations with relation names as keys 
+    #   and destination classes as values.
+    def has_many_relations_hash
+      relations_reflection = self.reflect_on_all_associations(:has_many)
+      relations_hash = {}
+      relations_reflection.each do |relation|
+        relations_hash[relation.name.to_s] = relation.class_name.constantize
+      end
+
+      #log "has_many_relations_hash: #{relations_hash}"
+      relations_hash
+    end
+
+
+    # Public: Takes a Hash of attributes for this model, and does a cross check if there exists 
+    # an instance of this model already with the same values as those passed in. In doing our check,
+    # we <strong>only</strong> consider those attributes present in the array returned from a call 
+    # to uniqueness_attributes().
+    #
+    #   contents_hash   - The hash of attributes for a candidate instance of this model.
+    #
+    # Returns Boolean whether or not a model instance exists with the provided contents hash.
+    def has_existing_instance?(contents_hash)
+      conditions_hash = uniqueness_conditions(contents_hash)
+      #log "#{self.to_s}: Looking for existing instance using contents_hash: #{contents_hash}"
+      #log "#{self.to_s}: Looking for existing instance with attributes: #{conditions_hash}"
+
+      # Do we have an empty set of conditions?
+      if conditions_hash.empty?
+        # YES: Return a no match result. This shouldn't happen, but if we allow this answer,
+        # every record will be matched with the no-constraint conditions, and then possibly removed.
+        log_warn "Interchange::ImportConcern has_existing_instance(): Ran into situation where conditions_hash" \
+            "computed was empty. This is dangerous; a wildcard match like this could cause us to delete all" \
+            "existing records as duplicates. Ensure uniqueness_attributes array on root models are set correctly."
+        false
+      else
+        # NO: We have some conditions that we can filter on, so we'll do a search based on these
+        # conditions and let the existence thereof be our verdict.
+        self.where(conditions_hash).exists?
+      end
+    end
+
+
+    # Internal: Retrieves all instances of this model that match a subset of the values in the 
+    # contents hash; specifically, the uniqueness values.
+    #
+    #   contents_hash   - The hash of attributes for a candidate instance of this model.
+    #
+    # Return Array of all instances of this model that matched a subset of the values in the contents hash, as
+    #   defined by the uniqueness_attributes
+    def retrieve_existing_instances(contents_hash)
+      conditions_hash = uniqueness_conditions(contents_hash)
+      self.where(conditions_hash)
+    end
+
+
+    # Internal: Returns the first matching existing instance of this model found, otherwise nil.
+    #
+    #   contents_hash - The hash of attributes for a candidate instance of this model.
+    #
+    # Returns ActiveRecord::Base an instance of this model that matched a subset of the values in the contents hash
+    def retrieve_any_existing_instance(contents_hash)
+      existing = retrieve_existing_instances(contents_hash)
+      unless existing.empty?
+        existing.first
+      end
+    end
+
+
+    # Internal: Finds existing instances of this model that match the uniqueness attributes defined for this model,
+    # and destroys them. Presumably, this is to make way for a newly imported instance that would then be a dupe.
+    #
+    #   contents_hash - the hash of attributes for a candidate instance of this model.
+    #
+    # Returns Fixnum the number of instances we found (and presumably destroyed).
+    def remove_duplicates(contents_hash)
+      existing_instances = retrieve_existing_instances(contents_hash)
+      existing_instances.each do | existing_instance |
+          log "#{self.to_s}: remove_duplicates(): Destroying instance #{existing_instance.id}"
+          existing_instance.destroy
+      end
+
+      existing_instances.count
+    end
+
+
+    # Public: Performs an import operation on the mixing in model, using the model contents provided.
+    #
+    # Note: when we ourselves call import() on related models, we effectively ignore the duplicate_strategy, as
+    # those related models will by definition, always be non-root models. We only care about duplicates when it comes
+    # to models that define top level collections (i.e. root models).
+    #
+    #   contents            - the contents of a new model to be imported. This may be a proper Ruby Hash.
+    #   duplicate_strategy  - a constant from the Enums::DuplicateStrategy module. This indicates whether duplicates
+    #                         should be allowed, skipped or replace that which they duplicate. 
+    #                         This is only meaningful when importing a root model.
+    #   root_model          - if not specified, we'll eventually set it by walking up the parent resource chain 
+    #                         on the model we do instantiate (default: parent resource).
+    #
+    # Returns ActiveRecord::Base the model instance we just built.
+    def import(contents, duplicate_strategy, root_model=nil)
+      #log "#{self.to_s}: Asked to import data."
+
+      # Convent the contents passed in to a Hash if it is currently a String of (presumably) JSON.
+      #if contents.is_a? String
+      #  log 'We were passed a String of contents'
+      #  contents_hash = JSON.parse(contents)
+      #else
+      #  log 'We were passed a Hash of contents'
+      #  contents_hash = contents
+      #end
+
+      contents_hash = contents
+      model = self.new
+
+      unless root_model
+        if model.is_root_resource?
+          root_model = model
+          root_model.import_errors = [] # Initialize the list of errors
+          root_model.import_notices = [] # Initialize the list of notices
+
+          # Determine if we have duplicates, and if so, handle them as directed by duplicate_strategy:
+          apply_duplicate_handling_strategy(contents_hash, duplicate_strategy, root_model)
+        end
+      end
+
+      # Apply values from the contents hash onto the model:
+      apply_content_to_model(contents_hash, model, root_model)
+
+      # Return the new model just built; callers are responsible for saving, when appropriate.
+      model
+    end
+
+
+    # Public: Determines whether we should allow, replace or skip duplicates. We'll first search for a duplicate
+    # and if one exists, we'll then apply the duplicate strategy provided in determining how to deal with
+    # the duplicate. As we go, we'll add entries to the root model's import_notices array if warranted.
+    # For imports that should be skipped, we set the skip_import flag on the root model indicating that
+    # it should not be saved.
+    #
+    #   contents_hash       - the hash of attributes for a candidate instance of this model.
+    #   duplicate_strategy  - a constant from the Enums::DuplicateStrategy module. This indicates whether duplicates
+    #                         should be allowed, skipped or replace that which they duplicate. This is only meaningful 
+    #                         when importing a root model.
+    #   root_model          - if not specified, we'll eventually set it by walking up the parent resource chain 
+    #                         on the model we do instantiate.
+    #
+    # Returns nothing.
+    def apply_duplicate_handling_strategy(contents_hash, duplicate_strategy, root_model)
+      if has_existing_instance?(contents_hash)
+        case duplicate_strategy
+          when Enums::DuplicateStrategy::ALLOW
+            # Do nothing; allow it if there happened to be a duplicate.
+            # Log this in import_notices
+            root_model.import_notices << "Imported as an allowed duplicate."
+          when Enums::DuplicateStrategy::REPLACE
+            # Remove existing entries
+            num_dupes_removed = remove_duplicates(contents_hash)
+            # Log this in import_notices
+            root_model.import_notices << "Imported, but had to delete #{num_dupes_removed} duplicate(s) prior."
+          when Enums::DuplicateStrategy::SKIP
+            # Log this in import_notices
+            root_model.import_notices << "Skipped importing this, as it was a duplicate."
+            # Break out of this import; nothing more for us to do. We'll set a return flag to indicate this.
+            root_model.skip_import = true
+          else
+            # Do nothing. Assume our caller has already checked for valid duplicate_strategy values.
+        end # case
+      end
+    end
+
+
+    # Public: Applies the contents hash provided onto the model object provided. This includes
+    # core properties of the model, as well as related objects. For related objects,
+    # we effectively call into the import() method on the related class, building out
+    # our object graph with recursion.
+    #
+    #   contents_hash - the hash of attributes for a candidate instance of this model.
+    #   model         - the model instance we are setting values into from the contents hash.
+    #   root_model    - represents the root model for the model we're currently importing. We need this
+    #                   for when we make re-entrant calls into the import() method for related 
+    #                   models to our model instance.
+    # 
+    # Returns nothing.
+    def apply_content_to_model(contents_hash, model, root_model)
+      has_many_relationships_hash = has_many_relations_hash()
+      has_one_relationships_hash = has_one_relations_hash()
+
+      # Any contents in hash not in a pair will generate an exception. Defend against such malformed input
+      # content with an exception handling block.
+      begin
+        contents_hash.each_pair do |key, value|
+          #log "Processing key from contents hash: '#{key}'"
+
+          next if key == 'id' # Defend against these, which really shouldn't be in the source input files anyways.
+
+          if model.has_attribute? key
+            #log "Processing attribute: #{key} | value: #{value}"
+            model.send("#{key}=", value) # Superior to instance_variable_set b/c we're dealing with ActiveRecord attributes
+
+          elsif has_one_relationships_hash.keys.include? key
+            #log "The key: #{key} is one of our has_one relations"
+            klazz = has_one_relationships_hash[key]
+            if klazz.respond_to? :import
+              #log "#{klazz.to_s} responds to import."
+              related_has_one_entity = klazz.import(value, Enums::DuplicateStrategy::ALLOW, root_model)
+              #log "++About to add '#{related_has_one_entity.class.name}' as a has one to '#{self.name}' via the key '#{key}'"
+              mutator_key = "#{key}=".to_sym
+              model.send(mutator_key, related_has_one_entity)
+              #log "..Completed adding '#{related_has_one_entity.class.name}' as a has one to '#{self.name}' via the key '#{key}'"
+            end
+
+          elsif has_many_relationships_hash.keys.include? key
+            #log "The key: #{key} is one of our has_many relations"
+            klazz = has_many_relationships_hash[key]
+            if klazz.respond_to? :import
+              #log "#{klazz.to_s} responds to import."
+              value.each do |related_object_data|
+                model.send(key) << klazz.import(related_object_data, Enums::DuplicateStrategy::ALLOW, root_model)
+              end
+            else
+              log "#{klazz.to_s} does NOT respond to import."
+            end
+          end
+        end
+      rescue Exception => exception
+        log_error "ERROR: Ran into an exception importing model #{self.to_s}. #{exception.class.to_s}: #{exception}."
+        root_model.import_errors << "#{exception.class.to_s}: #{exception.message}"
+      end
+    end
+
+  end # module ClassMethods
+end # module Mock::ImportConcern

data/app/models/concerns/mock/phone_number_concern.rb

@@ -0,0 +1,33 @@
+# This module provides a method that reformats our related phone numbers into a hash structure.
+# This can be useful for many things, though our primary use is to facilitate generating 
+# JSON responses via JBuilder
+#
+# Include this module into any model that has_many :phone_numbers. 
+module Mock::PhoneNumberConcern
+
+  extend ActiveSupport::Concern
+
+  included do 
+  end
+
+  # Organizes all of our associated PhoneNumbers into a hash structure, where the key is the 
+  # label and the value is an Array of all raw phone number values that have that given label.
+  # This facilitates situations where for example, you have two home phone numbers.
+  def formatted_phone_numbers_hash
+    numbers_hash = {}
+    phone_numbers.each do |phone_number_object|
+      iterated_label = phone_number_object.label
+      # Does the label already exist in our hash?
+      if numbers_hash[iterated_label]
+        # YES: Just add the number to the existing value array:
+        numbers_hash[iterated_label] << phone_number_object.number
+      else
+        # NO: Create a new entry for this label:
+        numbers_hash[iterated_label] = [phone_number_object.number]
+      end
+    end
+
+    numbers_hash
+  end
+
+end # module

data/app/models/concerns/mock/resource_ancestors_concern.rb

@@ -0,0 +1,86 @@
+# Include this module on every model we use. For non-root models, include the class
+# declaration parent_resource with a symbol identifying what method an instance of that model
+# would call to retrieve its resource parent.
+#
+# For example, in the Allergy.rb model file, we'd have the following line:
+#
+#   parent_resource :patient
+#
+# This information allows us to build a model chain up to the root model; useful in constructing
+# navigation structures, such as breadcrumbs.
+#
+module Mock::ResourceAncestorsConcern
+
+  extend ActiveSupport::Concern
+
+  included do 
+  end
+
+
+  def parent_resource_model_object
+    self.send(self.class.parent_resource_symbol) if self.class.parent_resource_symbol
+  end
+
+
+  def resource_ancestors
+    parent = parent_resource_model_object
+
+    if parent
+      parent.resource_ancestors + [self]
+    else
+      [self]
+    end
+  end
+
+
+  def root_resource
+    resource_ancestors.first unless resource_ancestors.empty?
+  end
+
+
+  # We are a root resource if our root resource is ourselves.
+  def is_root_resource?
+    root_resource == self
+  end
+
+
+  # Returns nil by default. Models should override if they'd like
+  # a short summary to appear in breadcrumbs.
+  def short_title
+    nil
+  end
+
+
+  # Returns a title string that is more than the short_title; it is preceded by the model class name.
+  def model_qualified_title
+    "#{self.class.to_s}: #{short_title}"
+  end
+
+
+  # We are a protected record if the Patient we ultimately belong to is a protected record.
+  # Any root model must implement or have a property such that we can ask it 'protected_record?'.
+  # So as not to conflict, this mixin module uses the signature 'marked_as_protected?' to traverse
+  # up the parent resource chain.
+  def marked_as_protected?
+    parent = parent_resource_model_object
+
+    if parent
+      parent.marked_as_protected?
+    else
+      self.protected_record?
+    end
+  end
+
+
+  module ClassMethods
+    def parent_resource(parent_resource_method_symbol)
+      @parent_resource_symbol = parent_resource_method_symbol.to_sym
+    end
+
+    def parent_resource_symbol
+      @parent_resource_symbol 
+    end
+  end # module ClassMethods
+
+
+end # module Mock::ResourceAncestorsConcern

data/app/models/concerns/mock/root_model_concern.rb

@@ -0,0 +1,41 @@
+# This concern is only meant to be mixed into models that are top-level collections.
+# That is, those models who have no parent model resource.
+module Mock::RootModelConcern
+
+  # Extensions
+  extend ActiveSupport::Concern
+
+  included do
+  end
+
+  # Instance Variables
+  attr_accessor :export_errors
+  attr_accessor :import_errors
+  attr_accessor :import_notices
+  attr_accessor :skip_import
+
+
+  # ---------- Instance Methods ----------
+
+  def skip_import?
+    skip_import
+  end
+
+
+  # Returns the name to be used for data interchange. Normally, one just returns
+  # the name of the class.
+  def interchange_type_name
+    self.class.to_s
+  end
+
+  # ---------- Class Methods ----------
+
+  module ClassMethods
+    # Our implementing classes should always respond in the affirmative to this query.
+    def is_root_resource?
+      true
+    end
+  end  # Mock::RootModelConcern::ClassMethods
+
+
+end  # Mock::RootModelConcern

data/config/application.rb

@@ -38,7 +38,7 @@ module Mockingjay
     # Set Time.zone default to the specified zone and make Active Record auto-convert to this zone.
     # Run "rake -D time" for a list of tasks for finding time zone names. Default is UTC.
     config.active_record.default_timezone = :local
-    config.active_record.time_zone_aware_attributes = false  
+    config.active_record.time_zone_aware_attributes = false
 
     # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
     # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
@@ -95,6 +95,4 @@ module Mockingjay
     end
 
   end
-end
-
-
+end

data/config/initializers/reference.rb

@@ -4,34 +4,11 @@ module Reference
   # to Ruby classes concretely defined in app/models/reference. Only include those root level reference classes;
   # any nested classes should be bootstrapped from the initialize() method of the parent reference class.
   ROOT_REFERENCE_MODEL_CLASSES = [
-      Reference::LabGroup,
-      Reference::LabResultDataType,
-      Reference::AllergyReactionType,
-      Reference::ConditionStatusType,
-      Reference::NotificationConceptType,
-      Reference::AllergyStatusType,
-      Reference::AllergySeverity,
-      Reference::AllergyCancelReason,
-      Reference::VisitType,
-      Reference::VitalsMeasurementType,
-      Reference::VitalsMeasurementStatusType,
-      Reference::VitalsMeasurementNormalcy,
-      Reference::VitalsMeasurementUnit,
-      Reference::VitalsMeasurementContributorSystem,
-      Reference::VitalsMeasurementSystem,
-      Reference::VitalsMeasurementResultType,
-      Reference::DiagnosisConfirmationStatus,
-      Reference::ProblemClassification,
-      Reference::DiagType,
-      Reference::LifeCycleStatus,
-      Reference::ClinicalDiagnosisClinicalService,
-      Reference::HealthRecordCancelReason
   ]
 
   # This Array holds only those classes that are nested reference models, (ultimately) dependent on one class in the
   # ROOT_REFERENCE_MODEL_CLASSES Array.
   NESTED_REFERENCE_MODEL_CLASSES = [
-      Reference::LabConcept
   ]
 
   # Where reference data is read from and written to

data/config/routes.rb

@@ -1,4 +1,4 @@
-Mockingjay.Application.routes.draw do
+Mockingjay::Application.routes.draw do
   match '/patients/:patientId/orders/inpatient' => 'api/ion_orders_engine/order_profile/inpatient_order_profile#show', via: :get, :constraints => {:patientId => /\d+/}
   match '/patients/:patientId/orders/:orderId' => 'api/ion_orders_engine/order_by_id/order_by_id#show', via: :get, :constraints => {:patientId => /\d+/, :orderId => /\d+/}
-end
+end # Mockingjay::Application.routes.draw

data/lib/bootstrap_breadcrumbs_builder.rb

@@ -0,0 +1,34 @@
+# CREDIT: https://gist.github.com/1933884
+#
+# The BootstrapBreadcrumbsBuilder is a Bootstrap compatible breadcrumb builder.
+# It provides basic functionalities to render a breadcrumb navigation according to Bootstrap's conventions.
+#
+# BootstrapBreadcrumbsBuilder accepts a limited set of options:
+# * separator: what should be displayed as a separator between elements
+#
+# You can use it with the :builder option on render_breadcrumbs:
+#     <%= render_breadcrumbs :builder => ::BootstrapBreadcrumbsBuilder, :separator => "&raquo;" %>
+#
+# Note: You may need to adjust the autoload_paths in your config/application.rb file for rails to load this class:
+#     config.autoload_paths += Dir["#{config.root}/lib/"]
+#
+class BootstrapBreadcrumbsBuilder < BreadcrumbsOnRails::Breadcrumbs::Builder
+  def render
+    @context.content_tag(:ul, class: 'breadcrumb') do
+      @elements.collect do |element|
+        render_element(element)
+      end.join.html_safe
+    end
+  end
+
+  def render_element(element)
+    current = @context.current_page?(compute_path(element))
+
+    @context.content_tag(:li, class: ('active' if current)) do
+      link_or_text = @context.link_to_unless_current(compute_name(element), compute_path(element), element.options)
+      divider = @context.content_tag(:span, (@options[:separator]  || '/').html_safe, class: 'divider') unless current
+
+      link_or_text + (divider || '')
+    end
+  end
+end

data/lib/enums/duplicate_strategy.rb

@@ -0,0 +1,25 @@
+module Enums
+
+  # Public: Contains all valid options as Fixnum constants for the various ways that potential
+  # duplicate records can be handled.
+  module DuplicateStrategy
+    ALLOW = 0
+    REPLACE = 1
+    SKIP = 2
+
+    ALL_OPTIONS = [ALLOW, REPLACE, SKIP]
+
+    # Public: Will advise if the provided value passed in is valid.
+    # Note: This is a module method, not an 'instance' method, as the generated documentation
+    # might imply.
+    #
+    #   value   - String value to test for validity.
+    # 
+    # Returns Boolean whether the value provided is valid.
+    def valid?(value)
+      ALL_OPTIONS.include? value
+    end
+
+  end  # module DuplicateStrategy
+
+end  # module Enums

data/lib/enums.rb

@@ -0,0 +1,4 @@
+# Public: A module for namespacing so that contained classes are more easily identified
+# as having the specific purpose of being a vessel for enumerated values.
+module Enums
+end

data/lib/interchange/Writer.rb

@@ -0,0 +1,176 @@
+# This module deals with importing and exporting model data. We are a counterpart
+# to controllers under the same Interchange module.
+module Interchange
+    
+  # Public: Handles saving model data (exporting) to the local file system, be it intended for 
+  # later imports back into Mockingjay, or for use as test data for UIAutomation.
+  class Writer
+    # Mixins
+    include ::Mixins::Logging
+    include ::ActionView::Helpers::TextHelper # for pluralize
+    
+    # A Hash of results from the last operation, containing keys:
+    #   :successful - Array of model instances whose export was successful.
+    #   :failures   - Array of model instances whose export was unsuccessful.
+    attr_accessor :operation_results
+    
+    
+    # Public: This demarcates a new export operation. You must provide a block
+    # for us to yield to when you call this method. That block should
+    # contain one or more calls to our export() method. 
+    # 
+    # We reset the class variable 'operation_results' and populate it 
+    # after yielding, with summary information about the export operation.
+    #
+    # Returns nothing.
+    def mark_export_operation
+      log "Starting Export operation."
+      # Clear the class cached last-export summary:
+      self.class.instance_variable_set(:@last_export_summary, nil)
+      @operation_results = { successful: [], failures: [] }
+      
+      yield # Hand over control to the block that calls our export() method one or more times
+      
+      log "Completed Export operation."
+      summarize_operation
+      self.class.instance_variable_set(:@last_export_summary, @operation_results)
+    end
+    
+    
+    # Public: This inspects the @operation_results Hash and adds more entries to it that describe
+    # and timestamp the operation. Included in this is a 'flash_hash' that a controller can
+    # use after the export operation, to present a one line summary.
+    #
+    # Returns nothing.
+    def summarize_operation
+      message = ''
+
+      # Failures:
+      if @operation_results[:failures].empty?
+        flash_key = :notice
+        @operation_results[:has_failures] = false
+      else
+        flash_key = :alert
+        @operation_results[:has_failures] = true
+        message = "#{@operation_results[:failures].count} #{@model_class.to_s} record(s) failed to export. "
+      end
+
+      # Summary Info:
+      @operation_results[:total_records] = @operation_results[:failures].count + @operation_results[:successful].count
+      message.concat(pluralize(@operation_results[:successful].count, "#{@model_class.to_s} record")).concat(' exported successfully. ')
+      @operation_results[:flash_hash] = { flash_key => message }
+      @operation_results[:timestamp] = Time.now      
+    end
+    
+    
+    # Public: This determines which specific objects will get exported, and then farms that out to the create_file()
+    # method to actually write to the file system.
+    #
+    # We can handle multiple objects or a single object as well as regular exports and those 
+    # meant for UIAutomation test data. Most of these options are specified in the optional options hash.
+    # In all cases, each call to this method is for dealing with objects of a specific model class.
+    #
+    #   model_class - Class of model to be exported.
+    #   options     - Hash of options that help us identify what subset of data (instances belonging to the model class)
+    #                 that we are meant to export. These options can include: 
+    #                 :ids      - what ID values to limit the export to (default: nil)
+    #                 :keywords - what keywords a model must have at least one of, in order to qualify for export (default: nil)
+    def export(model_class, options = {})
+      ids = options[:ids]
+      keywords = options[:keywords]
+      base_path = options[:base_path]
+
+      log "keywords sought: #{keywords}"
+      
+      controller_name = "Interchange::#{model_class.to_s.pluralize}Controller"
+      controller = controller_name.constantize
+      @rendering_controller = controller.new
+      
+      # Create dummy request and response objects on the rendering controller,
+      # otherwise it will complain. This was gleaned from: http://stackoverflow.com/a/6773022/535054
+      @rendering_controller.request = ActionDispatch::TestRequest.new
+      @rendering_controller.response = ActionDispatch::TestResponse.new
+      
+      # Retrieve instances of the given model, and then iterate through them to do the export:
+      models =
+        if ids
+          # We have a specific list of ID values we've been asked to export:
+          model_class.where(:id => ids)
+        elsif keywords
+          # We want only those instances that have one of the list of keywords given to us:
+          model_class.joins(:metadata_keywords).where(:metadata_keywords => {:text => keywords})
+        else
+          # We have no specific list of IDs, so we're going to export all instances:
+          model_class.find(:all)
+        end
+      
+      # Make the call to create_file() for each model instance we've determined needs to be exported:
+      models.each do |model|
+        begin
+          # TODO: Ensure this is a top-level resource before exporting
+          create_file model, options
+          @operation_results[:successful] << model          
+        rescue Exception => exception
+          @operation_results[:failures] << model    
+          model.export_errors << "Failure details: #{exception}"      
+        end
+      end
+    end
+        
+    
+    # Internal: Decorates the passed in pretty JSON if needed. Wwe adorn the
+    # output with JavaScript that provides comments and variable instantiation.
+    # 
+    #   model       - ActiveRecord::Base the root model being exported, from which we can get class 
+    #                 and name information to decorate with.
+    #   pretty_json - String with contents ready to be exported, that we'll decorate.
+    #   options     - Hash of options. (default: {})
+    #
+    # Returns String of the decorated output.
+    def decorate_output(model, pretty_json, options={})
+      decorated_output = "// #{model.interchange_name}.js\n"
+      decorated_output.concat "var CERN#{model.interchange_type_name}_#{model.interchange_name} = #{pretty_json};"
+
+      decorated_output
+    end
+    
+    
+    # Internal: Creates a local file that contains the provided JSON payload for the given model object.
+    # Model objects of a similar class are co-located in their own sub-directory.
+    #
+    #   model   - ActiveRecord::Base the root model to be exported.
+    #   options - Hash of options. (default: {})
+    #
+    # Returns nothing.
+    def create_file(model, options={})
+      Rails.logger.debug "Performing local export of #{model.class} model: #{model.short_title}"
+      model.export_errors = []
+      pretty_json = @rendering_controller.render_show_template_to_string(model, options)
+      data_file_contents = decorate_output(model, pretty_json, options)
+      base_path = options[:base_path] || 'public/interchange/'
+
+      interchange_extension = 'js'
+      interchange_type = if base_path == 'public/interchange/'
+                           'export/'
+                         else
+                           ''
+                         end
+
+      # Determine directory we will write the file into:
+      directory = "#{base_path}#{interchange_type}#{model.class.to_s.pluralize}"
+
+      # Ensure the directory exists:
+      directory_absolute_path = File.join(Rails.root, directory)
+      Rails.logger.debug "Absolute directory path to write to: #{directory_absolute_path}"
+      system("mkdir -p #{directory_absolute_path}") unless File.exists?(directory_absolute_path)
+
+      # Write the file to disk:
+      file_absolute_path = "#{directory_absolute_path}/#{model.interchange_name}.#{interchange_extension}"
+      Rails.logger.debug "Absolute model file path to write to: #{file_absolute_path}"
+      file = File.new(file_absolute_path, "w")
+      file.write(data_file_contents)
+      file.close
+    end
+
+  end # class  
+end  # module

data/lib/interchange/reader.rb

@@ -0,0 +1,197 @@
+# This module deals with importing and exporting model data. We are a counterpart
+# to controllers under the same Interchange module.
+module Interchange
+
+  # Handles reading files from the local file system meant for import. Ultimately, we'll pass a JSON object
+  # to the model whose data we've loaded, and that model will be responsible for creating a new instance of itself
+  # and all of its constituent, wholly owned, related objects.
+  #
+  # You use mark_import_operation() with a block in which you call import() one or more times, to perform your
+  # import operation.
+  class Reader
+    # Mixins
+    include ::Mixins::Logging
+    include ::ActionView::Helpers::TextHelper # for pluralize
+
+    attr_accessor :operation_results
+
+    # Prepares for an import operation and cleans up after it, summarizing the results.
+    # Callers must provide a block that makes one or more calls to our import() method to import
+    # various models.
+    def mark_import_operation
+      # Clear the class cached last-import summary:
+      self.class.instance_variable_set(:@last_import_summary, nil)
+
+      # Create a hash we'll return as the result of the import
+      @operation_results = { successful: [], failures: [], skipped: [] }
+
+      yield # Hand over control to the block that calls our import() method one or more times
+
+      # Now mark the operation as complete:
+      summarize_operation
+      self.class.instance_variable_set(:@last_import_summary, @operation_results)
+    end
+
+
+    # We kick off the import process for all records in the import folder that belong to the provided model class.
+    # If not provided, we default to no clean up of files and the skipping of any duplicates.
+    #
+    # @param model_class The actual top-level model class whose json files we'll look for and import.
+    # @param cleanup Defaults to false. If true, this instructs the successful import operations to be
+    #   followed up with a deletion of the source file for import.
+    # @param duplicate_strategy Defaults to skipping duplicates. Provide a value in module Enums::DuplicateStrategy.
+    # @return A hash that summarizes the operation. Included within is another hash that can be used for the Flash
+    #   that provides an alert or notice summary, as appropriate.
+    def import(model_class, cleanup=false, duplicate_strategy=Enums::DuplicateStrategy::SKIP, base_path='public/interchange/import/')
+      log "Importing files for model class: #{model_class}, with options" \
+        "cleanup: #{cleanup}, duplicate_strategy: #{duplicate_strategy}, base_path: #{base_path}"
+
+      @model_class = model_class
+      @cleanup_requested = cleanup
+
+      log "Started import for model: #{@model_class.to_s}"
+
+      # Determine directory we will read files from:
+      directory = "#{base_path}#{@model_class.to_s.pluralize}"
+
+      # Ensure the directory exists:
+      models_path = File.join(Rails.root, directory)
+      log "Models path to read from: #{models_path}"
+
+      # Does the directory exist that files of the given model class would be found at?
+      if File.exists?(models_path)
+        log "Import path '#{models_path}' exists."
+        Dir.chdir models_path
+        filenames = Dir.glob("*.{js,json}") # The candidate files to import will all have a .json or .js extension.
+        log "Matched the following file paths: #{filenames}"
+
+        # Iterate through all the files in the model directory, and attempt to import each one:
+        filenames.each do | filename |
+          log "#{self.class.name} import(): Processing file '#{filename}'"
+          contents = File.read(filename)
+          massaged_contents = transform_javascript_format(contents)
+          model = @model_class.send :import, massaged_contents, duplicate_strategy
+
+          if model.skip_import?
+            log "#{self.class.name} import(): Skipping import of file '#{filename}'"
+            process_skipped_import(model, filename)
+          elsif model.import_errors.empty?
+            log "#{self.class.name} import(): Success at import of file '#{filename}'"
+            process_model_save(model, filename)
+          else
+            log "#{self.class.name} import(): Import failed for file '#{filename}'"
+            process_failed_import(model)
+          end
+        end
+      else
+        log "No import folder exists at path: #{models_path}"
+      end
+
+    end  # import
+
+
+    # This takes a file with camel case keys and makes them underscore keys, recognizable
+    # to our Ruby models. Additionally, JavaScript commands that encase the core payload,
+    # are stripped out, so that we have valid JSON we can parse.
+    #
+    # Doing this whole exercise lets us export to JavaScript files useful for UIAutomation,
+    # while having a single format we can also import for ourselves (Mockingjay).
+    def transform_javascript_format(contents)
+      # Find positions for the start and end braces:
+      start_position = contents.index('{')
+      end_position = contents.rindex('}')
+
+      # Retrieve the string contents of the file between these braces, inclusive:
+      massaged_contents = contents[start_position..end_position]
+
+      # Parse the contents into JSON, and the make all the keys underscore style:
+      JSON.parse(massaged_contents).underscore_keys
+    end
+
+
+    protected
+
+    # Records that the import attempt for the given model, failed. We don't delete the source file in this case,
+    # regardless of the value of @cleanup_requested, because the user would likely want to inspect the file,
+    # retry after adjustments, etc.
+    #
+    # @param model The model instance that failed to import. This should have at least one entry in its
+    #   import_errors array.
+    def process_failed_import(model)
+      @operation_results[:failures] << model
+      log "Reader.import(): ERROR. Could not save imported model #{model.short_title}." \
+              "Errors: #{model.errors.full_messages.join(' | ')}"
+      # Note: for failures, we obviously do not want to delete the source file; so that it might be inspected.
+    end
+
+
+    # Attempts to save the provided model. Records a successful import if it succeeds, and a failure if it doesn't.
+    # @param model The model instance we will attempt to save.
+    # @param filename The source filename (fully qualified) that the model was built from. We'll use this to know
+    #   what file to delete if the save was successful and cleanup was requested.
+    def process_model_save(model, filename)
+      log "#{self.class.name} process_model_save(): Entered method."
+      begin
+        if model.valid?
+            log "#{self.class.name} process_model_save(): model is: #{model}"
+            #Rails.application.eager_load! # Needed to ensure all models are loaded for our asking them if they are root resources.
+            model.save
+            @operation_results[:successful] << model
+            log "Reader.import(): Successfully saved imported model #{model.model_qualified_title}"
+            # Delete the source file, if cleanup was requested:
+            File.delete(filename) if @cleanup_requested
+        else
+            @operation_results[:failures] << model
+            log_error "Reader.import(): Error saving model #{model.model_qualified_title}. Details: #{model.errors.full_messages}"
+            model.import_errors << "Save failed with error: #{model.errors.full_messages}"
+        end
+      rescue Exception => e
+        log "#{self.class.name} process_model_save(): Exception: #{e}"
+      end
+    end
+
+
+    # Records that we skipped importing a model, because it was a duplicate.
+    # @param model The model instance that we have skipped an import of, because it would duplicate one or more
+    #   records already in the system.
+    # @param filename The source filename (fully qualified) that the model was built from. We'll use this to know
+    #   what file to delete if cleanup was requested.
+    def process_skipped_import(model, filename)
+      @operation_results[:skipped] << model
+      log "Reader.import(): Skipped importing model #{model.model_qualified_title}"
+      # Delete the source file, if cleanup was requested:
+      File.delete(filename) if @cleanup_requested
+    end
+
+
+    # Adorns the summary hash passed in, beyond its core arrays of successful model import and failed model imports,
+    # with keys describing other aspects of the operation, including:
+    # * has_failures => Boolean on whether any failures exist
+    # * total_records => Sum total of successful and failed model imports; the total count of models we attempted to import
+    # * flash_hash => A hash that can be used for the flash messaging that summarizes the status of this import
+    def summarize_operation
+      message = ''
+
+      # Failures:
+      if @operation_results[:failures].empty?
+        flash_key = :notice
+        @operation_results[:has_failures] = false
+      else
+        flash_key = :alert
+        @operation_results[:has_failures] = true
+        message = "#{@operation_results[:failures].count} record(s) failed to import. "
+      end
+
+      # Skipped:
+      @operation_results[:has_skips] = !@operation_results[:skipped].empty?
+
+      # Summary Info:
+      @operation_results[:total_records] = @operation_results[:failures].count + @operation_results[:successful].count + @operation_results[:skipped].count
+      message.concat(pluralize(@operation_results[:successful].count, "record")).concat(' imported successfully. ')
+      message.concat(pluralize(@operation_results[:skipped].count, "record")).concat(' skipped. ')
+      @operation_results[:flash_hash] = { flash_key => message }
+      @operation_results[:timestamp] = Time.now
+    end
+
+  end  # class
+end  # module

data/lib/mixins/logging.rb

@@ -0,0 +1,36 @@
+module Mixins::Logging
+
+  extend ActiveSupport::Concern
+
+  included do
+  end
+
+  # ---------- Instance Methods ----------
+
+  # Convenience wrapper for Rails.logger.debug
+  def log(message)
+  	log_debug message
+  end
+
+  # An alias for the more abbreviated log() method,
+  # for consistency.
+  def log_debug(message)
+    Rails.logger.debug message
+  end
+
+
+  def log_info(message)
+  	Rails.logger.info message
+  end
+
+
+  def log_warn(message)
+  	Rails.logger.warn message
+  end
+  
+
+  def log_error(message)
+  	Rails.logger.error message
+  end
+
+end  # module Logging

data/lib/reference/data_types.rb

@@ -0,0 +1,31 @@
+# Public: This is where you invoke the load command for each reference data type that piggybacks off of the
+# DataList and DataOption models.
+#
+# Any reference data model with nested reference data structure, is responsible for loading those nested
+# data lists and options.
+#
+# Relies on the constant ROOT_REFERENCE_MODEL_CLASSES, defined in config/initializers/reference_data_types
+class Reference::DataTypes
+
+  # Loads all reference data classes with information from DataSets marked active.
+  def self.load
+    Rails.logger.info "Reference::DataTypes load(): Loading reference data types."
+    Reference::ROOT_REFERENCE_MODEL_CLASSES.each { |reference_class| reference_class.send(:load_reference_data)}
+  end
+
+
+  # De-registers all cached instances of reference data from each reference data type.
+  def self.unload
+    Rails.logger.info "Reference::DataTypes unload(): Unloading reference data types."
+    Reference::ROOT_REFERENCE_MODEL_CLASSES.each { |reference_class| reference_class.send(:unload_reference_data)}
+  end
+
+
+  # Reloads our reference data. Handy if a data list or data set has changed.
+  def self.reload
+    Rails.logger.info "Reference::DataTypes reload(): Reloading reference data types."
+    self.unload
+    self.load
+  end
+
+end  # class

data/lib/reference/loader.rb

@@ -0,0 +1,46 @@
+module Reference
+  # Public: This class handles the import of data located in the 'data/reference/' folder.
+  #
+  # We seed the database with default values for reference data.
+  class Loader
+
+    # Mixins
+    include ::Mixins::Logging
+
+    # Internal: Creates our instance of Reader, that handles the actual import.
+    def initialize
+      @reader = Interchange::Reader.new
+    end
+
+
+    # Public: The primary interface to this class. We setup to load all reference data in the
+    # data/reference/ folder, such that we leave the seed files intact, do not destroy existing data prior,
+    # and that we just replace any imports for data that already exists based on each model's determination
+    # of uniqueness.
+    def perform_import
+      log "#{self.class.name} perform_import(): Began import process."
+      # Set the parameters guiding how the import should be run:
+      cleanup = false
+      duplicate_strategy = Enums::DuplicateStrategy::REPLACE
+
+      # Wrap the import process in a block that can log the overall status:
+      @reader.mark_import_operation do
+        # Kick off the underlying import operation on the model(s) requested:
+        root_model_classes.each do |model_class|
+          puts "Reference::Loader - Loading reference data (if any) for model: #{model_class.to_s}"
+          @reader.import model_class, cleanup, duplicate_strategy, Reference::BASE_PATH
+        end
+      end
+    end
+
+
+    private
+
+    # Determines which of our models are root resources. Only these attempt to get loaded.
+    def root_model_classes
+      [DataSet]
+    end
+
+  end  # class
+
+end  # module

data/lib/reference/updater.rb

@@ -0,0 +1,23 @@
+module Reference
+
+  # Public: Writes reference data back to the file system, which will automatically get loaded next time.
+  # This will also get flagged in source control as an update that others will receive, who are running locally.
+  class Updater
+
+    # This constructor sets up Writer class that we offload the low level export work to.
+    def initialize
+      @writer = Interchange::Writer.new
+    end
+
+
+    def perform_export
+      # Start the export operation block:
+      @writer.mark_export_operation do
+        # Kick off the underlying export operation on the reference data model requested:
+        @writer.export DataSet, base_path: Reference::BASE_PATH, suppress_database_ids: true
+      end
+    end
+
+  end # class: Updater
+
+end  # module: Reference

data/lib/resource_display_helper.rb

@@ -0,0 +1,46 @@
+# This helper class is meant to get yielded to a block of code in a show template.
+# We hold the model object whose attributes are to be displayed, and handle substituting
+# values into a partial template, abstracting HTML boilerplate from the resource's
+# show template itself.
+#
+# We are very similar to the form that gets yielded by a form_for / simple_form_for call
+# except that we are making a show template easier to build, instead of a form.
+#
+class ResourceDisplayHelper
+
+  # Attributes
+  attr_accessor :model_object
+  attr_accessor :resource_helper
+
+
+  # ---------- Initializers ----------
+  
+  # Provide the model object we'll be invoking attribute method calls on, as well as the
+  # resource helper that we can ask to render a view partial for us.
+  def initialize(model_object, resource_helper)
+    @model_object = model_object
+    @resource_helper = resource_helper
+  end
+  
+  
+  # ---------- Interface ----------
+  
+  # This is the main method of this class that callers will use. They provide
+  # the attribute whose label and value is to be displayed. Optional overrides
+  # for the label and value are also allowed.
+  def attribute(name, options={})
+    label = options[:label] || name.to_s.humanize.titleize
+    value = options[:value] || model_object.send(name)
+    link_path = options[:link_path]
+
+    if value && value.kind_of?(String) && options[:truncate]
+      value = value.truncate(options[:truncate], :omission => "...", :separator => ' ')
+    end
+
+    # We don't have access to the view renderer, but our provider resource helper does.
+    # Use it to render the partial that holds the boilerplate template for how we like
+    # to show a single attribute:
+    resource_helper.render partial: 'mock/common/show_attribute', locals: {label: label, value: value, link_path: link_path}
+  end
+
+end  # class

data/lib/tasks/auto_annotate_models.rake

@@ -0,0 +1,20 @@
+# NOTE: only doing this in development as some production environments (Heroku)
+# NOTE: are sensitive to local FS writes, and besides -- it's just not proper
+# NOTE: to have a dev-mode tool do its thing in production.
+if(Rails.env.development?)
+  task :set_annotation_options do
+    ENV['position_in_class']    = "before"
+    ENV['position_in_fixture']  = "before"
+    ENV['position_in_factory']  = "before"
+    ENV['show_indexes']         = "true"
+    ENV['include_version']      = "false"
+    ENV['exclude_tests']        = "false"
+    ENV['exclude_fixtures']     = "false"
+    ENV['ignore_model_sub_dir'] = "false"
+    ENV['skip_on_db_migrate']   = "false"
+    ENV['format_rdoc']          = "false"
+    ENV['format_markdown']      = "false"
+    ENV['no_sort']              = "false"
+    ENV['force']                = "false"
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ion_orders_engine_mockingjay
 version: !ruby/object:Gem::Version
-  version: 1.0.1.SNAPSHOT
+  version: 1.0.2
 platform: ruby
 authors:
 - Kevin Schuster
@@ -120,6 +120,10 @@ files:
 - app/helpers/reference/data_elements_helper.rb
 - app/helpers/reference/data_lists_helper.rb
 - app/helpers/reference/data_sets_helper.rb
+- app/models/concerns/mock/import_concern.rb
+- app/models/concerns/mock/phone_number_concern.rb
+- app/models/concerns/mock/resource_ancestors_concern.rb
+- app/models/concerns/mock/root_model_concern.rb
 - app/views/interchange/common/_database_info.json.jbuilder
 - app/views/interchange/common/_metadata_keywords.json.jbuilder
 - app/views/interchange/common/_test_assertions.json.jbuilder
@@ -180,11 +184,23 @@ files:
 - config/locales/simple_form.en.yml
 - config/mongo.yml
 - config/routes.rb
+- db/development.sqlite3
 - db/schema.rb
 - db/seeds.rb
+- lib/bootstrap_breadcrumbs_builder.rb
+- lib/enums/duplicate_strategy.rb
+- lib/enums.rb
+- lib/interchange/reader.rb
+- lib/interchange/Writer.rb
 - lib/ion_orders_engine_mockingjay/engine.rb
 - lib/ion_orders_engine_mockingjay/version.rb
 - lib/ion_orders_engine_mockingjay.rb
+- lib/mixins/logging.rb
+- lib/reference/data_types.rb
+- lib/reference/loader.rb
+- lib/reference/updater.rb
+- lib/resource_display_helper.rb
+- lib/tasks/auto_annotate_models.rake
 - lib/tasks/ion_orders_engine_mockingjay_tasks.rake
 - Rakefile
 - README.md
@@ -202,9 +218,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.1.4