ion_orders_engine_mockingjay 1.0.1.SNAPSHOT

data/app/controllers/application_controller.rb

@@ -0,0 +1,25 @@
+class ApplicationController < ActionController::Base
+  # Mixins
+  include ::Mixins::Logging
+
+  protect_from_forgery
+  
+  helper :layout
+
+  before_filter :reload_reference_data
+
+  protected
+
+  # TODO: Fix this hack by using a persistent key-value store in development.
+  # This will reload our reference data if is has been unloaded.
+  def reload_reference_data
+    log "ApplicationController reload_reference_data(): Reference.get_instances_hash is: #{Reference.get_instances_hash}"
+    if Reference.empty_cache?
+      log "ApplicationController reload_reference_data(): Determined that we need to reload reference data. Doing so now."
+      Reference::DataTypes.reload if ActiveRecord::Base.connection.table_exists? 'reference_data_lists'
+    else
+      log "ApplicationController reload_reference_data(): No need to reload reference data."
+    end
+  end
+
+end

data/app/controllers/crud/base_controller.rb

@@ -0,0 +1,90 @@
+class Crud::BaseController < ApplicationController
+  
+  protected
+  
+  # Internal: By default, paths we construct will not be prefixed with a module symbol.
+  # However, in cases where controllers use a module namespace not shared by the models
+  # they operate on, subclasses of this class should include the symbol paths should 
+  # be prefixed with. For example: 
+  #
+  #   :mock
+  def module_symbol_for_paths
+    nil
+  end
+  
+  # Makes all breadcrumb calls from the root resource to the model provided.
+  # If an optional last breadcrumb symbol is provided, we add a breadcrumb for
+  # that too. The last breadcrumb always has a link href value of '#'.
+  # We leverage the breadcrumbs_on_rails gem to handle the mechanics of building
+  # the display tree from our calls to its API.
+  #
+  # We only ever pull in two resources max, to form the URL, since we never go deeper 
+  # than one level of resource nesting.
+  #
+  # If the current element in the ancestors chain we retrieve is not a symbol, and it 
+  # responds to 'short_title', we'll append that to the breadcrumb name, after a colon.
+  def configure_breadcrumbs(model, last_crumb_symbol=nil)
+    if model.is_a?(Symbol)
+      ancestors = [model]
+    else
+      ancestors = model.resource_ancestors      
+    end
+
+    ancestors.push(last_crumb_symbol) unless last_crumb_symbol.nil?
+    total_crumbs = ancestors.length
+    log "ancestors has #{ancestors.length} elements. They are: #{ancestors}"
+
+    ancestors.each_with_index do | resource, index |
+      # Is this breadcrumb name going to be based on a symbol?
+      if resource.is_a?(Symbol)
+        crumb_name = resource.to_s.humanize.titleize
+      else
+        crumb_name = resource.class.model_name.tableize.humanize.singularize.titleize.split('/').last
+        crumb_name.concat(": #{resource.short_title}") if resource.short_title
+      end
+
+      # Are we dealing with a nested resource?
+      if index > 0
+        parent_resource = [ ancestors[index-1] ]
+      else
+        parent_resource = []
+      end
+
+      # Determine what the path should start off with. Namely, allow for the case
+      # that a module namespace might be needed; provided by a subclass' 
+      # implementation of module_symbol_for_paths:
+      base_path = if module_symbol_for_paths
+        [module_symbol_for_paths]
+      else
+        []
+      end
+      
+      crumb_path_array = base_path.concat(parent_resource).push(ancestors[index])
+
+      # Are we processing the last breadcrumb in the sequence?
+      if index == (total_crumbs - 1)
+        # YES: So cue breadcrumbs_on_rails to use a no-op URL and a diffused CSS style.
+        url = '#'
+        options = {class: 'active'}
+      else
+        # NO: Do allow this breadcrumb to be a real link to its resource.
+        current_resource = crumb_path_array.last
+
+        # Is the current model a singular child resource?
+        if current_resource.is_singular_child_resource?
+          # YES. So we need to swap it out in the crumb path array with
+          # a singular symbol of itself instead, so that when passed to url_for(),
+          # a correct URL path will be constructed.
+          crumb_path_array[-1] = crumb_path_array.last.class.to_s.tableize.singularize.to_sym
+        end
+
+        url = url_for(crumb_path_array)
+        options = {}
+      end
+
+      add_breadcrumb crumb_name, url, options # breadcrumbs_on_rails call
+    end
+  end
+
+  
+end

data/app/controllers/interchange/base_controller.rb

@@ -0,0 +1,63 @@
+class Interchange::BaseController < ApplicationController 
+
+  # This constructor sets up a writer class, which we'll use if we do any export for automation or export for
+  # later import purposes. The writer handles the details of writing a model's contents to disk.
+  def initialize
+    super
+    @writer = Interchange::Writer.new 
+  end
+
+
+  # NOTE: This method is meant to be called by a subclass, that sets up the
+  #       @model instance variable for us (along with other instance variables
+  #       that the template we render would be expecting).
+  def show
+    pretty_json = render_show_template_to_string(@model, params) # Calls the two-parameter variant our subclasses should implement
+    decorated_json = @writer.decorate_output(@model, pretty_json, params)
+    render json: decorated_json
+  end
+
+
+  protected
+
+  # Takes a string of raw JSON and renders it pretty.
+  # If no JSON string is provided, we'll do a render to string that runs
+  # under the auspices of the current controller action calling us 
+  # (or the template for the specified action).
+  def render_to_string_pretty_json(json_string=nil, options={})
+    unless json_string
+      # Use the calling action's view template to produce JSON:
+      if options[:template]
+        json_string = render_to_string(formats: :json, action: options[:template])
+      else
+        json_string = render_to_string(formats: :json)
+      end
+    end
+
+    # Reverse any newline escaping that happens right at the jbuilder stage:
+    json_string.gsub!('\\\n', '\n')
+
+    # Parse and return the pretty JSON string:
+    json_object = JSON.parse(json_string)
+    pretty_json = JSON.pretty_generate(json_object)
+    render_to_string json: pretty_json
+  end
+
+
+  # NOTE: This is not a standalone method. It is meant to be called by our subclasses,
+  # after they have setup instance variables that will be used in processing their
+  # 'show' action JSON template.
+  #
+  # We return the result of generating a pretty JSON representation from the 'show' template,
+  # as defined by the subclass controller that invokes us.
+  def render_show_template_to_string(options={})
+    @suppress_database_timestamps = true
+
+    # Since we use ids now to stitch together pointers within an export file, default this
+    # to false unless requested otherwise:
+    @suppress_database_ids = options[:suppress_database_ids]
+    render_to_string_pretty_json(nil, template: 'show')
+  end
+
+
+end # class

data/app/controllers/interchange/data_sets_controller.rb

@@ -0,0 +1,40 @@
+class Interchange::DataSetsController < Interchange::BaseController
+
+  alias :super_render_show_template_to_string :render_show_template_to_string
+  alias :super_show :show
+
+
+  def initialize
+    super
+    @model_class = DataSet
+  end
+
+
+  # ---------- Exporting ----------
+
+  # Shows a data set's JSON representation in the browser.
+  def show
+    # Find the data set and set the @data_set variable, which the jbuilder template will look for:
+    @data_set = DataSet.find(params[:id])
+
+    # Alias the @data_set variable to @model, which our superclass' implementation needs:
+    @model = @data_set
+
+    # Invoke the superclass implementation to do the rendering work:
+    super_show
+  end
+
+
+  # Returns a DataSet's JSON representation as a string.
+  #
+  # We setup the instance variables that the rendered template would need for the 
+  # given data set. We then return the result of generating a pretty JSON representation
+  # of the data set, by calling our superclass variant of this method.
+  def render_show_template_to_string(data_set, options={})
+    @data_set = data_set
+    super_render_show_template_to_string(options)
+  end
+
+
+
+end  # class

data/app/controllers/interchange/exports_controller.rb

@@ -0,0 +1,120 @@
+# Controller for export related functionality, as a RESTful resource. We handle both
+# regular exports and exports bound for UIAutomation .js data files.
+class Interchange::ExportsController < ApplicationController
+
+  layout 'application'
+
+  # This constructor sets up Writer class that we offload the low level export work to.
+  def initialize
+    super
+    @writer = Interchange::Writer.new 
+  end
+
+
+  # Shows the page of export options, as well as the results of the last export operation,
+  # if the server hasn't been bounced since that was last performed.
+  def show
+    log 'ExportsController: show'
+    marshal_options_from_session
+    options = {class: 'active'}
+    add_breadcrumb 'Export', '#', options # breadcrumbs_on_rails call
+    
+    # Retrieve results of the last export, so we can display that in our view:
+    @last_export_summary = Interchange::Writer.instance_variable_get(:@last_export_summary)
+  end
+
+
+  # This responds to the request to do the export. We invoke a helper method to handle the
+  # export of a given model class, one class at a time. Possible param values that can be provided:
+  #   * export_patients - Whether to export patients. Pass 1 for true.
+  #   * export_physicians - Whether to export physicians. Pass 1 for true.
+  #   * model_class_name - Indicates a single class we want exported. Use along with model_id to export a single object.
+  #   * model_id - The id value of the single object we want to export. Use along with model_class_name to export a single object.
+  #   * ids - A specific set of ID values to export (as opposed to all for the specified model class).
+  #   * restrict_by_keywords - Whether to restrict models exported to those with one of the keywords provided by keywords_csv.
+  #   * keywords_csv - A string of keywords, comma separated. These are keywords a model 
+  #       must have one of, in order to be included in the export.
+  # We determine what models to export from the params provided.
+  # Once complete, we redirect to the show action, with a flash message built from the 
+  # Interchange::Writer class' tally of results.
+  def create
+    log 'In create method. Initiating an export operation now.'
+    log "params: #{params}"
+    
+    marshal_options_to_session
+    
+    # Determine what models are to be included:
+    model_classes = []
+    
+    model_classes << Patient if params[:export_patients]
+    model_classes << Physician if params[:export_physicians]
+    model_classes << DocumentTemplate if params[:export_document_templates]
+    model_classes << DataSet if params[:export_data_sets]
+
+    # Did we have a specific model class given for export?
+    if params[:model_class_name]
+      # YES: Export just that class and just the ID provided:
+      model_classes << params[:model_class_name].constantize 
+      ids = [params[:model_id]] if params[:model_id]
+    end
+    
+    # If not already specified by model_id, look for a subset of IDs to 
+    # restrict the export to:
+    ids = params[:ids] unless ids
+
+    # Determine if there are keywords requested for us to filter by:
+    keywords =
+      if params[:restrict_by_keywords] && !params[:keywords_csv].blank?
+        params[:keywords_csv].split(',')
+      else
+        nil
+      end
+    
+    keywords.each do | keyword |
+      keyword.strip!
+    end if keywords
+    
+    # Start the export operation block:
+    @writer.mark_export_operation do
+      # Kick off the underlying export operation on the model(s) requested:
+      model_classes.each do |model_class|
+        @writer.export model_class, {keywords: keywords, ids: ids}
+      end
+    end
+    
+    redirect_to interchange_export_path, @writer.operation_results[:flash_hash]
+  end
+
+
+  protected
+
+  # Take the various options specified in the export dialog, which came along
+  # in the params hash, and store them in a @selections variable, which itself,
+  # gets stored in the session object. This allows for later retrieval of these
+  # options on a subsequent request-response cycle, so that these preferences
+  # (options) appear to be remembered.
+  def marshal_options_to_session
+    @selections = @selections || {}
+    @selections[:export_patients] = params[:export_patients]
+    @selections[:export_physicians] = params[:export_physicians]
+    @selections[:export_document_templates] = params[:export_document_templates]
+    @selections[:export_data_sets] = params[:export_data_sets]
+    @selections[:restrict_by_keywords] = params[:restrict_by_keywords]
+    @selections[:keywords_csv] = params[:keywords_csv]
+    
+    session[self.class.to_s] ||= {}
+    session[self.class.to_s][:selections] = @selections
+  end
+
+
+  # Retrieves the @selections hash from the session hash, which was originally
+  # stored in the method marshal_options_to_session. This allows us to have
+  # an instance variable setup for the view that will drive the UI to preselect
+  # the previously selected options.
+  def marshal_options_from_session
+    session[self.class.to_s] ||= {}
+    @selections = session[self.class.to_s][:selections] || {}
+  end
+
+
+end  # class

data/app/controllers/interchange/imports_controller.rb

@@ -0,0 +1,141 @@
+# Controller for a import related functionality, as a RESTful resource.
+class Interchange::ImportsController < ApplicationController
+
+  layout 'application'
+
+  # This constructor sets up Reader class that we offload the low level import work to.
+  def initialize
+    super
+    @reader = Interchange::Reader.new
+  end
+
+
+  # Shows the page of import options, as well as the results of the last import operation,
+  # if the server hasn't been bounced since that was last performed.
+  def show
+    log 'ImportController: show'
+    marshal_options_from_session
+    options = {class: 'active'}
+    add_breadcrumb 'Import', '#', options # breadcrumbs_on_rails call
+
+    # Retrieve results of the last import, so we can display that in our view:
+    @last_import_summary = Interchange::Reader.instance_variable_get(:@last_import_summary)
+  end
+
+
+  # This responds to the request to do the import. We invoke a helper method to handle the
+  # import of a given model class, one at a time. Possible param values that can be provided:
+  #   * import_patients - Whether to import patients. Pass 1 for true.
+  #   * import_physicians - Whether to import physicians. Pass 1 for true.
+  #   * destroy_existing - Whether to destroy existing data before starting the import. Pass 1 for true.
+  #   * cleanup - Whether to delete source files that are successfully imported. Pass 1 for true.
+  #
+  # We determine what models to import from the params provided, as well as whether to delete
+  # existing data prior to import and source import data after successful import.
+  # Once complete, we redirect to the show action, with a flash message built from the 
+  # Interchange::Reader class' tally of results.
+  def create
+    log 'In create method. Initiating an import operation now.'
+    log "params: #{params}"
+
+    # Determine what models are to be included:
+    model_classes = []
+    model_classes << Patient if params[:import_patients]
+    model_classes << Physician if params[:import_physicians]
+    model_classes << DocumentTemplate if params[:import_document_templates]
+    model_classes << DataSet if params[:import_data_sets]
+
+    # Determine what options have been requested:
+    destroy_existing = params[:destroy_existing]
+    cleanup = params[:cleanup]
+
+    duplicate_strategy =
+        case params[:duplicates]
+          when 'Allow' then
+            Enums::DuplicateStrategy::ALLOW
+          when 'Replace' then
+            Enums::DuplicateStrategy::REPLACE
+          when 'Skip' then
+            Enums::DuplicateStrategy::SKIP
+          else
+            Enums::DuplicateStrategy::SKIP
+        end
+
+    marshal_options_to_session
+
+    @reader.mark_import_operation do
+      # Kick off the underlying import operation on the model(s) requested:
+      model_classes.each do |model_class|
+        import model_class, destroy_existing, cleanup, duplicate_strategy
+      end
+    end
+
+    redirect_to interchange_import_path, @reader.operation_results[:flash_hash]
+  end
+
+
+  protected
+
+  # Take the various options specified in the import dialog, which came along
+  # in the params hash, and store them in a @selections variable, which itself,
+  # gets stored in the session object. This allows for later retrieval of these
+  # options on a subsequent request-response cycle, so that these preferences
+  # (options) appear to be remembered.
+  def marshal_options_to_session
+    @selections = @selections || {}
+    @selections[:import_patients] = params[:import_patients]
+    @selections[:import_physicians] = params[:import_physicians]
+    @selections[:import_document_templates] = params[:import_document_templates]
+    @selections[:import_data_sets] = params[:import_data_sets]
+    @selections[:destroy_existing] = params[:destroy_existing]
+    @selections[:cleanup] = params[:cleanup]
+    @selections[:duplicates] = params[:duplicates]
+
+    session[self.class.to_s] ||= {}
+    session[self.class.to_s][:selections] = @selections
+  end
+
+
+  # Retrieves the @selections hash from the session hash, which was originally
+  # stored in the method marshal_options_to_session. This allows us to have
+  # an instance variable setup for the view that will drive the UI to preselect
+  # the previously selected options.
+  def marshal_options_from_session
+    session[self.class.to_s] ||= {}
+    @selections = session[self.class.to_s][:selections] || {}
+
+    # Provide a default of 'Replace' for the duplicate strategy, if not yet specified:
+    @selections[:duplicates] = 'Replace' unless @selections[:duplicates]
+
+    # Marshal duplicate strategy as boolean for each of the specific strategy keys:
+    @selections[:allow_duplicates] = (@selections[:duplicates] == 'Allow')
+    @selections[:skip_duplicates]  = (@selections[:duplicates] == 'Skip')
+    @selections[:replace_duplicates]  = (@selections[:duplicates] == 'Replace')
+
+  end
+
+
+
+  # ---------- Importing ----------
+
+  # Imports all source files for the given model class provided, using the options specified.
+  #
+  # @param model_class {Class} The model class we are to find source files to import, and import.
+  # @param destroy_existing {Boolean} Whether we are to destroy existing models belonging to model_class
+  #   prior to the import operation.
+  # @param cleanup {Boolean} Whether to delete source import files for model instances that successfully imported.
+  # @param duplicate_strategy {Enums::DuplicateStrategy} A constant indicating how to handle duplicates. 
+  def import(model_class, destroy_existing, cleanup, duplicate_strategy)
+    log "Importing files for model class: #{model_class}, with options: " \
+      "{destroy_existing: #{destroy_existing}, cleanup: #{cleanup}, duplicate_strategy: #{duplicate_strategy}}"
+
+    # Delete all records for this model, if requested:
+    if destroy_existing
+      log_info "Interchange::ImportsController: Asked to destroy all existing instances of #{model_class}."
+      model_class.all.each { |model_instance| model_instance.destroy }
+    end
+
+    @reader.import model_class, cleanup, duplicate_strategy
+  end
+
+end  # class

data/app/controllers/reference/base_controller.rb

@@ -0,0 +1,7 @@
+class Reference::BaseController < Crud::BaseController
+  
+  def module_symbol_for_paths
+    :reference
+  end
+  
+end

data/app/controllers/reference/data_lists_controller.rb

@@ -0,0 +1,177 @@
+class Reference::DataListsController < Reference::BaseController
+    
+  before_filter :retrieve_data_listable
+
+
+  # GET /reference/data_lists
+  # GET /reference/data_lists.json
+  #
+  # The index action should only ever be called on this polymorphic model in the 
+  # context of a parent resource (our @data_listable).
+  def index
+    if @data_listable.instance_of?(DataOption)
+      redirect_to :show
+    end
+
+    @data_lists = @data_listable.data_lists
+    configure_breadcrumbs @data_listable, :data_lists
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.json { render json: @data_lists }
+    end
+  end
+
+
+  # GET /reference/data_lists/1
+  # GET /reference/data_lists/1.json
+  def show
+    retrieve_data_list
+   
+    respond_to do |format|
+      format.html # show.html.erb
+      format.json { render json: @data_list }
+    end
+  end
+
+
+  # GET /reference/data_lists/new
+  # GET /reference/data_lists/new.json
+  def new
+    @data_list = if @data_listable.instance_of?(DataOption)
+      DataList.new(DataList.default_options)
+    else
+      @data_listable.data_lists.new(DataList.default_options)
+    end
+    
+    configure_breadcrumbs @data_listable, :data_list
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.json { render json: @data_list }
+    end
+  end
+
+
+  # GET /reference/data_lists/1/edit
+  def edit
+    retrieve_data_list
+  end
+
+
+  # POST /reference/data_lists
+  # POST /reference/data_lists.json
+  def create
+    @data_list = if @data_listable.instance_of?(DataOption)
+      @data_listable.nested_data_list = DataList.new(params[:data_list])
+    else
+      @data_listable.data_lists.new(params[:data_list])
+    end
+
+    respond_to do |format|
+      if @data_list.save
+        format.html do
+          success_path = if @data_listable.instance_of?(DataOption)
+            [:reference, @data_listable, :nested_data_list]
+          else
+            [:reference, @data_listable, @data_list]
+          end
+          
+           redirect_to success_path, notice: 'Data List was successfully created.' 
+        end
+        format.json { render json: @data_list, status: :created, location: @data_list }
+      else
+        format.html do
+            # Set breadcrumbs again, otherwise they'd be lost on render of 'new' template:
+            configure_breadcrumbs @data_listable, :data_list
+            render action: "new"
+          end
+        format.json { render json: @data_list.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+
+  # PUT /reference/data_lists/1
+  # PUT /reference/data_lists/1.json
+  def update
+    retrieve_data_list
+
+    respond_to do |format|
+      if @data_list.update_attributes(params[:data_list])
+        Reference::DataTypes.reload # Update all of our reference data, given the updated DataList
+        format.html { redirect_to [:reference, @data_listable, @data_list], notice: 'Data List was successfully updated.' }
+        format.json { head :no_content }
+      else
+        format.html { render action: "edit" }
+        format.json { render json: @data_list.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+
+  # DELETE /reference/data_lists/1
+  # DELETE /reference/data_lists/1.json
+  def destroy
+    retrieve_data_list
+    root_resource = @data_list.root_resource
+    @data_list.destroy if @data_list
+    root_resource.export_update # Allow root resource to save update to disk
+
+    Reference::DataTypes.reload # Update all of our reference data, given the removed DataList
+
+    respond_to do |format|
+      format.html { redirect_to [:reference, @data_listable, :data_lists],
+                                notice: 'Data List was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+  
+  
+
+  private 
+  
+  # Find the data_listable resource we belong to.
+  # Credit: http://railscasts.com/episodes/154-polymorphic-association-revised
+  def retrieve_data_listable
+    resource, id = request.path.split('/')[2, 3] # Start at index 2 and not 1, because we use the reference namespace
+    log "Resource name retrieved: #{resource}"
+    @data_listable = resource.singularize.classify.constantize.find(id)
+
+    # Retrieve data_set through the resource ancestor chain, so layout template
+    # has something to work with re: special notifications:
+    @data_set = @data_listable.resource_ancestors.first
+
+    # alternative option per Railscasts on polymorhpic relationships:
+    #   klass = [Allergy, Condition].detect { |c| params["#{c.name.underscore}_id"] }
+    #   @data_listable = klass.find(params["#{klass.name.underscore}_id"])
+  end
+
+
+  # def retrieve_data_list
+  #   @data_list = DataList.find(params[:id])
+  #   configure_breadcrumbs @data_list
+  # end
+
+
+  def retrieve_data_list
+    retrieve_data_listable unless @data_listable
+    
+    log "params: #{params}"
+    log "data_listable: #{@data_listable}"
+    
+    @data_list = if params[:id] && !@data_listable.instance_of?(DataOption)
+      DataList.find(params[:id])
+    else 
+      @data_listable.try(:nested_data_list)
+    end
+
+
+    if @data_list
+      configure_breadcrumbs @data_list
+    else
+      configure_breadcrumbs @data_listable, :data_list
+    end
+  end
+
+end