think_feel_do_engine 3.10.6

data/app/models/delivered_message.rb

@@ -0,0 +1,59 @@
+# An instance of a Message sent to a Participant or User.
+class DeliveredMessage < ActiveRecord::Base
+  include ThinkFeelDoEngine::Addressable
+
+  belongs_to :message
+  belongs_to :recipient, polymorphic: true
+
+  validates :message, :recipient, presence: true
+  validates :is_read, inclusion: { in: [true, false] }
+
+  after_create :deliver_notifications
+
+  scope :unread, -> { where(is_read: false) }
+
+  scope :sent_from, lambda { |sender_id|
+    joins(:message)
+      .where(
+        Arel::Table.new(:messages)[:sender_id]
+        .eq(sender_id)
+      )
+  }
+
+  delegate :body, :render_body, :sender, :subject, to: :message
+
+  def mark_read
+    update(is_read: true)
+  end
+
+  private
+
+  def deliver_notifications
+    if recipient.instance_of? User
+      ThinkFeelDoEngine::MessageNotifications
+        .new_for_coach(recipient, sender.active_group)
+        .deliver
+    elsif recipient.notify_by_sms?
+      MessageSmsNotification
+        .new(
+          body: "You have a new #{application_name} message.",
+          phone_number: recipient.phone_number)
+        .deliver
+    else
+      ThinkFeelDoEngine::MessageNotifications
+        .new_for_participant(recipient)
+        .deliver
+    end
+  rescue => exception
+    ::Raven.capture_message(exception)
+  end
+
+  def application_name
+    internationalization
+      .t(:application_name, default: "ThinkFeelDo")
+  end
+
+  def internationalization
+    I18n
+  end
+end

data/app/models/emotion.rb

@@ -0,0 +1,30 @@
+# Participants rate their emotions a name and intensity
+class Emotion < ActiveRecord::Base
+  belongs_to :creator, class_name: "Participant"
+  has_many :emotional_ratings, dependent: :destroy
+
+  validates :creator, presence: true
+  validates :name, presence: true
+  validates :name, uniqueness: { scope: :creator_id }
+
+  before_validation :normalize_name
+
+  def self.associate(participant, name)
+    find_or_create_by(
+      creator_id: participant.id,
+      name: normalized_name(name)
+    )
+  end
+
+  private
+
+  def self.normalized_name(n)
+    n.strip.downcase
+  end
+
+  def normalize_name
+    if name.respond_to?(:strip)
+      self.name = self.class.normalized_name(name)
+    end
+  end
+end

data/app/models/emotional_rating.rb

@@ -0,0 +1,45 @@
+# Participants no longer rate their emotions, they rate emotional ratings
+# These are objects tied to emotions - giving participants the opportunity
+# to rate the same emotion multiple times.
+class EmotionalRating < ActiveRecord::Base
+  belongs_to :emotion
+  belongs_to :participant
+
+  validates :emotion, presence: true
+  validates :participant, presence: true
+  validates :rating, presence: true, inclusion: { in: 0..10 }
+  validates :is_positive, inclusion: { in: [true, false] }
+
+  attr_writer :name
+
+  delegate :name, to: :emotion, prefix: false
+
+  before_validation :associate_emotion
+
+  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))
+    )
+  }
+
+  scope :positive, -> { where(arel_table[:is_positive].eq(true)) }
+
+  scope :negative, -> { where(arel_table[:is_positive].eq(false)) }
+
+  def rating_value
+    Values::EmotionalRating.from_rating(rating).to_s
+  end
+
+  def self.attribute_names
+    super.concat ["name"]
+  end
+
+  private
+
+  def associate_emotion
+    if @name.present?
+      self.emotion = Emotion.associate(participant, @name)
+    end
+  end
+end

data/app/models/engagement.rb

@@ -0,0 +1,7 @@
+# Used to determine when a patient starts and completes learn task_statuses
+class Engagement < ActiveRecord::Base
+  belongs_to :task_status
+
+  delegate :participant_id, to: :task_status, prefix: false
+  delegate :participant, to: :task_status, prefix: false
+end

data/app/models/group.rb

@@ -0,0 +1,144 @@
+# A set of Participants.
+class Group < ActiveRecord::Base
+  belongs_to :arm
+  belongs_to :creator, class_name: "User"
+
+  has_many :memberships, dependent: :destroy
+  has_many :participants, through: :memberships
+  has_many :active_memberships,
+           -> { active },
+           class_name: "Membership",
+           foreign_key: :group_id,
+           dependent: :destroy,
+           inverse_of: :active_group
+  has_many :tasks, dependent: :destroy
+  has_many :active_participants, through: :active_memberships
+
+  validates :arm_id, presence: true
+  validates :title, presence: true, length: { maximum: 50 }, uniqueness: true
+
+  delegate :count, to: :memberships, prefix: true
+
+  def learning_tasks
+    tasks
+      .joins(:bit_core_content_module)
+      .where(
+        Arel::Table.new(:bit_core_content_modules)[:type]
+        .eq("ContentModules::LessonModule")
+      )
+  end
+
+  def logins_by_week(week_number)
+    memberships.map do |membership|
+      membership
+        .logins_by_week(week_number)
+    end.inject(:+)
+  end
+
+  def thoughts_by_week(week_number)
+    thoughts = Arel::Table.new(:thoughts)
+
+    memberships.map do |membership|
+      membership
+        .participant
+        .thoughts
+        .where(thoughts[:created_at].gteq(week_start_day(week_number)))
+        .where(thoughts[:created_at].lt(week_end_day(week_number)))
+    end.map(&:count).sum
+  end
+
+  def activities_past_by_week(week_number)
+    activities = Arel::Table.new(:activities)
+
+    memberships.map do |membership|
+      membership
+        .participant
+        .activities
+        .in_the_past
+        .where(activities[:created_at].gteq(week_start_day(week_number)))
+        .where(activities[:created_at].lt(week_end_day(week_number)))
+    end.map(&:count).sum
+  end
+
+  def activities_future_by_week(week_number)
+    activities = Arel::Table.new(:activities)
+
+    memberships.map do |membership|
+      membership
+        .participant
+        .activities
+        .unscheduled_or_in_the_future
+        .where(activities[:created_at].gteq(week_start_day(week_number)))
+        .where(activities[:created_at].lt(week_end_day(week_number)))
+    end.map(&:count).sum
+  end
+
+  def goals_by_week(week_number)
+    social_networking_goals = Arel::Table.new(:social_networking_goals)
+
+    memberships.map do |membership|
+      SocialNetworking::Goal
+        .where(participant: membership.participant)
+        .where(social_networking_goals[:created_at]
+                 .gteq(week_start_day(week_number)))
+        .where(social_networking_goals[:created_at]
+                 .lt(week_end_day(week_number)))
+    end.map(&:count).sum
+  end
+
+  def comments_by_week(week_number)
+    social_networking_comments = Arel::Table.new(:social_networking_comments)
+
+    memberships.map do |membership|
+      SocialNetworking::Comment
+        .where(participant: membership.participant)
+        .where(social_networking_comments[:created_at]
+                 .gteq(week_start_day(week_number)))
+        .where(social_networking_comments[:created_at]
+                 .lt(week_end_day(week_number)))
+    end.map(&:count).sum
+  end
+
+  def on_the_mind_statements_by_week(week_number)
+    social_networking_on_the_mind_statements =
+      Arel::Table.new(:social_networking_on_the_mind_statements)
+
+    memberships.map do |membership|
+      SocialNetworking::OnTheMindStatement
+        .where(participant: membership.participant)
+        .where(social_networking_on_the_mind_statements[:created_at]
+                 .gteq(week_start_day(week_number)))
+        .where(social_networking_on_the_mind_statements[:created_at]
+                 .lt(week_end_day(week_number)))
+    end.map(&:count).sum
+  end
+
+  def likes_by_week(week_number)
+    social_networking_likes =
+      Arel::Table.new(:social_networking_likes)
+
+    memberships.map do |membership|
+      SocialNetworking::Like
+        .where(participant: membership.participant)
+        .where(social_networking_likes[:created_at]
+                 .gteq(week_start_day(week_number)))
+        .where(social_networking_likes[:created_at]
+                 .lt(week_end_day(week_number)))
+    end.map(&:count).sum
+  end
+
+  private
+
+  # Returns the earliest start date of all the group's memberships
+  def start_date
+    memberships.order(start_date: :asc).first.start_date
+  end
+
+  def week_start_day(week_number)
+    start_date + ((week_number - 1) * 7).days
+  end
+
+  def week_end_day(week_number)
+    start_date + (week_number * 7).days
+  end
+end

data/app/models/media_access_event.rb

@@ -0,0 +1,24 @@
+# Log of participant viewings and listenings of media slides
+class MediaAccessEvent < ActiveRecord::Base
+  belongs_to :participant,
+             foreign_key: :participant_id
+  belongs_to :slide,
+             class_name: "BitCore::Slide",
+             foreign_key: :bit_core_slide_id
+  validates :media_type, inclusion: { in: ["audio", "video"] }
+  validates :media_link,
+            :participant,
+            :slide,
+            presence: :true
+
+  delegate :title, to: :slide, prefix: true
+
+  def task_release_day
+    module_id = slide.slideshow.content_provider.bit_core_content_module_id
+
+    Task.where(
+      bit_core_content_module_id: module_id,
+      group_id: participant.active_group.id
+    ).first.release_day
+  end
+end

data/app/models/membership.rb

@@ -0,0 +1,199 @@
+# The relationship of a Participant to a Group.
+class Membership < ActiveRecord::Base
+  AMERICAN_DATE_FMT = "%m/%d/%Y"
+
+  belongs_to :group
+  belongs_to :active_group,
+             class_name: "Group",
+             foreign_key: :group_id,
+             inverse_of: :active_memberships
+  belongs_to :participant
+  belongs_to :active_participant,
+             class_name: "Participant",
+             foreign_key: :participant_id,
+             inverse_of: :active_membership
+  has_many :task_statuses, dependent: :destroy
+  has_many :tasks,
+           -> { uniq },
+           through: :task_statuses
+
+  validates :start_date, presence: true
+  validates :end_date, presence: true
+  validates :group, presence: true
+  validates :participant, presence: true
+  validates :group_id, uniqueness: { scope: :participant_id }
+  validate :not_complete_in_the_future
+  validate :group_id_unchanged
+  validate :single_active_membership
+  validate :not_ending_in_the_past
+
+  delegate :email, to: :participant, prefix: true, allow_nil: true
+
+  after_create :create_task_statuses
+
+  scope :active, lambda {
+    where(
+      arel_table[:start_date].lteq(Date.current)
+      .and(arel_table[:end_date].gteq(Date.current))
+      .or(arel_table[:is_complete].eq(true))
+    )
+  }
+
+  scope :inactive, lambda {
+    where(
+      arel_table[:start_date].gt(Date.current)
+      .or(arel_table[:end_date].lt(Date.current))
+    )
+  }
+
+  scope :continuing, lambda {
+    where(is_complete: false)
+  }
+
+  def available_task_statuses
+    @available_task_statuses ||=
+      task_statuses
+      .available_by_day(day_in_study)
+      .not_terminated_by_day(day_in_study)
+      .joins(:task, task: :bit_core_content_module)
+      .by_position
+  end
+
+  def incomplete_tasks
+    available_task_statuses
+      .incomplete_by_day(day_in_study)
+  end
+
+  def incomplete_tasks_today
+    available_task_statuses
+      .incomplete_on_day(day_in_study)
+  end
+
+  def week_in_study(date = nil)
+    (day_in_study(date) / 7.0).ceil == 0 ? 1 : (day_in_study(date) / 7.0).ceil
+  end
+
+  def day_in_study(date = nil)
+    ((date || Date.current) - start_date).to_i + 1
+  end
+
+  def length_of_study
+    end_date - start_date + 1
+  end
+
+  def start_date_american
+    start_date && start_date.strftime(AMERICAN_DATE_FMT)
+  end
+
+  def end_date_american
+    end_date && end_date.strftime(AMERICAN_DATE_FMT)
+  end
+
+  def learning_tasks
+    tasks.learning
+  end
+
+  def flag_complete
+    self.is_complete = true
+    self.end_date = Date.yesterday
+
+    save validate: false
+  end
+
+  def logins_by_week(week_number)
+    participant_login_events = Arel::Table.new(:participant_login_events)
+    participant
+      .participant_login_events
+      .where(participant_login_events[:created_at]
+               .gteq(week_start_day(week_number)))
+      .where(participant_login_events[:created_at]
+               .lt(week_end_day(week_number)))
+      .count
+  end
+
+  def logins_today
+    participant_login_events = Arel::Table.new(:participant_login_events)
+    participant
+      .participant_login_events
+      .where(participant_login_events[:created_at]
+                 .gteq(Date.current.beginning_of_day))
+      .where(participant_login_events[:created_at]
+                 .lt(Date.current.end_of_day))
+  end
+
+  def lessons_read
+    task_statuses.completed.select(&:is_lesson?)
+  end
+
+  def lessons_read_for_day(time)
+    task_statuses
+      .completed
+      .where("completed_at <= ? AND completed_at >= ?",
+             time.end_of_day,
+             time.beginning_of_day)
+      .select(&:is_lesson?)
+  end
+
+  def lessons_read_for_week
+    task_statuses
+      .completed
+      .where("completed_at >= ?", Time.current.advance(days: -7)
+                                      .beginning_of_day)
+      .select(&:is_lesson?)
+  end
+
+  def withdraw
+    return false unless valid?
+
+    update_column(:end_date, Date.current - 1.day)
+  end
+
+  def discontinue
+    return false unless valid?
+
+    update_columns(end_date: Date.current - 1.day, is_complete: true)
+  end
+
+  private
+
+  def create_task_statuses
+    group.tasks.each do |task|
+      task.send(:create_recurring_task_statuses, self)
+    end
+  end
+
+  def single_active_membership
+    if Membership.where(participant_id: participant_id)
+       .where("start_date <= ? AND end_date >= ?", end_date, start_date)
+       .where.not(id: id)
+       .exists?
+      errors.add(:base, "There can be only one active membership")
+    end
+  end
+
+  def group_id_unchanged
+    if changed.include?("group_id") && !changes["group_id"][0].nil?
+      errors.add :group_id, "cannot be changed"
+    end
+  end
+
+  def not_complete_in_the_future
+    return unless end_date && end_date > Date.today && is_complete == true
+
+    errors.add :is_complete, "cannot be set to true for end dates in the future"
+  end
+
+  def week_start_day(week_number)
+    start_date + ((week_number - 1) * 7).days
+  end
+
+  def week_end_day(week_number)
+    start_date + (week_number * 7).days
+  end
+
+  def not_ending_in_the_past
+    return unless end_date && end_date_changed? && end_date < Date.current
+
+    errors.add :end_date, "must not be in the past"
+  end
+end