think_feel_do_engine 3.10.6

data/app/models/message.rb

@@ -0,0 +1,58 @@
+# A message sent from a Participant or User to a Participant or User.
+class Message < ActiveRecord::Base
+  include ThinkFeelDoEngine::Addressable
+
+  belongs_to :sender, polymorphic: true
+  belongs_to :recipient, polymorphic: true
+  has_many :delivered_messages, dependent: :destroy
+
+  validates :subject, :sender, :recipient, presence: true
+  validate :participant_is_messageable,
+           if: proc { |message| message.recipient.try(:notify_by_email?) }
+
+  before_create :populate_sent_at
+  after_create :create_delivered_messages
+
+  delegate :email, :study_id, to: :recipient, prefix: true, allow_nil: true
+
+  def render_body
+    rendered = ""
+
+    unless body.nil?
+      markdown = Redcarpet::Markdown.new(
+        Redcarpet::Render::HTML,
+        space_after_headers: true
+      )
+
+      rendered += markdown.render(body)
+    end
+
+    rendered.html_safe
+  end
+
+  private
+
+  def create_delivered_messages
+    recipient.received_messages.create(message_id: id)
+  end
+
+  def messaging_tool
+    recipient
+      .current_group
+      .arm
+      .bit_core_tools
+      .find_by_type("Tools::Messages")
+  end
+
+  def participant_is_messageable
+    unless messaging_tool
+      errors
+        .add :base, "We're sorry, but this participant does"\
+                    " not have access to the messaging tool."
+    end
+  end
+
+  def populate_sent_at
+    self.sent_at = Time.new
+  end
+end

data/app/models/message_sms_notification.rb

@@ -0,0 +1,45 @@
+# SMS notification service for Messages and Notifications sent to Participants.
+class MessageSmsNotification
+  attr_reader :body, :phone_number
+
+  def initialize(body:, phone_number:)
+    @body = body
+    @phone_number = phone_number
+  end
+
+  def deliver
+    if environment.staging? || environment.production?
+      sms_client.account.messages.create message
+    else
+      message
+    end
+  end
+
+  private
+
+  def config
+    Rails.application.config
+  end
+
+  def environment
+    Rails.env
+  end
+
+  def from_telephone_number
+    config.try(:twilio_account_telephone_number)
+  end
+
+  def message
+    {
+      to: "+1#{ phone_number }",
+      from: from_telephone_number,
+      body: body
+    }
+  end
+
+  def sms_client
+    @sms_client ||= Twilio::REST::Client.new(
+      config.twilio_account_sid,
+      config.twilio_auth_token)
+  end
+end

data/app/models/mood.rb

@@ -0,0 +1,31 @@
+# Participants rate their mood
+class Mood < ActiveRecord::Base
+  belongs_to :participant
+  validates :participant, presence: true
+  validates :rating, presence: true, inclusion: { in: 0..10 }
+
+  scope :for_day, lambda { |datetime|
+    where(
+      arel_table[:created_at].gteq(datetime.beginning_of_day)
+      .and(arel_table[:created_at].lteq(datetime.end_of_day))
+    )
+  }
+
+  def rating_value
+    Values::Mood.from_rating(rating).to_s
+  end
+
+  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))
+    )
+  }
+end

data/app/models/participant.rb

@@ -0,0 +1,355 @@
+require "devise"
+
+# A person enrolled in the intervention.
+class Participant < ActiveRecord::Base
+  include ThinkFeelDoEngine::Concerns::ValidatePassword
+
+  devise :database_authenticatable,
+         :recoverable, :trackable, :validatable, :timeoutable,
+         timeout_in: 20.minutes
+
+  has_many :memberships, dependent: :destroy
+  has_one :active_membership,
+          -> { active },
+          class_name: "Membership",
+          foreign_key: :participant_id,
+          dependent: :destroy,
+          inverse_of: :active_participant
+  has_many :groups, through: :memberships
+  has_one :active_group, through: :active_membership
+  has_many :activities,
+           -> { includes :activity_type },
+           dependent: :destroy
+  has_many :planned_activities,
+           -> { includes :activity_type }
+  has_many :awake_periods, dependent: :destroy
+  has_many :activity_types, dependent: :destroy
+  has_many :emotions, dependent: :destroy, foreign_key: :creator_id
+  has_many :emotional_ratings,
+           -> { includes :emotion },
+           dependent: :destroy
+  has_many :moods, dependent: :destroy
+  has_many :thoughts,
+           -> { includes :pattern },
+           dependent: :destroy
+  has_many :sent_messages, class_name: "Message", as: :sender
+  has_many :messages, as: :sender, dependent: :destroy
+  has_many :received_messages,
+           -> { includes message: :sender },
+           class_name: "DeliveredMessage",
+           as: :recipient,
+           dependent: :destroy
+  has_many :addressed_messages,
+           class_name: "Message",
+           as: :recipient,
+           dependent: :destroy
+  has_many :phq_assessments, dependent: :destroy
+  has_many :wai_assessments, dependent: :destroy
+  has_many :participant_tokens, dependent: :destroy
+  has_one :participant_status,
+          class_name: "BitPlayer::ParticipantStatus",
+          dependent: :destroy
+  has_one :coach_assignment, dependent: :destroy
+  has_one :coach, class_name: "User", through: :coach_assignment
+  has_many :participant_login_events, dependent: :destroy
+  has_many :media_access_events, dependent: :destroy
+  has_many :events,
+           class_name: "EventCapture::Event",
+           foreign_key: :participant_id,
+           dependent: :destroy
+  has_many :click_events,
+           -> { where(kind: "click") },
+           class_name: "EventCapture::Event",
+           foreign_key: :participant_id
+
+  delegate :end_date, to: :active_membership, prefix: true, allow_nil: true
+
+  accepts_nested_attributes_for :coach_assignment
+
+  def self.active
+    joins(:memberships).merge(Membership.active)
+  end
+
+  def self.inactive
+    joins(:memberships).merge(Membership.inactive)
+  end
+
+  scope :stepped, lambda {
+    joins(:memberships)
+      .where(
+        Arel::Table.new(:memberships)[:stepped_on]
+        .not_eq(nil)
+      )
+  }
+
+  scope :not_stepped, lambda {
+    joins(:memberships)
+      .where(
+        Arel::Table.new(:memberships)[:stepped_on]
+        .eq(nil)
+      )
+  }
+
+  def is_not_allowed_in_site
+    # participant not set to is_complete (hence withdrawal or termination)
+    # and who have no active memberships
+    active_membership.nil? && !memberships.where(is_complete: true).exists?
+  end
+
+  def active_group_is_social?
+    active_group && active_group.arm.social?
+  end
+
+  def duration_of_last_session
+    latest_action_at - current_sign_in_at
+  end
+
+  def latest_action_at
+    events
+      .order(recorded_at: :desc)
+      .first
+      .try(:recorded_at)
+  end
+
+  def populate_emotions
+    emotions_array = [
+      "Anxious",
+      "Enthusiastic",
+      "Grateful",
+      "Happy",
+      "Irritable",
+      "Upset",
+      "Sad",
+      "Guilty",
+      "Calm",
+      "Concentrated",
+      "Relaxed"
+    ]
+    emotions_array.each do |e|
+      emotions.find_or_create_by(name: e)
+    end
+
+    emotions
+  end
+
+  def unfinished_awake_periods
+    join_sql = <<-SQL
+      LEFT JOIN activities
+        ON activities.participant_id = awake_periods.participant_id
+        AND activities.start_time = awake_periods.start_time
+    SQL
+
+    awake_periods.joins(join_sql).where("activities.start_time IS NULL")
+  end
+
+  def most_recent_unfinished_awake_period
+    unfinished_awake_periods.order("awake_periods.start_time DESC").first
+  end
+
+  def build_data_record(association, attributes)
+    send(association).build(attributes)
+  end
+
+  def build_phq_assessment(attributes)
+    phq_assessments.build(attributes)
+  end
+
+  def current_group
+    active_membership.group
+  end
+
+  def fetch_data_record(association, id)
+    send(association).find(id)
+  end
+
+  def count_unread_messages
+    received_messages.where(is_read: false).count
+  end
+
+  def count_all_incomplete(tool)
+    @count_all_incomplete ||= {}
+
+    @count_all_incomplete[tool.id] ||= (
+      if tool.is_a?(Tools::Messages)
+        count_unread_messages
+      else
+        content_module_ids = tool.content_modules.where(is_viz: false)
+
+        if content_module_ids
+          active_membership.incomplete_tasks
+            .for_content_module_ids(content_module_ids)
+            .count
+        else
+          false
+        end
+      end
+    )
+  end
+
+  def learning_tasks(content_modules)
+    active_membership.task_statuses
+      .for_content_module_ids(content_modules.map(&:id))
+  end
+
+  def stepping_suggestion
+    data = phq_assessments.map do |x|
+      [x.release_date, x] if x.number_answered > 0
+    end
+    assessment_data = Hash[data]
+
+    PhqStepping.new(assessment_data,
+                    active_membership.start_date)
+  end
+
+  def navigation_status
+    participant_status || build_participant_status
+  end
+
+  def recent_accomplished_activities
+    recent_activities.accomplished
+  end
+
+  def recent_activities
+    activities.during(recent_period[:start_time], recent_period[:end_time])
+  end
+
+  def recent_pleasurable_activities
+    recent_activities.pleasurable
+  end
+
+  def flag_inactivity
+    participant_login_events
+      .order(:created_at)
+      .last
+      .try(:update_attribute, :inactive_log_out, true)
+  end
+
+  # Checks whether the user session has expired based on configured time.
+  # Overridden devise method.
+  def timedout?(last_access)
+    timedout = super
+    flag_inactivity if timedout
+
+    timedout
+  end
+
+  def unplanned_activities
+    UnplannedActivities.new(self)
+  end
+
+  def contact_status_enum
+    %w(sms email)
+  end
+
+  def notify_by_email?
+    "email" == contact_preference
+  end
+
+  def notify_by_sms?
+    "sms" == contact_preference || "phone" == contact_preference
+  end
+
+  def average_rating(array)
+    array.reduce(0) { |a, e| a.to_f + e[0] } / array.size
+  end
+
+  def positive_emotions(emotion_array)
+    emotions = emotion_array.collect do |emotion|
+      if emotion.is_positive
+        [emotion.rating, emotion.created_at, emotion.name]
+      end
+    end
+    emotions.compact
+  end
+
+  def negative_emotions(emotion_array)
+    emotions = emotion_array.collect do |emotion|
+      unless emotion.is_positive
+        [emotion.rating, emotion.created_at, emotion.name]
+      end
+    end
+    emotions.compact
+  end
+
+  def most_recent_membership
+    memberships.order(end_date: :desc).first
+  end
+
+  def emotional_rating_daily_averages
+    averaged_ratings = []
+
+    daily_ratings = emotional_ratings.group_by { |er| er.created_at.to_date }
+    # rubocop:disable all
+    daily_ratings.each do |day, emotion_array|
+    # rubocop:enable all
+      positive_ratings = positive_emotions(emotion_array)
+      if positive_ratings.size > 0
+        daily_positive = { day: day,
+                           intensity: average_rating(positive_ratings),
+                           is_positive: true,
+                           drill_down: positive_ratings,
+                           data_type: "Emotion"
+                         }
+        averaged_ratings << daily_positive
+      end
+      negative_ratings = negative_emotions(emotion_array)
+      if negative_ratings.size > 0
+        daily_negative = {  day: day,
+                            intensity: average_rating(negative_ratings),
+                            is_positive: false,
+                            drill_down: negative_ratings,
+                            data_type: "Emotion"
+                         }
+        averaged_ratings << daily_negative
+      end
+    end
+    averaged_ratings
+  end
+
+  def in_study?
+    if active_membership.start_date <= Date.today &&
+       active_membership.end_date >= Date.today
+      true
+    else
+      false
+    end
+  end
+
+  def mood_rating_daily_averages
+    averaged_ratings = []
+    daily_ratings = moods.group_by { |mood| mood.created_at.to_date }
+    # rubocop:disable all
+    daily_ratings.each do |day, moods_array|
+    # rubocop:enable all
+      ratings = moods_array.collect do |mood|
+        [mood.rating, mood.created_at].compact
+      end
+      if ratings.size > 0
+        averaged_ratings << { day: day,
+                              intensity: average_rating(ratings),
+                              is_positive: true,
+                              drill_down: ratings,
+                              data_type: "Mood"
+                            }
+      end
+    end
+    averaged_ratings
+  end
+
+  private
+
+  def recent_awake_period
+    @recent_awake_period ||= awake_periods.order("start_time").last
+  end
+
+  def recent_period
+    @recent_period ||= (
+      # when no awake period return an empty set to allow chaining
+      now = Time.new
+      start_time = recent_awake_period.try(:start_time) || now
+      end_time = recent_awake_period.try(:end_time) || now
+
+      { start_time: start_time, end_time: end_time }
+    )
+  end
+end