think_feel_do_engine 3.10.6

data/app/helpers/think_feel_do_engine/tasks_helper.rb

@@ -0,0 +1,110 @@
+module ThinkFeelDoEngine
+  # Used to display asterisks if tasks and tools have been assigned to a group
+  # and to hide unassigned links
+  module TasksHelper
+    def task_status(membership, content_module)
+      membership.available_task_statuses
+        .for_content_module(content_module)
+        .order(start_day: :asc)
+        .last
+    end
+
+    def task_status_viz(task_status)
+      task_status.title
+    end
+
+    def task_status_link(available_module:, icon:, membership:)
+      available_module = TaskStatusLink.new(
+        available_module: available_module,
+        icon: icon,
+        membership: membership)
+      link_to available_module.name,
+              think_feel_do_engine.navigator_location_path(
+                module_id: available_module.id
+              ), class: available_module.css_class,
+                 data: available_module.data_attributes,
+                 id: available_module.css_id
+    end
+
+    def unread_task?(task_status)
+      !task_status.completed_at?
+    end
+
+    def todays_lesson(task_status, response)
+      membership = current_participant.membership
+      response.html_safe if task_status.release_day == membership.day_in_study
+    end
+
+    def current_provider_skippable?(navigator)
+      provider = navigator.current_content_provider
+      mod = navigator.current_module
+      membership = current_participant.active_membership
+
+      # If the TaskStatus was *just* marked complete, this is the first time
+      # viewing the ContentProvider, so we should consider it incomplete.
+      ContentProviderDecorator.fetch(provider)
+        .is_skippable_after_first_viewing &&
+        task_status(membership, mod).completed_at < Time.current - 5.minutes
+    end
+
+    def create_task_path(task_status)
+      think_feel_do_engine.navigator_location_path(
+        module_id: task_status
+                   .bit_core_content_module_id,
+        provider_id: task_status
+                     .bit_core_content_module
+                     .content_providers
+                     .find_by_position(1)
+                     .id,
+        content_position: 1
+      )
+    end
+  end
+
+  # Helper class to build task status link
+  class TaskStatusLink
+    attr_reader :available_module, :icon, :membership
+
+    def initialize(available_module:, icon:, membership:)
+      @available_module = available_module
+      @icon = icon
+      @membership = membership
+    end
+
+    def css_class
+      "task-status list-group-item list-group-item-#{completion_status}"
+    end
+
+    def css_id
+      "task-status-#{ available_module.task_status_id }"
+    end
+
+    def data_attributes
+      {
+        task_status_id: available_module.task_status_id
+      }
+    end
+
+    def id
+      available_module.id
+    end
+
+    def name
+      icon.html_safe + " " +  available_module.title
+    end
+
+    private
+
+    def completed?
+      membership.available_task_statuses
+        .for_content_module(available_module)
+        .order(start_day: :asc)
+        .last
+        .completed_at
+    end
+
+    def completion_status
+      completed? ? "read" : "unread"
+    end
+  end
+end

data/app/mailers/think_feel_do_engine/lesson_notification_mailer.rb

@@ -0,0 +1,15 @@
+module ThinkFeelDoEngine
+  # Sends a new lesson notification to a given participant.
+  class LessonNotificationMailer < ActionMailer::Base
+    default(
+      from: Rails.configuration.action_mailer.default_options[:from])
+
+    def lesson_notification_email(
+      application_name:, lesson_module:, participant_email:)
+      @application_name = application_name
+      @lesson = lesson_module
+      mail(to: participant_email,
+           subject: "New Lesson Available")
+    end
+  end
+end

data/app/mailers/think_feel_do_engine/message_notifications.rb

@@ -0,0 +1,21 @@
+module ThinkFeelDoEngine
+  # Mailer for notifying of new application messages.
+  class MessageNotifications < ActionMailer::Base
+    def new_for_coach(coach, group)
+      @group = group
+      mail to:      coach.email,
+           subject: "New message"
+    end
+
+    def new_for_participant(participant)
+      @context_name = participant
+                      .current_group
+                      .arm
+                      .bit_core_tools
+                      .find_by_type("Tools::Messages")
+                      .title
+      mail to:      participant.email,
+           subject: "New message"
+    end
+  end
+end

data/app/mailers/think_feel_do_engine/site_message_mailer.rb

@@ -0,0 +1,11 @@
+module ThinkFeelDoEngine
+  # Mailer for SiteMessage delivery.
+  class SiteMessageMailer < ActionMailer::Base
+    def general(message)
+      @body = message.body
+
+      mail to: message.participant.email,
+           subject: message.subject
+    end
+  end
+end

data/app/models/ability.rb

@@ -0,0 +1,91 @@
+# Uses CanCan to assign granular authorizations.
+class Ability
+  include CanCan::Ability
+
+  def initialize(user)
+    # Guest user by default
+    @user = user || User.new
+
+    if @user.admin?
+      authorize_admin
+    else
+      authorize_coach if @user.coach?
+      authorize_content_author if @user.content_author?
+      authorize_researcher if @user.researcher?
+    end
+  end
+
+  private
+
+  def authorize_admin
+    can :manage, :all
+  end
+
+  def authorize_coach
+    can :index, Arm
+    can :show, Arm do |arm|
+      # TODO: make a nicer scope/sql call
+      access = false
+      arm.groups.each do |group|
+        unless access
+          access = !(group.participant_ids & @user.participant_ids).empty?
+        end
+      end
+      access
+    end
+    can [:show, :moderate], Group do |group|
+      !(@user.participant_ids & group.participant_ids).empty?
+    end
+    can :show, Participant do |participant|
+      @user.participant_ids.include?(participant.id)
+    end
+    authorize_coach_messaging
+    can [:withdraw, :discontinue, :update], Membership do |membership|
+      coach_has_participant? @user.id, membership.participant_id
+    end
+    can :manage, PhqAssessment do |assessment|
+      coach_has_participant? @user.id, assessment.participant_id
+    end
+  end
+
+  def authorize_coach_messaging
+    can [:create, :index], Message
+    can :show, Message do |message|
+      (message.try(:sender) == @user) || (message.try(:recipient) == @user)
+    end
+    can(:show, DeliveredMessage) do |message|
+      message.try(:recipient) == @user
+    end
+    can [:new, :index], SiteMessage
+    can [:create, :show], SiteMessage do |message|
+      coach_has_participant? @user.id, message.participant_id
+    end
+  end
+
+  def coach_has_participant?(coach_id, participant_id)
+    CoachAssignment.exists?(
+      coach_id: coach_id,
+      participant_id: participant_id
+    )
+  end
+
+  # think_feel_do_engine
+  def authorize_content_author
+    can :read, Arm
+    can :update, Group
+    can :manage, BitCore::ContentModule
+    can :manage, BitCore::ContentProvider
+    can :manage, BitCore::Slideshow
+    can :manage, BitCore::Slide
+  end
+
+  # think_feel_do_dashboard
+  def authorize_researcher
+    can [:show, :index], Arm
+    [Group, CoachAssignment, Membership, Participant, Task, User]
+      .each do |klass|
+      can :manage, klass
+    end
+    can :read, "Reports"
+  end
+end

data/app/models/activity.rb

@@ -0,0 +1,362 @@
+# Represents a real-world activity of a participant.
+class Activity < ActiveRecord::Base
+  attr_accessor :activity_type_title,
+                :activity_type_new_title,
+                :in_review
+
+  PLEASURABLE_CUTOFF = 6
+  ACCOMPLISHED_CUTOFF = 6
+
+  belongs_to :activity_type
+  belongs_to :participant
+
+  validates :activity_type, :participant, presence: true
+
+  validate :actual_ratings!, on: :update, if: proc { |f| f.in_review }
+
+  delegate :title, to: :activity_type, prefix: false, allow_nil: true
+
+  before_validation :create_activity_type, :set_end_time
+  validate :actual_accomplishable_updates, on: :update
+  validate :predicted_intensities, :actual_intensities
+
+  scope :for_day, lambda { |time|
+    where(
+      arel_table[:start_time]
+      .gteq(time.beginning_of_day)
+      .and(arel_table[:start_time].lteq(time.end_of_day))
+    )
+  }
+
+  scope :accomplished, lambda {
+    where(
+      arel_table[:actual_accomplishment_intensity]
+      .gteq(ACCOMPLISHED_CUTOFF)
+    )
+  }
+
+  scope :pleasurable, lambda {
+    where(
+      arel_table[:actual_pleasure_intensity]
+      .gteq(PLEASURABLE_CUTOFF)
+    )
+  }
+
+  scope :in_the_past, lambda {
+    where(
+      arel_table[:end_time]
+      .lt(Time.current)
+    )
+  }
+
+  scope :last_seven_days, lambda {
+    where(
+      arel_table[:updated_at]
+      .gteq(Time.current.advance(days: -7).beginning_of_day)
+    )
+  }
+
+  scope :updated_for_day, lambda { |time|
+    where(
+      arel_table[:updated_at]
+        .gteq(time.beginning_of_day)
+        .and(arel_table[:updated_at].lteq(time.end_of_day))
+    )
+  }
+
+  scope :created_last_seven_days, lambda {
+    where(
+      arel_table[:created_at]
+        .gteq(Time.current.advance(days: -7).beginning_of_day)
+    )
+  }
+
+  scope :created_for_day, lambda { |time|
+    where(
+      arel_table[:created_at]
+        .gteq(time.beginning_of_day)
+        .and(arel_table[:created_at].lteq(time.end_of_day))
+    )
+  }
+
+  # To Do: fix naming and/or what is going on here
+  # change to start_time and is_scheduled
+  # and updated tests
+  scope :unscheduled_or_in_the_future, lambda {
+    where(
+      arel_table[:start_time].eq(nil)
+      .or(arel_table[:end_time].gt(Time.current))
+    )
+  }
+
+  scope :reviewed_and_complete, lambda {
+    where(is_reviewed: true)
+      .where
+      .not(
+        predicted_accomplishment_intensity: nil,
+        predicted_pleasure_intensity: nil,
+        actual_accomplishment_intensity: nil,
+        actual_pleasure_intensity: nil)
+  }
+
+  scope :reviewed_and_incomplete, lambda {
+    where(is_reviewed: true)
+      .where(
+        actual_accomplishment_intensity: nil,
+        actual_pleasure_intensity: nil)
+      .where
+      .not(
+        predicted_accomplishment_intensity: nil,
+        predicted_pleasure_intensity: nil)
+  }
+
+  scope :monitored, lambda {
+    where(is_reviewed: false)
+      .where
+      .not(
+        actual_accomplishment_intensity: nil,
+        actual_pleasure_intensity: nil)
+      .where(
+        predicted_accomplishment_intensity: nil,
+        predicted_pleasure_intensity: nil)
+  }
+
+  # To Do: fix naming and/or what is going on here
+  # change to start_time
+  # and updated tests
+  scope :in_the_future, lambda {
+    where(
+      arel_table[:end_time].gt(Time.current)
+    )
+  }
+
+  scope :planned, lambda {
+    where(
+      is_reviewed: false,
+      actual_accomplishment_intensity: nil,
+      actual_pleasure_intensity: nil)
+      .where
+      .not(
+        predicted_accomplishment_intensity: nil,
+        predicted_pleasure_intensity: nil)
+  }
+
+  scope :random, lambda {
+    order("RANDOM()")
+  }
+
+  scope :were_planned, lambda {
+    where
+      .not(
+        predicted_accomplishment_intensity: nil,
+        predicted_pleasure_intensity: nil)
+  }
+
+  scope :with_actual_ratings, lambda {
+    where
+      .not(
+        actual_accomplishment_intensity: nil,
+        actual_pleasure_intensity: nil)
+  }
+
+  scope :unplanned, lambda {
+    where(start_time: nil, end_time: nil)
+  }
+
+  scope :during, lambda { |start_time, end_time|
+    where(
+      arel_table[:start_time].gteq(start_time)
+      .and(arel_table[:end_time].lteq(end_time))
+    )
+  }
+
+  # Extend with virtual attributes.
+  def self.attribute_names
+    super + %w(activity_type_title activity_type_new_title)
+  end
+
+  def shared_description
+    "Activity: #{activity_type.title}"
+  end
+
+  def update_as_reviewed(params = {})
+    update(
+      params
+      .merge(in_review: true, is_reviewed: true))
+  end
+
+  def actual_ratings!
+    validate_actual_intensities!("accomplishment")
+    validate_actual_intensities!("pleasure")
+  end
+
+  def actual_editable?
+    if end_time && !reviewed_and_incomplete?
+      end_time < Time.zone.now
+    else
+      false
+    end
+  end
+
+  def status_label
+    if monitored?
+      "Monitored"
+    elsif planned?
+      "Planned"
+    elsif reviewed_and_complete?
+      "Reviewed & Completed"
+    elsif reviewed_and_incomplete?
+      "Reviewed and did not complete"
+    else
+      "N/A"
+    end
+  end
+
+  def monitored?
+    not_reviewed? &&
+      neither_intensity_is_rated?(:predicted) &&
+      both_intensities_rated?(:actual)
+  end
+
+  def planned?
+    not_reviewed? &&
+      neither_intensity_is_rated?(:actual) &&
+      both_intensities_rated?(:predicted)
+  end
+
+  def reviewed_and_complete?
+    reviewed? &&
+      both_intensities_rated?(:predicted) &&
+      both_intensities_rated?(:actual)
+  end
+
+  def reviewed_and_incomplete?
+    reviewed? &&
+      neither_intensity_is_rated?(:actual) &&
+      both_intensities_rated?(:predicted)
+  end
+
+  def was_recently_created?
+    (Time.current - created_at) < 1.minute
+  end
+
+  def actual_pleasure_value
+    Values::Pleasure.from_intensity(actual_pleasure_intensity)
+  end
+
+  def actual_accomplishment_value
+    Values::Accomplishment.from_intensity(actual_accomplishment_intensity)
+  end
+
+  def predicted_accomplishment_value
+    Values::Accomplishment.from_intensity(predicted_accomplishment_intensity)
+  end
+
+  def predicted_pleasure_value
+    Values::Pleasure.from_intensity(predicted_pleasure_intensity)
+  end
+
+  def rated?
+    actual_pleasure_intensity || actual_accomplishment_intensity
+  end
+
+  def intensity_difference(attribute)
+    actual_intensity = send("actual_#{attribute}_intensity")
+    predicted_intensity = send("predicted_#{attribute}_intensity")
+    if actual_intensity && predicted_intensity
+      (actual_intensity - predicted_intensity).abs
+    else
+      "N/A"
+    end
+  end
+
+  def self.completion_score
+    if reviewed_and_complete.count > 0
+      (reviewed_and_complete.count * 100 / count).round
+    else
+      0
+    end
+  end
+
+  private
+
+  def both_intensities_rated?(type)
+    accomplishment = send("#{type}_accomplishment_intensity")
+    pleasure = send("#{type}_pleasure_intensity")
+    !accomplishment.nil? && !pleasure.nil?
+  end
+
+  def either_intensity_is_rated?(type)
+    accomplishment = send("#{type}_accomplishment_intensity")
+    pleasure = send("#{type}_pleasure_intensity")
+    !accomplishment.nil? || !pleasure.nil?
+  end
+
+  def neither_intensity_is_rated?(type)
+    !either_intensity_is_rated?(type)
+  end
+
+  def reviewed?
+    is_reviewed?
+  end
+
+  def not_reviewed?
+    !reviewed?
+  end
+
+  def actual_accomplishable_updates
+    actual_accomplishable_update("actual_accomplishment_intensity")
+    actual_accomplishable_update("actual_pleasure_intensity")
+  end
+
+  def actual_accomplishable_update(accomplishable_attr)
+    if end_time > Time.zone.now &&
+       changed.include?(accomplishable_attr)
+      errors.add accomplishable_attr.to_sym, "can't be updated "\
+        "because activity is not in the past."
+    end
+  end
+
+  def actual_intensities
+    if (actual_accomplishment_intensity &&
+        actual_pleasure_intensity.nil?) ||
+       (actual_pleasure_intensity &&
+        actual_accomplishment_intensity.nil?)
+      errors.add :base, "When rating actual intensities, you must "\
+                        "rate both pleasure and accomplishment."
+    end
+  end
+
+  def predicted_intensities
+    if (predicted_accomplishment_intensity &&
+        predicted_pleasure_intensity.nil?) ||
+       (predicted_pleasure_intensity &&
+        predicted_accomplishment_intensity.nil?)
+      errors.add :base, "When predicting, you must predict "\
+                        "both pleasure and accomplishment."
+    end
+  end
+
+  def validate_actual_intensities!(attribute)
+    attribute_sym = "actual_#{attribute}_intensity".to_sym
+    errors.add attribute_sym, "can't be blank." if send(attribute_sym).nil?
+  end
+
+  def create_activity_type
+    new_title = activity_type_new_title.present? ? activity_type_new_title :
+      activity_type_title
+    if new_title
+      activity_types = participant.activity_types
+
+      if activity_types.create(title: new_title)
+        self.activity_type = activity_types.find_by_title(new_title)
+      end
+    end
+  end
+
+  def set_end_time
+    unless start_time.nil?
+      self.end_time = start_time + 1.hour
+    end
+  end
+end