think_feel_do_engine 3.10.6

data/app/models/think_feel_do_engine/reports/patient_activity.rb

@@ -0,0 +1,22 @@
+module ThinkFeelDoEngine
+  module Reports
+    # Collect metadata for each Participant Activity.
+    class PatientActivity
+      def self.columns
+        %w( participant_id activity_title created_at )
+      end
+
+      def self.all
+        Participant.select(:id, :study_id).map do |participant|
+          participant.activities.map do |activity|
+            {
+              participant_id: participant.study_id,
+              activity_title: activity.title,
+              created_at: activity.created_at.iso8601
+            }
+          end
+        end.flatten
+      end
+    end
+  end
+end

data/app/models/think_feel_do_engine/reports/patient_thought.rb

@@ -0,0 +1,22 @@
+module ThinkFeelDoEngine
+  module Reports
+    # Collect metadata for all Participant Thoughts.
+    class PatientThought
+      def self.columns
+        %w( participant_id content created_at )
+      end
+
+      def self.all
+        Participant.select(:id, :study_id).map.map do |participant|
+          participant.thoughts.map do |thought|
+            {
+              participant_id: participant.study_id,
+              content: thought.content,
+              created_at: thought.created_at.iso8601
+            }
+          end
+        end.flatten
+      end
+    end
+  end
+end

data/app/models/think_feel_do_engine/reports/phq_assessment.rb

@@ -0,0 +1,32 @@
+module ThinkFeelDoEngine
+  module Reports
+    # Scenario: Participants complete a Phq Assessment by email.
+    class PhqAssessment
+      def self.columns
+        %w( participant_id date_transmitted date_completed phq1 phq2 phq3 phq4
+            phq5 phq6 phq7 phq8 phq9 )
+      end
+
+      def self.all
+        Participant.select(:id, :study_id).map do |participant|
+          participant.phq_assessments.map do |assessment|
+            {
+              participant_id: participant.study_id,
+              date_transmitted: assessment.release_date.iso8601,
+              date_completed: assessment.updated_at.to_date.iso8601,
+              phq1: assessment.q1,
+              phq2: assessment.q2,
+              phq3: assessment.q3,
+              phq4: assessment.q4,
+              phq5: assessment.q5,
+              phq6: assessment.q6,
+              phq7: assessment.q7,
+              phq8: assessment.q8,
+              phq9: assessment.q9
+            }
+          end
+        end.flatten
+      end
+    end
+  end
+end

data/app/models/think_feel_do_engine/reports/reporter.rb

@@ -0,0 +1,45 @@
+require "csv"
+
+module ThinkFeelDoEngine
+  module Reports
+    # Produces formatted versions of data produced by a data collector.
+    # The collector is expected to have two methods:
+    # `columns` returns a collection of column names
+    # `all` returns a collection of Hashes whose keys match the column names
+    class Reporter
+      def self.fetch_reports
+        return [] unless Rails.application.config.respond_to?(:reports)
+        Rails.application.config.reports
+      end
+
+      def self.file_path(name)
+        Rails.application.config.reports_root_path
+          .join("reports/#{name.to_s.scan(/[a-z]+/).join.downcase}.csv")
+      end
+
+      def initialize(collector)
+        @collector = collector
+        @path = self.class.file_path(parsed_name)
+      end
+
+      def write_csv
+        CSV.open(@path, "wb") do |csv|
+          to_csv(csv)
+        end
+      end
+
+      def to_csv(csv = [])
+        csv << @collector.columns
+        @collector.all.each do |s|
+          csv << @collector.columns.map { |c| s[c.to_sym] }
+        end
+      end
+
+      private
+
+      def parsed_name
+        @collector.name.split("::").last.downcase
+      end
+    end
+  end
+end

data/app/models/think_feel_do_engine/reports/site_session.rb

@@ -0,0 +1,63 @@
+module ThinkFeelDoEngine
+  module Reports
+    # Scenario: a Participant is active on the site for a period of time.
+    class SiteSession
+      THRESHOLD = 5.minutes
+
+      def self.columns
+        %w( participant_id sign_in_at first_action_at last_action_at )
+      end
+
+      def self.all
+        Participant.select(:id, :study_id).map do |participant|
+          earliest_click_time = latest_click_time = nil
+          times = click_times(participant.id)
+          times.map do |click_time|
+            earliest_click_time ||= click_time
+            latest_click_time ||= earliest_click_time
+
+            if click_time - latest_click_time < THRESHOLD &&
+               click_time != times.last
+              # this click is part of the current session
+              latest_click_time = click_time
+
+              nil
+            else
+              # this click is part of the next session or
+              # it's the last click
+              sign_in = preceding_sign_in(participant.id,
+                                          earliest_click_time)
+              session = {
+                participant_id: participant.study_id,
+                sign_in_at: sign_in.try(:iso8601),
+                first_action_at: earliest_click_time.iso8601,
+                last_action_at: latest_click_time.iso8601
+              }
+              earliest_click_time = latest_click_time = nil
+
+              session
+            end
+          end.compact
+        end.flatten
+      end
+
+      def self.click_times(participant_id)
+        EventCapture::Event
+          .where(participant_id: participant_id, kind: "click")
+          .order(:emitted_at)
+          .select(:emitted_at)
+          .map(&:emitted_at)
+      end
+
+      # Returns the sign in for the Participant closest to the given time.
+      def self.preceding_sign_in(participant_id, time)
+        ParticipantLoginEvent
+          .where(participant_id: participant_id)
+          .order(:created_at)
+          .where("created_at < ?", time)
+          .last
+          .try(:created_at)
+      end
+    end
+  end
+end

data/app/models/think_feel_do_engine/reports/task_completion.rb

@@ -0,0 +1,30 @@
+module ThinkFeelDoEngine
+  module Reports
+    # Scenario: a Participant completes a Task on the assigned day.
+    class TaskCompletion
+      def self.columns
+        %w( participant_id title completed_on )
+      end
+
+      def self.all
+        Participant.select(:id, :study_id)
+          .includes(:memberships).map do |participant|
+          next unless participant.active_membership
+
+          TaskStatus.where(membership_id: participant.active_membership.id)
+            .map do |task_status|
+            next unless task_status.completed_at.try(:to_date) ==
+                        participant.active_membership.start_date +
+                        task_status.start_day - 1
+
+            {
+              participant_id: participant.study_id,
+              title: task_status.task.title,
+              completed_on: task_status.completed_at.to_date.iso8601
+            }
+          end
+        end.flatten.compact
+      end
+    end
+  end
+end

data/app/models/think_feel_do_engine/reports/tool_access.rb

@@ -0,0 +1,51 @@
+module ThinkFeelDoEngine
+  module Reports
+    # Scenario: a Participant accesses a Tool Module.
+    class ToolAccess
+      def self.columns
+        %w( participant_id module_title came_from occurred_at )
+      end
+
+      def self.all
+        Participant.select(:id, :study_id).map do |participant|
+          tool_access_events(participant).map do |tool_access|
+            {
+              participant_id: participant.study_id,
+              module_title: tool_access[:title],
+              came_from: tool_access[:source],
+              occurred_at: tool_access[:time].iso8601
+            }
+          end
+        end.flatten
+      end
+
+      def self.tool_access_events(participant)
+        sources = {
+          "list-group left" => "Tool home",
+          "list-group right" => "Tool home",
+          "<li>" => "Nav menu",
+          '<li class="list-group-item' => "To do list"
+        }
+        module_titles = BitCore::ContentModule.all.map(&:title)
+
+        EventCapture::Event
+          .where(kind: "click", participant_id: participant.id).map do |e|
+            title = module_titles.find do |t|
+              e.payload["buttonHtml"].include?(t)
+            end
+            source = sources.keys.find do |s|
+              e.payload["parentHtml"].try(:include?, s)
+            end
+
+            next unless title && source
+
+            {
+              title: title,
+              source: sources[source],
+              time: e.emitted_at
+            }
+          end.compact
+      end
+    end
+  end
+end

data/app/models/think_feel_do_engine/reports/tool_module.rb

@@ -0,0 +1,29 @@
+module ThinkFeelDoEngine
+  module Reports
+    # Helper methods for reporting on modules.
+    module ToolModule
+      URL_ROOT_RE = /^[^\/]*\/\/[^\/]+/
+
+      def self.included(klass)
+        class << klass
+          # Returns a hash mapping path to Tool Module.
+          def modules_map
+            tool_modules.each_with_object({}) do |m, h|
+              h[url_helpers.navigator_location_path(module_id: m.id)] = m
+            end
+          end
+
+          private
+
+          def tool_modules
+            BitCore::ContentModule.where(type: nil)
+          end
+
+          def url_helpers
+            ThinkFeelDoEngine::Engine.routes.url_helpers
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/think_feel_do_engine/reports/user_agent.rb

@@ -0,0 +1,33 @@
+require "user_agent_parser"
+
+module ThinkFeelDoEngine
+  module Reports
+    # Scenario: a Participant accesses the site with a unique user agent.
+    class UserAgent
+      def self.columns
+        %w( participant_id user_agent_family user_agent_version user_agent_os )
+      end
+
+      def self.all
+        Participant.select(:id, :study_id).map do |participant|
+          user_agents = EventCapture::Event
+                        .where(participant_id: participant.id)
+                        .map { |event| event.payload[:ua] }
+                        .uniq
+
+          user_agents.map do |agent|
+            ua = UserAgentParser.parse(agent)
+            next if ua.family == "Other" && ua.version.to_s == ""
+
+            {
+              participant_id: participant.study_id,
+              user_agent_family: ua.family,
+              user_agent_version: ua.version.to_s,
+              user_agent_os: ua.os.to_s
+            }
+          end
+        end.flatten.compact
+      end
+    end
+  end
+end

data/app/models/think_feel_do_engine/reports/video_session.rb

@@ -0,0 +1,65 @@
+module ThinkFeelDoEngine
+  module Reports
+    # Scenario: a Participant plays a video.
+    class VideoSession
+      def self.columns
+        %w( participant_id video_title video_started_at video_stopped_at
+            stopping_action )
+      end
+
+      def self.all
+        Participant.select(:id, :study_id).map do |participant|
+          video_play_events(participant.id).map do |e|
+            m = e.current_url.match(/.*\/providers\/(\d+)\/(\d+)$/)
+            provider_id = m ? m[1] : -1
+            position = m ? m[2] : -1
+            video = BitCore::ContentProvider
+                    .where(id: provider_id)
+                    .first
+                    .try(:source_content)
+                    .try(:slides)
+                    .try(:find_by_position, position)
+            next_e = next_event(e)
+
+            {
+              participant_id: participant.study_id,
+              video_title: video.try(:title),
+              video_started_at: e.emitted_at.iso8601,
+              video_stopped_at: next_e.try(:emitted_at).try(:iso8601),
+              stopping_action: next_e.try(:kind)
+            }
+          end
+        end.flatten
+      end
+
+      def self.video_play_events(participant_id)
+        EventCapture::Event
+          .where(participant_id: participant_id, kind: "videoPlay")
+          .select(:participant_id, :kind, :emitted_at, :payload)
+          .order(:emitted_at)
+      end
+
+      # Return the immediately following Event for the Participant that is not a
+      # video play event, or nil if none exist.
+      def self.next_event(event)
+        event = EventCapture::Event.next_event_for(event)
+
+        return if event.nil?
+        return event if event && event.kind != "videoPause"
+
+        # if the event is a pause and there's an immediately following finish,
+        # return the finish event
+        finish_event = EventCapture::Event
+                       .where(participant_id: event.participant_id)
+                       .where("emitted_at > ? AND emitted_at < ?",
+                              event.emitted_at,
+                              event.emitted_at + 2.seconds)
+                       .order(:emitted_at)
+                       .limit(1)
+                       .first
+
+        finish_event.try(:kind) == "videoFinish" ? finish_event : event
+      end
+    end
+  end
+end

data/app/models/think_feel_do_engine/reports/wai_assessment.rb

@@ -0,0 +1,35 @@
+module ThinkFeelDoEngine
+  module Reports
+    # Scenario: Participants complete a Wai Assessment by email.
+    class WaiAssessment
+      def self.columns
+        %w( participant_id date_transmitted date_completed wai1 wai2 wai3 wai4
+            wai5 wai6 wai7 wai8 wai9 wai10 wai11 wai12 )
+      end
+
+      def self.all
+        Participant.select(:id, :study_id).map do |participant|
+          participant.wai_assessments.map do |assessment|
+            {
+              participant_id: participant.study_id,
+              date_transmitted: assessment.release_date.iso8601,
+              date_completed: assessment.updated_at.to_date.iso8601,
+              wai1: assessment.q1,
+              wai2: assessment.q2,
+              wai3: assessment.q3,
+              wai4: assessment.q4,
+              wai5: assessment.q5,
+              wai6: assessment.q6,
+              wai7: assessment.q7,
+              wai8: assessment.q8,
+              wai9: assessment.q9,
+              wai10: assessment.q10,
+              wai11: assessment.q11,
+              wai12: assessment.q12
+            }
+          end
+        end.flatten
+      end
+    end
+  end
+end

data/app/models/thought.rb

@@ -0,0 +1,80 @@
+# A thought recorded by a Participant.
+class Thought < ActiveRecord::Base
+  EFFECTS = {
+    helpful: "helpful",
+    harmful: "harmful",
+    neither: "neither"
+  }
+  IDENTIFIED = "Identified"
+  ASSIGNED_A_PATTERN = "Assigned a pattern to"
+  RESHAPED = "Reshaped"
+
+  belongs_to :participant
+  belongs_to :pattern, class_name: "ThoughtPattern", foreign_key: :pattern_id
+
+  before_validation :clean_attributes
+
+  validates :participant, :content, :effect, presence: true
+  validates :effect, inclusion: { in: EFFECTS.values }
+
+  delegate :description,
+           :recommendations,
+           :title,
+           to: :pattern,
+           prefix: true,
+           allow_nil: true
+
+  scope :helpful, -> { where(effect: EFFECTS[:helpful]) }
+
+  scope :harmful, -> { where(effect: EFFECTS[:harmful]) }
+
+  scope :no_pattern, -> { where(pattern_id: nil) }
+
+  scope :unreflected, lambda {
+    where(effect: EFFECTS[:harmful])
+      .where(arel_table[:challenging_thought].eq(nil)
+        .or(arel_table[:act_as_if].eq(nil)))
+  }
+
+  scope :last_seven_days, lambda {
+    where(
+      arel_table[:created_at]
+        .gteq(Time.current.advance(days: -7).beginning_of_day))
+  }
+
+  scope :for_day, lambda { |time|
+    where(
+      arel_table[:created_at]
+        .gteq(time.beginning_of_day)
+        .and(arel_table[:created_at].lteq(time.end_of_day))
+    )
+  }
+
+  def status_label
+    if !pattern_id && !challenging_thought
+      IDENTIFIED
+    elsif pattern_id && !challenging_thought
+      ASSIGNED_A_PATTERN
+    elsif challenging_thought
+      RESHAPED
+    end
+  end
+
+  def shared_description
+    "Thought: #{ content }"
+  end
+
+  private
+
+  def clean_attributes
+    def clean_attribute(attr)
+      if self[attr].respond_to?(:strip)
+        cleaned = self[attr].strip
+        send("#{ attr }=", cleaned == "" ? nil : cleaned)
+      end
+    end
+
+    clean_attribute(:challenging_thought)
+    clean_attribute(:act_as_if)
+  end
+end