think_feel_do_engine 3.10.6

data/app/models/planned_activity.rb

@@ -0,0 +1,5 @@
+# A planned activity is expected to take place in the future.
+class PlannedActivity < Activity
+  validates :predicted_accomplishment_intensity, :predicted_pleasure_intensity,
+            presence: true
+end

data/app/models/roles/clinician.rb

@@ -0,0 +1,4 @@
+module Roles
+  class Clinician
+  end
+end

data/app/models/roles/content_author.rb

@@ -0,0 +1,4 @@
+module Roles
+  class ContentAuthor
+  end
+end

data/app/models/roles/researcher.rb

@@ -0,0 +1,4 @@
+module Roles
+  class Researcher
+  end
+end

data/app/models/site_message.rb

@@ -0,0 +1,6 @@
+# A message sent from the site to a Participant.
+class SiteMessage < ActiveRecord::Base
+  belongs_to :participant
+
+  validates :participant, :subject, :body, presence: true
+end

data/app/models/slideshow_anchor.rb

@@ -0,0 +1,16 @@
+# Defines a relationship between a BitCore::Slideshow and a "target", which for
+# now is limited to the home screen of a Participant.
+class SlideshowAnchor < ActiveRecord::Base
+  TARGET_NAMES = %w(home_intro)
+
+  belongs_to :slideshow,
+             class_name: "BitCore::Slideshow",
+             foreign_key: :bit_core_slideshow_id
+
+  validates :slideshow, :target_name, presence: true
+  validates :target_name, inclusion: { in: TARGET_NAMES }, uniqueness: true
+
+  def self.fetch(target_name)
+    find_by_target_name(target_name.to_s).try(:slideshow)
+  end
+end

data/app/models/task.rb

@@ -0,0 +1,102 @@
+# Gives participants notifications on what needs to be completed
+class Task < ActiveRecord::Base
+  belongs_to :group
+  belongs_to :bit_core_content_module, class_name: "BitCore::ContentModule"
+  belongs_to :creator, class_name: "User"
+  has_many :memberships, through: :group
+  has_many :task_statuses, dependent: :destroy
+
+  validates :is_recurring, inclusion: { in: [true, false] }
+  validates :release_day,
+            uniqueness: {
+              scope: [:bit_core_content_module, :group],
+              message: "This task has already been assigned and set to be " \
+                       "released on this day to this group."
+            },
+            presence: true
+
+  accepts_nested_attributes_for :task_statuses
+
+  before_save :check_if_valid_release_day
+  after_create :assign_task_status_to_each_participant
+
+  scope :learning, lambda {
+    joins(:bit_core_content_module)
+      .where(
+        Arel::Table.new(:bit_core_content_modules)[:type]
+        .eq("ContentModules::LessonModule")
+      )
+  }
+
+  def title
+    try(:bit_core_content_module).try(:pretty_title) ||
+      try(:bit_core_content_module).try(:title)
+  end
+
+  def incomplete_participant_list
+    task_statuses.collect do |status|
+      if status.completed_at.nil?
+        status.participant
+      end
+    end
+  end
+
+  def complete_participant_list
+    task_statuses.collect do |status|
+      unless status.completed_at.nil?
+        status.participant
+      end
+    end
+  end
+
+  # Returns a count of the number of times this task was assigned.
+  def total_assigned
+    task_statuses.count
+  end
+
+  # Returns the count of the number of times this task was completed.
+  def total_read
+    task_statuses.where.not(completed_at: nil).count
+  end
+
+  private
+
+  def check_if_valid_release_day
+    if group.active_memberships.continuing.any? do |m|
+         release_day > m.length_of_study
+       end
+      errors.add :base, "Release day comes after some members are finished"
+
+      false
+    else
+      true
+    end
+  end
+
+  def assign_task_status_to_each_participant
+    group.memberships.each do |membership|
+      create_recurring_task_statuses(membership)
+    end
+  end
+
+  def create_recurring_task_statuses(membership)
+    if is_recurring
+      i = release_day
+      end_day = termination_day ? termination_day : membership.length_of_study
+      while i <= end_day
+        create_task(membership.id, i)
+        i += 1
+      end
+    else
+      create_task(membership.id)
+    end
+  end
+
+  def create_task(membership_id, day = nil)
+    day ||= release_day
+    TaskStatus.create!(
+      membership_id: membership_id,
+      start_day: day,
+      task_id: id)
+  end
+end

data/app/models/task_status.rb

@@ -0,0 +1,94 @@
+# Holds the completion status of a task for each participant
+class TaskStatus < ActiveRecord::Base
+  belongs_to :membership
+  belongs_to :task
+  has_one :participant, through: :membership
+  has_many :engagements, dependent: :destroy
+
+  delegate :bit_core_content_module,
+           :bit_core_content_module_id,
+           :release_day,
+           :title,
+           to: :task
+  delegate :participant_id, to: :membership, prefix: false
+
+  scope :for_content_module, lambda { |content_module|
+    joins(:task)
+      .where(tasks: { bit_core_content_module_id: content_module.id })
+  }
+
+  scope :for_content_module_ids, lambda { |ids|
+    joins(:task)
+      .where(tasks: { bit_core_content_module_id: ids })
+  }
+
+  # To Do: should this be renamed or removed?
+  # Is this being used anymore?
+  scope :available_for_learning, lambda { |membership|
+    joins(:task, task: :bit_core_content_module)
+      .by_position
+      .where(
+        arel_table[:start_day]
+        .lteq(membership.day_in_study)
+      )
+  }
+
+  scope :completed, -> { where(arel_table[:completed_at].not_eq(nil)) }
+
+  scope :incomplete, -> { where(arel_table[:completed_at].eq(nil)) }
+
+  scope :by_position, lambda {
+    joins(:task, task: :bit_core_content_module)
+      .order("bit_core_content_modules.position ASC")
+  }
+
+  scope :available_by_day, lambda { |day_in_study|
+    where(arel_table[:start_day].lteq(day_in_study))
+  }
+
+  scope :incomplete_by_day, lambda { |day_in_study|
+    where(arel_table[:start_day].lteq(day_in_study))
+      .incomplete
+  }
+
+  scope :incomplete_on_day, lambda { |day_in_study|
+    where(arel_table[:start_day].eq(day_in_study))
+      .incomplete
+  }
+
+  scope :not_terminated_by_day, lambda { |day_in_study|
+    tasks = Arel::Table.new(:tasks)
+    joins(:task)
+      .where(
+        tasks[:termination_day].eq(nil)
+        .or(
+          tasks[:termination_day].gteq(day_in_study)
+        )
+      )
+  }
+
+  def provider_viz?
+    try(:bit_core_content_module).try(:is_viz)
+  end
+
+  def mark_complete
+    if completed_at
+      save!
+    else
+      update_attributes(completed_at: DateTime.current)
+    end
+  end
+
+  def is_lesson?
+    task.bit_core_content_module.type == "ContentModules::LessonModule"
+  end
+
+  def notify_today?
+    today = Time.now
+    start_day == ((today.to_date - membership.start_date.to_date).to_i + 1)
+  end
+
+  def available_for_learning_on
+    membership.start_date + release_day - 1
+  end
+end

data/app/models/think_feel_do_engine/addressable.rb

@@ -0,0 +1,28 @@
+module ThinkFeelDoEngine
+  # Labels the sender and recipient of a message.
+  module Addressable
+    def from(user = nil)
+      if sender.id == user.try(:id)
+        "You"
+      elsif sender.try(:study_id)
+        sender.study_id
+      elsif recipient.try(:active_group).try(:arm).try(:has_woz?)
+        "Moderator"
+      else
+        "Coach"
+      end
+    end
+
+    def to(user = nil)
+      if recipient.id == user.try(:id)
+        "You"
+      elsif recipient.try(:study_id)
+        recipient.study_id
+      elsif sender.try(:active_group).try(:arm).try(:has_woz?)
+        "Moderator"
+      else
+        "Coach"
+      end
+    end
+  end
+end

data/app/models/think_feel_do_engine/concerns/validate_password.rb

@@ -0,0 +1,65 @@
+require "strong_password"
+
+module ThinkFeelDoEngine
+  module Concerns
+    # validates passwords.
+    module ValidatePassword
+      WEAK_PASSWORD_MESSAGE = "is too weak"
+      extend ActiveSupport::Concern
+
+      included do
+        before_validation :contains_integer,
+                          :contains_lowercase_letter,
+                          :contains_uppercase_letter,
+                          :repeating_characters,
+                          on: [:create, :update],
+                          if: :password_exists_without_message?
+
+        validates :password,
+                  password_strength: {
+                    extra_dictionary_words: :extra_words,
+                    use_dictionary: true,
+                    min_entropy: ThinkFeelDoEngine::
+                        PasswordValidator::VALID_ENTROPY,
+                    message: WEAK_PASSWORD_MESSAGE
+                  },
+                  if: :password_exists_without_message?
+      end
+
+      private
+
+      def contains_integer
+        set_error_on_password unless password =~ /[0-9]/
+      end
+
+      def contains_lowercase_letter
+        set_error_on_password unless password =~ /[a-z]/
+      end
+
+      def contains_uppercase_letter
+        set_error_on_password unless password =~ /[A-Z]/
+      end
+
+      def email_prefix
+        @email_prefix ||= email[/[^@]+/]
+      end
+
+      def extra_words
+        [email_prefix, email_prefix.reverse] if email.present?
+      end
+
+      def password_exists_without_message?
+        password.present? &&
+          !errors.full_messages.include?("Password #{WEAK_PASSWORD_MESSAGE}")
+      end
+
+      def repeating_characters
+        set_error_on_password if password =~ /(.)\1\1/
+      end
+
+      def set_error_on_password
+        errors.add(:password, WEAK_PASSWORD_MESSAGE)
+      end
+    end
+  end
+end

data/app/models/think_feel_do_engine/password_validator.rb

@@ -0,0 +1,55 @@
+module ThinkFeelDoEngine
+  # Users Participant and User password validations
+  class PasswordValidator
+    WEAK_PASSWORD_MESSAGE = "is too weak"
+    VALID_ENTROPY = 10
+
+    attr_reader :password,
+                :password_token,
+                :person,
+                :token
+
+    def initialize(password:, password_token:)
+      @password = password
+      @password_token = password_token
+      find_or_intialize_person
+    end
+
+    def entropy_value
+      valid_entropy? ? calculate_entroy : 0
+    end
+
+    private
+
+    def calculate_entroy
+      StrongPassword::StrengthChecker
+        .new(password)
+        .calculate_entropy(use_dictionary: true)
+    end
+
+    def find_or_intialize_person
+      @person ||= Participant.find_by_reset_password_token(token) ||
+                  User.find_by_reset_password_token(token) ||
+                  Participant.new
+    end
+
+    def set_password
+      person.password = password
+      person.password_confirmation = password
+    end
+
+    def token
+      @token ||= Devise.token_generator.digest(
+        Devise, :reset_password_token,
+        password_token)
+    end
+
+    def valid_entropy?
+      set_password
+      !person
+        .tap(&:valid?)
+        .errors[:password]
+        .include?(WEAK_PASSWORD_MESSAGE)
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module ThinkFeelDoEngine
+  module Reports
+    # Collect metadata for all Participant Emotional Ratings.
+    class EmotionalRating
+      def self.columns
+        %w( participant_id name rating created_at )
+      end
+
+      def self.all
+        Participant.select(:id, :study_id).map do |participant|
+          participant.emotional_ratings.map do |emotional_rating|
+            {
+              participant_id: participant.study_id,
+              name: emotional_rating.name,
+              rating: emotional_rating.rating,
+              created_at: emotional_rating.created_at.iso8601
+            }
+          end
+        end.flatten
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module ThinkFeelDoEngine
+  module Reports
+    # Scenario: a Participant clicks, causes a page to render,
+    # starts/pauses/finishes a video, etc.
+    class Event
+      def self.columns
+        %w( participant_id emitted_at current_url headers kind )
+      end
+
+      def self.all
+        Participant.select(:id, :study_id).map do |participant|
+          EventCapture::Event.where(participant_id: participant.id)
+            .map do |event|
+            {
+              participant_id: participant.study_id,
+              emitted_at: event.emitted_at.iso8601,
+              current_url: event.current_url,
+              headers: event.headers,
+              kind: event.kind
+            }
+          end
+        end.flatten
+      end
+    end
+  end
+end