think_feel_do_engine 3.10.6

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

@@ -0,0 +1,47 @@
+module ThinkFeelDoEngine
+  module Reports
+    # Shared Lesson Module behavior.
+    module LessonModule
+      URL_ROOT_RE = /^[^\/]*\/\/[^\/]+/
+
+      def self.included(klass)
+        class << klass
+          # Returns a hash mapping lesson entry (first slide) path to Lesson
+          # Module id.
+          def lesson_entries_map
+            lessons = ContentModules::LessonModule.all.map do |m|
+              first_provider_id = m.provider(1).try(:id)
+              next unless first_provider_id
+
+              path = navigator_location_path(module_id: m.id,
+                                             provider_id: first_provider_id,
+                                             content_position: 1)
+
+              ["#{ path }", m.id]
+            end.compact
+
+            Hash[lessons]
+          end
+
+          # Returns a hash mapping path to Lesson Module id.
+          def lessons_map
+            lessons = ContentModules::LessonModule.all.map do |m|
+              path = navigator_location_path(module_id: m.id)
+
+              ["#{ path }", m.id]
+            end
+
+            Hash[lessons]
+          end
+
+          private
+
+          def navigator_location_path(options)
+            ThinkFeelDoEngine::Engine.routes.url_helpers
+              .navigator_location_path(options)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+module ThinkFeelDoEngine
+  module Reports
+    # Scenario: a Participant starts viewing a Slide.
+    class LessonSlideView
+      include LessonModule
+
+      def self.columns
+        %w( participant_id lesson_id slide_id slide_title slide_selected_at
+            slide_exited_at )
+      end
+
+      def self.all
+        interactions = all_slide_interactions
+
+        # condense adjacent interactions
+        filtered_interactions = []
+        interactions.each_with_index do |interaction, i|
+          previous_interaction = i > 0 ? interactions[i - 1] : {}
+          next if previous_interaction[:slide_id] == interaction[:slide_id]
+
+          next_interaction = interactions[i + 1] || {}
+          filtered_interaction = interaction.clone
+
+          if next_interaction[:slide_id] == interaction[:slide_id]
+            filtered_interaction[:slide_exited_at] =
+              next_interaction[:slide_exited_at]
+          end
+
+          filtered_interactions << filtered_interaction
+        end
+
+        filtered_interactions
+      end
+
+      def self.all_slide_interactions
+        lessons = lessons_map
+
+        Participant.select(:id, :study_id).map do |participant|
+          slide_view_events(lessons, participant.id).map do |lesson_event|
+            e = lesson_event[1]
+            lesson_id = lesson_event[0]
+            slides = ContentModules::LessonModule.find(lesson_id).slides
+            slide = find_slide_by_url(slides, e.current_url)
+
+            {
+              participant_id: participant.study_id,
+              lesson_id: lesson_id,
+              slide_id: slide.try(:id),
+              slide_title: slide.try(:title),
+              slide_selected_at: e.emitted_at.try(:iso8601),
+              slide_exited_at: next_event_at(e).try(:iso8601)
+            }
+          end
+        end.flatten
+      end
+
+      # Events for a Participant in which a Lesson Slide is viewed.
+      def self.slide_view_events(lessons, participant_id)
+        EventCapture::Event
+          .where(participant_id: participant_id, kind: %w( click render ))
+          .select(:participant_id, :emitted_at, :payload)
+          .order(:emitted_at)
+          .to_a.map do |e|
+            key = lessons.keys.find do |l|
+              !e.current_url.match(/#{ l }(\/.*)?$/).nil?
+            end
+
+            key ? [lessons[key], e] : nil
+          end.compact
+      end
+
+      # Return the time of the Event immediately following if one exists,
+      # nil otherwise.
+      def self.next_event_at(event)
+        EventCapture::Event
+          .where("participant_id = ? AND emitted_at > ?",
+                 event.participant_id, event.emitted_at)
+          .select(:participant_id, :emitted_at)
+          .limit(1)
+          .first.try(:emitted_at)
+      end
+
+      def self.find_slide_by_url(slides, url)
+        slide_position = 1
+
+        if url.match(/modules\/\d+$/).nil?
+          slide_position = url[/\d+$/].to_i
+        end
+
+        slides.find_by_position(slide_position)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module ThinkFeelDoEngine
+  module Reports
+    # Scenario: a Participant starts viewing a Lesson.
+    class LessonViewing
+      include LessonModule
+
+      def self.columns
+        %w( participant_id lesson_id page_headers lesson_selected_at
+            last_page_number_opened last_page_opened_at )
+      end
+
+      def self.participant_ids(ids)
+        ids.empty? ? Participant.ids : ids
+      end
+
+      def self.all(*ids)
+        lessons = lesson_entries_map
+
+        Participant.select(:id, :study_id)
+          .where(id: participant_ids(ids)).map do |participant|
+          lesson_select_events =
+            EventCapture::Event
+            .where(participant_id: participant.id, kind: "render")
+            .select(:participant_id, :emitted_at, :payload)
+            .to_a.select do |e|
+              lessons.keys.include?(e.current_url.gsub(URL_ROOT_RE, ""))
+            end
+
+          lesson_select_events.map do |e|
+            lesson_id = lessons[e.current_url.gsub(URL_ROOT_RE, "")]
+            last_page_opened = last_page_opened(e, lesson_id)
+
+            {
+              participant_id: participant.study_id,
+              lesson_id: lesson_id,
+              page_headers: e.headers,
+              lesson_selected_at: e.emitted_at.iso8601,
+              last_page_number_opened: last_page_opened[:number].to_i,
+              last_page_opened_at: last_page_opened[:opened_at].iso8601
+            }
+          end
+        end.flatten
+      end
+
+      # last event (click) with matching module id
+      def self.last_page_opened(first_session_event, lesson_id)
+        lesson_events =
+          EventCapture::Event
+          .where(participant_id: first_session_event.participant_id,
+                 kind: "render")
+          .where("emitted_at > ?", first_session_event.emitted_at)
+          .order(:emitted_at)
+          .select(:kind, :emitted_at, :payload)
+          .to_a.take_while { |e| e.current_url.include?(lesson_id.to_s) }
+        last_event = (lesson_events.last || first_session_event)
+
+        {
+          number: last_event.current_url[/\d+$/],
+          opened_at: last_event.emitted_at
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module ThinkFeelDoEngine
+  module Reports
+    # Scenario: a Participant logs into the site.
+    class Login
+      def self.columns
+        %w( participant_id occurred_at )
+      end
+
+      def self.all
+        Participant.select(:id, :study_id).map do |participant|
+          ParticipantLoginEvent
+            .where(participant_id: participant.id).map do |event|
+              {
+                participant_id: participant.study_id,
+                occurred_at: event.created_at.iso8601
+              }
+            end
+        end.flatten
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+module ThinkFeelDoEngine
+  module Reports
+    # Metadata for Coach-Participant messaging.
+    class Messaging
+      COACH = 1
+      PARTICIPANT = 2
+
+      def self.columns
+        %w( message_id study_id therapist_id sender_id sender recipient
+            start_dt treatment_week day event_date event_time
+            is_message_opened message_opened_at message_subject
+            message_content )
+      end
+
+      def self.all
+        Message.all.map do |message|
+          new(message).report
+        end
+      end
+
+      def initialize(message)
+        @message = message
+        @sender = message.sender
+        @recipient = message.recipient
+        @participant = @sender.is_a?(Participant) ? @sender : @recipient
+        @coach = @sender.is_a?(User) ? @sender : @recipient
+      end
+
+      def report
+        {
+          message_id: @message.id,
+          study_id: study_id,
+          therapist_id: coach_id,
+          sender_id: sender_type,
+          sender: sender_identifier,
+          recipient: recipient_identifier,
+          start_dt: participant_start_date,
+          treatment_week: enrollment_week,
+          day: enrollment_day,
+          event_date: date_sent,
+          event_time: time_sent.iso8601,
+          is_message_opened: is_message_read?,
+          message_opened_at: message_read_at.try(:iso8601),
+          message_subject: @message.subject,
+          message_content: @message.body
+        }
+      end
+
+      private
+
+      def study_id
+        @participant.study_id
+      end
+
+      def coach_id
+        @coach.email
+      end
+
+      def sender_type
+        @sender == @coach ? COACH : PARTICIPANT
+      end
+
+      def sender_identifier
+        @sender == @coach ? coach_id : study_id
+      end
+
+      def recipient_identifier
+        @recipient == @coach ? coach_id : study_id
+      end
+
+      def participant_start_date
+        @participant_start_date ||=
+          @participant.active_membership.try(:start_date)
+      end
+
+      def enrollment_week
+        enrollment_day && ((enrollment_day - 1).days / 1.week) + 1
+      end
+
+      def enrollment_day
+        @enrollment_day ||= (
+          participant_start_date &&
+            (time_sent.to_date - participant_start_date + 1).to_i
+        )
+      end
+
+      def date_sent
+        @message.sent_at.to_date.to_s(:db)
+      end
+
+      def time_sent
+        @message.sent_at
+      end
+
+      def is_message_read?
+        received_message.try(:is_read)
+      end
+
+      def message_read_at
+        is_message_read? && received_message.try(:updated_at)
+      end
+
+      def received_message
+        @received_message ||= @recipient.received_messages
+                              .find_by_message_id(@message.id)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module ThinkFeelDoEngine
+  module Reports
+    # Scenario: A Participant starts using a Module page.
+    class ModulePageView
+      include ToolModule
+
+      def self.columns
+        %w( participant_id tool_id module_id page_headers page_selected_at
+            page_exited_at url )
+      end
+
+      def self.all
+        modules = modules_map
+
+        Participant.select(:id, :study_id).map do |participant|
+          slide_render_events_for(participant, modules).map do |module_event|
+            e = module_event[1]
+            mod = module_event[0]
+
+            {
+              participant_id: participant.study_id,
+              tool_id: mod.bit_core_tool_id,
+              module_id: mod.id,
+              page_headers: e.headers,
+              page_selected_at: e.emitted_at.iso8601,
+              page_exited_at: page_exit_event_at(e).try(:iso8601),
+              url: e.payload["currentUrl"]
+            }
+          end
+        end.flatten
+      end
+
+      def self.slide_render_events_for(participant, modules)
+        EventCapture::Event
+          .where(participant_id: participant.id,
+                 kind: %w( render ))
+          .select(:participant_id, :emitted_at, :payload)
+          .to_a.map do |e|
+            key = modules.keys.find do |l|
+              !e.current_url.match(/#{ l }(\/.*)?$/).nil?
+            end
+
+            key ? [modules[key], e] : nil
+          end.compact
+      end
+
+      def self.page_exit_event_at(page_render_event)
+        EventCapture::Event
+          .order(:emitted_at)
+          .where("emitted_at > ? AND payload NOT LIKE ?",
+                 page_render_event.emitted_at,
+                 "%currentUrl: #{ page_render_event.current_url }\n%")
+          .select(:emitted_at).limit(1).first.try(:emitted_at)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+module ThinkFeelDoEngine
+  module Reports
+    # Scenario: A Participant starts using a Tool Module.
+    class ModuleSession
+      include ToolModule
+
+      THRESHOLD = 5.minutes
+
+      def self.columns
+        %w( participant_id module_id page_headers module_selected_at
+            last_page_opened_at did_complete )
+      end
+
+      def self.all
+        all_module_interactions
+          .group_by { |i| i[:participant_id] }
+          .map do |_participant_id, interactions|
+          # condense adjacent interactions
+          filtered_interactions = [nice_times(interactions.first.clone)].compact
+          interactions.each_with_index do |interaction, i|
+            previous_interaction = interactions[i - 1] || {}
+            next if previous_interaction[:module_id] == interaction[:module_id]
+
+            filtered_interaction = interaction.clone
+
+            (i + 1..interactions.length - 1).each do |j|
+              next_interaction = interactions[j]
+              break if next_interaction[:module_id] != interaction[:module_id]
+
+              next unless next_interaction[:last_page_opened_at] -
+                          filtered_interaction[:last_page_opened_at] < THRESHOLD
+
+              filtered_interaction[:last_page_opened_at] =
+                next_interaction[:last_page_opened_at]
+            end
+
+            filtered_interactions << nice_times(filtered_interaction)
+          end
+
+          filtered_interactions.uniq
+        end.flatten
+      end
+
+      # Returns all events that represent a viewing (render) of a Content
+      # Module.
+      def self.all_module_interactions
+        modules = modules_map.keys.each_with_object({}) do |key, h|
+          if Task.exists?(bit_core_content_module_id: modules_map[key].id,
+                          has_didactic_content: true)
+            h[key] = modules_map[key]
+          end
+        end
+
+        Participant.select(:id, :study_id).map do |participant|
+          events = time_sorted_render_events_for(participant)
+
+          events.map do |e|
+            content_module = modules[e.current_url.gsub(URL_ROOT_RE, "")]
+
+            next unless content_module
+
+            last_page_opened = last_page_opened(events, e, content_module.id)
+
+            {
+              participant_id: participant.study_id,
+              module_id: content_module.id,
+              page_headers: e.headers,
+              module_selected_at: e.emitted_at,
+              last_page_opened_at: last_page_opened[:opened_at],
+              did_complete: last_page_opened[:is_last_module_page]
+            }
+          end.compact
+        end.flatten
+      end
+
+      def self.time_sorted_render_events_for(participant)
+        EventCapture::Event
+          .where(participant_id: participant.id, kind: "render")
+          .select(:id, :participant_id, :emitted_at, :payload, :kind)
+          .to_a.sort { |a, b| a.emitted_at <=> b.emitted_at }
+      end
+
+      # last event (click) with matching module id
+      def self.last_page_opened(events, first_session_event, module_id)
+        latest_event_time = first_session_event.emitted_at
+        module_events =
+          events
+          .drop_while { |e| e.id != first_session_event.id }
+          .take_while do |e|
+            e.emitted_at - latest_event_time < THRESHOLD &&
+            e.current_url.match(/modules\/#{ module_id }(\/.*)?$/) &&
+            (latest_event_time = e.emitted_at)
+          end
+        last_event = (module_events.last || first_session_event)
+
+        {
+          opened_at: last_event.emitted_at,
+          is_last_module_page: is_last_module_page(last_event.current_url,
+                                                   module_id)
+        }
+      end
+
+      def self.nice_times(interaction)
+        interaction[:module_selected_at] =
+          interaction[:module_selected_at].iso8601
+        interaction[:last_page_opened_at] =
+          interaction[:last_page_opened_at].iso8601
+
+        interaction
+      end
+
+      def self.is_last_module_page(url, module_id)
+        # last provider within module
+        last_provider = BitCore::ContentModule.find(module_id)
+                        .content_providers
+                        .order(:position)
+                        .last
+
+        if last_provider.nil?
+          false
+        else
+          provider_re = "modules\/#{ module_id }\/" \
+                        "providers\/#{ last_provider.id }(\/.*)?$"
+
+          !url.match(/#{ provider_re }/).nil?
+        end
+      end
+    end
+  end
+end