study_engine 0.0.2

data/app/models/study_engine/existing_assessments_form.rb

@@ -0,0 +1,99 @@
+require "study_engine/assessment"
+require "study_engine/config"
+
+module StudyEngine
+  class ExistingAssessmentsForm
+    include ActiveModel::Validations
+    extend ActiveModel::Naming
+
+    def self.model_name
+      ActiveModel::Name.new(Assessment)
+    end
+
+    validate :format_of_study_id
+    validate :presence_of_some_event
+    validate :presence_of_previous_events
+
+    def initialize attributes = {}
+      self.study_id = StudyID.new
+      self.event_datetimes ||= []
+      attributes.each do |name, value|
+        send("#{name}=", value)
+      end
+    end
+
+    def to_model
+      self
+    end
+
+    def to_key
+    end
+
+    def persisted?
+      false
+    end
+
+    attr_accessor :study_id, :method_applied, :event_datetimes
+
+    delegate :study, :site, :id, to: :study_id, prefix: true
+    delegate :study=, :site=, :id=, to: :study_id, prefix: true
+
+    def method_applied
+      @method_applied || "In-person"
+    end
+
+    def study_options
+      StudyID::Bank.studies
+    end
+
+    def save
+      if valid?
+        base = Assessment.by_study_id(study_id)
+        event_datetimes.each.with_index do |datetime, index|
+          next if datetime.blank?
+          event = StudyEngine.events[index]
+          assessment = base.by_event(event).create!(created_at: datetime, assessment_updated_at: datetime, method_applied: method_applied)
+          assessment.update_column :group_index, nil
+        end
+        true
+      end
+    end
+
+    private
+
+    def format_of_study_id
+      if study_id.present?
+        unless study_id.valid?
+          errors.add :base, "METRC study ID must be in the following format: XXX-XXX-####"
+        end
+      else
+        errors.add :base, "METRC study ID can not be blank.  Enter ID in the following format: XXX-XXX-####"
+      end
+    end
+
+    def presence_of_some_event
+      if event_datetimes.all?(&:blank?)
+        events = StudyEngine.events.dup
+        events.map!(&:downcase)
+        events.last.prepend("or ")
+        events = events.join(", ")
+        errors.add :base, "A #{events} timestamp must be present"
+      end
+    end
+
+    def presence_of_previous_events
+      event_datetimes.each.with_index do |datetime, index|
+        next if datetime.blank? || index.nil? || index.zero?
+        event = StudyEngine.events[index]
+        previous_events = StudyEngine.events[0...index]
+
+        previous_events.each.with_index do |previous_event, index|
+          if event_datetimes[index].blank? && Assessment.by_study_id(study_id).by_event(previous_event).none?
+            errors.add :base, "Cannot add a #{event.downcase} assessment when #{previous_event.downcase} assessment does not exist"
+          end
+        end
+      end
+    end
+  end
+end
+

data/app/models/study_engine/form.rb

@@ -0,0 +1,59 @@
+require "active_support/core_ext/module/delegation"
+
+module StudyEngine
+  class Form
+    include ActiveModel::Validations
+    extend ActiveModel::Naming
+
+    def self.wraps(model)
+      @wraps = model
+    end
+
+    def self.model_name
+      ActiveModel::Name.new(wrapped_class)
+    end
+
+    def self.wrapped_class
+      @wraps.to_s.classify.constantize
+    end
+
+    def self.lookup_ancestors
+      [self]
+    end
+
+    cattr_accessor(:attributes_list) { [] }
+
+    def self.attributes *attributes
+      attributes.each do |attribute|
+        attributes_list << attribute
+        attr_accessor attribute
+      end
+    end
+
+    def self.new_from_model model
+      attributes = model.attributes.slice(*attributes_list.map(&:to_s))
+      new attributes
+    end
+
+    def initialize attributes = {}, model = self.class.wrapped_class.new
+      @model = model
+      attributes.each do |name, value|
+        send("#{name}=", value)
+      end
+    end
+
+    def attributes
+      attributes_list.reduce({}) do |hash, key|
+        hash[key] = send(key)
+        hash
+      end
+    end
+
+    def save
+      @model.update_attributes(attributes) if valid?
+    end
+
+    delegate :to_model, :to_key, :to_param, :to_partial_path, :persisted?, :new_record?, to: :@model
+  end
+end
+

data/app/models/study_engine/report.rb

@@ -0,0 +1,69 @@
+require "study_engine/config"
+
+module StudyEngine
+  class Report < Struct.new(:assessments, :field, :direction)
+    def self.event_fields
+      StudyEngine.events.map.with_index { |_, index| :"event_#{index}" }
+    end
+
+    def self.group_class
+      Struct.new(:study_id, *event_fields) do
+        def each(&block)
+          Report.event_fields.map { |field| send(field) }.each(&block)
+        end
+
+        def max_count
+          Report.event_fields.map { |field| send(field).count }.max
+        end
+
+        def == other
+          values == other.values
+        end
+      end
+    end
+
+    def groups
+      sort build_groups
+    end
+
+    def build_groups
+      assessments.reduce({}) do |groups, assessment|
+        group = groups[assessment.study_id.to_s] || new_empty_group(assessment.study_id)
+
+        field = field_map[assessment.event]
+
+        group.send(field).push assessment
+        group.send(field).sort_by! { |a| a.completed_at ? -1 : 1 }
+
+        groups.merge(assessment.study_id.to_s => group)
+      end.values
+    end
+
+    def sort groups
+      groups.sort do |a, b|
+        a = a.send(field)
+        b = b.send(field)
+        ascending? ? a <=> b : b <=> a
+      end
+    end
+
+    def ascending?
+      direction == "ASC"
+    end
+
+    private
+
+    def field_map
+      StudyEngine.events.inject({}) do |hash, event|
+        index = StudyEngine.events.index(event)
+        hash.merge event => "event_#{index}"
+      end
+    end
+
+    def new_empty_group(study_id)
+      empty_groups = StudyEngine.events.map { |_| [] }
+      self.class.group_class.new(study_id, *empty_groups)
+    end
+  end
+end
+

data/app/models/study_engine/result.rb

@@ -0,0 +1,46 @@
+require "cat_engine/bank"
+require "cat_engine/engine"
+
+module StudyEngine
+  class Result < ActiveRecord::Base
+    belongs_to :assessment, touch: true
+
+    has_many :answers
+
+    delegate :current_question, to: :bank
+
+    def bank
+      CatEngine::Bank.new(bank_id, history, assessment.full_history)
+    end
+
+    def name
+      bank_id.sub(".flat","")
+    end
+
+    def history
+      answers.pluck(:response_id).join(" ")
+    end
+
+    def save_answer answer
+      wrapper do # race condition could bypass validity check
+        if bank.valid_answer?(answer.response_id)
+          answers << answer
+          update_attributes bank.to_h
+          save!
+        end
+      end
+    end
+
+    private
+
+    def wrapper
+      # UGH HACK HACK HACK why can't FlatEngine handle being wrapped in a lock?
+      if bank.send(:engine).is_a? CatEngine::Engine
+        with_lock { yield }
+      else
+        yield
+      end
+    end
+  end
+end
+

data/app/models/study_engine/screen_results.rb

@@ -0,0 +1,54 @@
+require "study_engine/config"
+
+module StudyEngine
+  class ScreenResults < Struct.new(:groups)
+    def each &block
+      block.call header
+      body block
+    end
+
+    private
+
+    def header
+      fields = ["Study ID"]
+      StudyEngine.events.each do |event|
+        fields += ["#{event} incomplete", "#{event} timestamp", "#{event} method", "#{event} coordinator", "#{event} note"]
+        fields += ["#{event} set"] if StudyEngine.groups[event].present?
+      end
+      fields.flatten
+    end
+
+    def body block
+      groups.each do |group|
+        group.max_count.times do |count|
+          col = [group.study_id.to_s]
+
+          col = group.each_with_index.inject(col) do |col, (assessments, index)|
+            col + assessment_segment(assessments[count], index)
+          end
+
+          block.call col
+        end
+      end
+    end
+
+    def assessment_segment assessment, index
+      assessment ? existing_assessment(assessment) : empty_assessment(index)
+    end
+
+    def existing_assessment assessment
+      summary = assessment.incomplete? && !assessment.by_mail? ? assessment.results_summary : ""
+      col = [summary, assessment.assessment_updated_at.to_s, assessment.method_applied, assessment.coordinator.try(:email), assessment.notes.to_s]
+      col << assessment.group_index_name if assessment.group_index
+      col
+    end
+
+    def empty_assessment index
+      col = ["", "", "", "", ""]
+      event = StudyEngine.events[index]
+      col << "" if StudyEngine.groups[event].present?
+      col
+    end
+  end
+end
+

data/app/models/study_engine/study_id.rb

@@ -0,0 +1,47 @@
+require "equalizer"
+
+module StudyEngine
+  class StudyID
+    def self.load slug
+      return unless slug
+      new slug
+    end
+
+    def self.dump study_id
+      study_id.to_s
+    end
+
+    include Equalizer.new(:study, :site, :id)
+
+    attr_accessor :study, :site, :id
+
+    def initialize slug=nil
+      @study, @site, @id = slug.split("-") if slug
+    end
+
+    def study= value
+      @study = value.try(:upcase)
+    end
+
+    def site= value
+      @site = value.try(:upcase)
+    end
+
+    def to_s
+      [study, site, id].join("-")
+    end
+
+    def <=> other
+      to_s <=> other.to_s
+    end
+
+    def present?
+      [@study, @site, @id].all?(&:present?)
+    end
+
+    def valid?
+      to_s =~ %r{\A[A-Z]{3}-[A-Z]{3}-[0-9]{4}\Z}
+    end
+  end
+end
+

data/app/models/study_engine/study_id/bank.rb

@@ -0,0 +1,38 @@
+module StudyEngine
+  class StudyID
+    class Bank < ActiveRecord::Base
+      self.table_name = "study_engine_study_ids"
+
+      def self.find_or_create_from_full_study_id study_id
+        study_id_study, study_id_site, study_id_id = study_id.split("-")
+        find_or_create_by study_id_study: study_id_study, study_id_site: study_id_site, study_id_id: study_id_id
+      end
+
+      def self.studies
+        pluck(:study_id_study).uniq.sort
+      end
+
+      def self.sites
+        pluck(:study_id_site).uniq.sort
+      end
+
+      def self.ids_grouped_by_study_and_site
+        all.reduce(Hash.new([])) do |hash, study_id|
+          hash[study_id.study_id_study + study_id.study_id_site] += [study_id.study_id_id]
+          hash
+        end
+      end
+
+      def self.studies_grouped_by_site
+        all.reduce(Hash.new(Set.new)) do |hash, study_id|
+          hash[study_id.study_id_site] += [study_id.study_id_study]
+          hash
+        end
+      end
+
+      validates :study_id_study, :study_id_site, format: /\A[A-Z]{3}\Z/
+      validates :study_id_id, format: /\A[0-9]{4}\Z/
+    end
+  end
+end
+

data/app/models/study_engine/study_id/sync.rb

@@ -0,0 +1,52 @@
+require "faraday"
+require "csv"
+require "study_engine/config"
+
+module StudyEngine
+  class StudyID
+    class Sync
+      def self.call
+        new.call
+      end
+
+      def call
+        raise "Cannot sync with REDCap without setting StudyEngine.redcap_token" if StudyEngine.redcap_token.blank?
+        CSV.parse(response, headers: true) do |row|
+          process row unless row.empty?
+        end
+        StudyID::Bank.where(["updated_at < ?", 30.minutes.ago]).delete_all
+      end
+
+      private
+
+      def process row
+        study_id = StudyID::Bank.find_or_create_from_full_study_id(row["study_id"])
+        study_id.touch unless study_id.new_record?
+      end
+
+      def response
+        conn = Faraday.new(url: "https://metrcdata.org")
+        resp = conn.post "/redcap/api/",
+          token: StudyEngine.redcap_token,
+          content: "record",
+          format: "csv"
+        resp.body
+      end
+
+      prepend Module.new {
+        def response
+          retries = 0
+          super
+        rescue Faraday::TimeoutError
+          retries += 1
+          if retries < 5
+            retry
+          else
+            raise
+          end
+        end
+      }
+    end
+  end
+end
+