think_feel_do_engine 3.10.6

data/app/models/activity_type.rb

@@ -0,0 +1,8 @@
+# The name given to an Activity. Can be private to a Participant or public.
+class ActivityType < ActiveRecord::Base
+  belongs_to :participant
+  has_many :activities, dependent: :restrict_with_exception
+
+  validates :title, presence: true
+  # do not validate presence of participant
+end

data/app/models/arm.rb

@@ -0,0 +1,47 @@
+# These arms are part of the adolescent and adult projects
+# Between 1 and 8 groups are in each arm and each group
+# could have between 1 and 10 or so participants
+class Arm < ActiveRecord::Base
+  has_many :groups, dependent: :nullify
+  has_many :bit_core_tools,
+           class_name: "BitCore::Tool",
+           foreign_key: :arm_id,
+           dependent: :destroy
+  has_many :bit_core_slideshows,
+           class_name: "BitCore::Slideshow",
+           foreign_key: :arm_id,
+           dependent: :destroy
+
+  validates :title, presence: true
+  validates_with ArmValidator
+
+  def display_name_required_for_membership?(participant, display_name)
+    if social? && display_name.empty?
+      participant.errors.add(
+        :display_name, "is required because the arm of this \
+          intervention utilizes social features or the \
+          participant is currently enrolled in an arm that \
+          requires a display name."
+        )
+      false
+    else
+      true
+    end
+  end
+
+  def social?
+    is_social
+  end
+
+  def woz?
+    has_woz
+  end
+
+  def non_home_tools
+    tools = Arel::Table.new(:bit_core_tools)
+    bit_core_tools
+      .where(tools[:type].eq(nil)
+        .or(tools[:type].not_eq("Tools::Home"))
+      )
+  end
+end

data/app/models/arm_validator.rb

@@ -0,0 +1,11 @@
+# Validates Arm model.
+class ArmValidator < ActiveModel::Validator
+  def validate(record)
+    if ActiveRecord::Base.connection
+       .column_exists?(:arms, :can_message_after_membership_complete) &&
+       record.can_message_after_membership_complete.nil?
+      record.errors[:base] << "An Arm must have a value for can_message"\
+                              "_after_membership_complete"
+    end
+  end
+end

data/app/models/available_content_module.rb

@@ -0,0 +1,95 @@
+# A read-only, view backed model that represents an assigned Content Module.
+class AvailableContentModule < ActiveRecord::Base
+  self.primary_key = :id
+
+  belongs_to :bit_core_tool,
+             class_name: "BitCore::Tool"
+  belongs_to :participant
+  has_many :content_providers,
+           class_name: "BitCore::ContentProvider",
+           foreign_key: :bit_core_content_module_id
+
+  def self.for_participant(participant)
+    where participant_id: participant.id
+  end
+
+  def self.for_tool(tool)
+    where bit_core_tool_id: tool.id
+  end
+
+  def self.is_viz
+    where is_viz: true
+  end
+
+  def self.is_not_viz
+    where is_viz: false
+  end
+
+  def self.is_completed
+    where.not completed_at: nil
+  end
+
+  def self.is_not_completed
+    where completed_at: nil
+  end
+
+  def self.is_didactic
+    where has_didactic_content: true
+  end
+
+  def self.is_not_didactic
+    where has_didactic_content: false
+  end
+
+  def self.is_terminated_on(date)
+    where(arel_table[:terminates_on].lt(date))
+  end
+
+  def self.is_not_terminated_on(date)
+    where(arel_table[:terminates_on].eq(nil)
+          .or(arel_table[:terminates_on].gteq(date)))
+  end
+
+  def self.available_by(date)
+    where(arel_table[:available_on].lteq(date))
+  end
+
+  def self.available_on(date)
+    where available_on: date
+  end
+
+  def self.excludes_module(content_module_or_id)
+    where.not(id: content_module_or_id.try(:id) || content_module_or_id)
+  end
+
+  def self.order_by_position(direction = :asc)
+    order position: direction
+  end
+
+  def self.position_greater_than(position)
+    where(arel_table[:position].gt(position))
+  end
+
+  # Note that this scope must appear at the end of a chain. Its SQL doesn't
+  # play nicely with Arel.
+  def self.latest_duplicate
+    select("
+      DISTINCT ON (has_didactic_content,
+                   bit_core_tool_id,
+                   is_viz,
+                   position,
+                   title,
+                   membership_id,
+                   participant_id)
+      *
+    ")
+      .order(:has_didactic_content,
+             :bit_core_tool_id,
+             :is_viz,
+             :position,
+             :title,
+             :membership_id,
+             :participant_id,
+             available_on: :desc)
+  end
+end

data/app/models/awake_period.rb

@@ -0,0 +1,40 @@
+# A period of time during which a Participant was awake and may have
+# participated in Activities.
+class AwakePeriod < ActiveRecord::Base
+  belongs_to :participant
+
+  validates :participant, :start_time, :end_time, presence: true
+  validate :end_time_after_start_time
+  validate :awake_periods_cannot_overlap
+
+  scope :periods_for, lambda { |start_time, end_time|
+    where(
+      arel_table[:start_time]
+      .lteq(end_time)
+      .and(
+        arel_table[:end_time]
+        .gteq(start_time)
+      )
+    )
+  }
+
+  private
+
+  def awake_periods_cannot_overlap
+    overlapping_period_exists =
+      participant
+      .awake_periods
+      .periods_for(start_time, end_time)
+      .limit(1)
+      .count == 1
+    if overlapping_period_exists
+      errors.add(:base, "This awake period already exists")
+    end
+  end
+
+  def end_time_after_start_time
+    if start_time && end_time && end_time <= start_time
+      errors.add :end_time, "Must be after the start time"
+    end
+  end
+end

data/app/models/bit_core/slide_observer.rb

@@ -0,0 +1,9 @@
+module BitCore
+  # Listen for BitCore::Slide lifecycle events.
+  # Registered in config/application.rb
+  class SlideObserver < ActiveRecord::Observer
+    def before_destroy(slide)
+      MediaAccessEvent.where(bit_core_slide_id: slide.id).destroy_all
+    end
+  end
+end

data/app/models/coach_assignment.rb

@@ -0,0 +1,9 @@
+# The assignment of a Coach (User) to a Participant.
+class CoachAssignment < ActiveRecord::Base
+  belongs_to :participant
+  belongs_to :coach, class_name: "User"
+
+  validates :coach, :participant, presence: true
+
+  delegate :email, to: :coach, prefix: false
+end

data/app/models/content_modules.rb

@@ -0,0 +1,27 @@
+module ContentModules
+  # Methods for extending BitCore::ContentModule with scopes.
+  module Scopes
+    def didactic(group_id)
+      didactic_module_ids = Task
+                            .where(group_id: group_id,
+                                   has_didactic_content: true)
+                            .select(:id, :bit_core_content_module_id)
+                            .map(&:bit_core_content_module_id)
+
+      where(id: non_viz_module_ids & didactic_module_ids).select(:id)
+    end
+
+    def non_didactic(group_id)
+      non_didactic_module_ids = Task.where(group_id: group_id,
+                                           has_didactic_content: false)
+                                .select(:id, :bit_core_content_module_id)
+                                .map(&:bit_core_content_module_id)
+
+      where(id: non_viz_module_ids & non_didactic_module_ids).select(:id)
+    end
+
+    def non_viz_module_ids
+      where(is_viz: false).map(&:id)
+    end
+  end
+end

data/app/models/content_modules/lesson_module.rb

@@ -0,0 +1,88 @@
+module ContentModules
+  # Container for didactic content.
+  class LessonModule < BitCore::ContentModule
+    after_save :update_slideshow
+
+    def self.sort(arm_id, lesson_ids)
+      start_position = Arm.find(arm_id)
+                       .bit_core_tools.find_by_type("Tools::Learn")
+                       .content_modules
+                       .where(type: [nil, "BitCore::ContentModule"])
+                       .order(position: :asc).maximum(:position)
+      start_position ||= 1
+      start_position += 1
+
+      transaction do
+        connection.execute "SET CONSTRAINTS " \
+                             "bit_core_content_module_position DEFERRED"
+        lesson_ids.each_with_index do |id, idx|
+          find(id).update_attribute(:position, idx + start_position)
+        end
+      end
+    end
+
+    def pretty_title
+      return "" if title.nil?
+
+      Redcarpet::Markdown.new(
+        Redcarpet::Render::HTML.new(
+          filter_html: true,
+          safe_links_only: true
+        )
+      ).render(title).html_safe
+    end
+
+    def plain_title
+      return "" if title.nil?
+
+      title.gsub(/\*\*/, "")
+    end
+
+    def lesson_provider
+      @lesson_provider ||= (content_providers.first ||
+        add_content_provider("BitCore::ContentProviders::SlideshowProvider")
+      )
+    end
+
+    def slides
+      lesson_provider.try(:source_content).try(:slides) || []
+    end
+
+    def build_slide(attrs = {})
+      update_slideshow
+
+      slides.build(attrs.merge(position: slides.count + 1))
+    end
+
+    def destroy_slide(slide)
+      position = slide.position
+
+      slide.transaction do
+        if slide.destroy!
+          slides.where("position >= ?", position).each_with_index do |s, i|
+            s.update_column(:position, position + i)
+          end
+        end
+      end
+
+      true
+
+    rescue
+      false
+    end
+
+    def sort(slide_ids)
+      update_slideshow
+
+      lesson_provider.source_content.sort(slide_ids)
+    end
+
+    private
+
+    def update_slideshow
+      lesson_provider.save
+
+      lesson_provider.add_or_update_slideshow(title, tool.arm_id)
+    end
+  end
+end

data/app/models/content_provider_decorator.rb

@@ -0,0 +1,115 @@
+# Allows for extending BitCore::ContentProvider with an additional model class
+# and corresponding attributes.
+class ContentProviderDecorator
+  # Play nicely with form_for.
+  include ActiveModel::Conversion
+
+  delegate :id, :bit_core_content_module_id, :type, :source_content,
+           :source_content_type, :source_content_id, :position,
+           :show_next_nav, :pretty_label, :content_module,
+           :template_path, :locals, :data_attributes,
+           to: :content_provider
+  delegate :is_skippable_after_first_viewing,
+           to: :content_policy
+
+  attr_reader :content_provider, :content_policy
+
+  def self.fetch(provider_or_id)
+    provider = provider_or_id
+    if provider.try(:to_i).class == Fixnum
+      provider = BitCore::ContentProvider.find(provider.to_i)
+    end
+    policy = ContentProviderPolicy.find_or_initialize_by(
+      bit_core_content_provider_id: provider.id
+    )
+
+    new(content_provider: provider, content_policy: policy)
+  end
+
+  # Play nicely with form_for.
+  def self.model_name
+    ActiveModel::Name.new(BitCore::ContentProvider)
+  end
+
+  # Eagerly load BitCore::ContentProvider descendants, as would
+  # normally be required in development and test environments.
+  def self.content_provider_classes
+    BitCore::ContentProviders::SlideshowProvider.to_s
+    Dir["#{Rails.root}/app/models/content_providers/*.rb"].each do |file|
+      require_dependency file
+    end
+
+    BitCore::ContentProvider.descendants
+  end
+
+  def initialize(attrs = {})
+    if attrs[:content_provider] && attrs[:content_policy]
+      @content_provider = attrs[:content_provider]
+      @content_policy = attrs[:content_policy]
+    else
+      provider_attrs = content_provider_attributes(attrs)
+      @content_provider = BitCore::ContentProvider.new(provider_attrs)
+      policy_attrs = content_policy_attributes(attrs)
+      @content_policy = ContentProviderPolicy.new(policy_attrs)
+    end
+  end
+
+  # Play nicely with form_for.
+  def to_model
+    content_provider
+  end
+
+  # Play nicely with form_for.
+  def persisted?
+    true
+  end
+
+  def errors
+    OpenStruct.new(full_messages: content_provider.errors.full_messages +
+                   content_policy.errors.full_messages)
+  end
+
+  def save
+    content_provider.transaction do
+      content_provider.save!
+      content_policy.bit_core_content_provider_id = content_provider.id
+      content_policy.save!
+    end
+
+    true
+
+  rescue
+    false
+  end
+
+  def update(attrs)
+    provider_attrs = content_provider_attributes(attrs)
+    policy_attrs = content_policy_attributes(attrs)
+
+    content_provider.update(provider_attrs) &&
+      content_policy.update!(policy_attrs)
+  end
+
+  def destroy
+    content_provider.transaction do
+      content_policy.destroy!
+      content_provider.destroy!
+    end
+
+    true
+
+  rescue
+    false
+  end
+
+  def content_provider_attributes(attrs)
+    attrs.slice(
+      :bit_core_content_module_id, :type, :source_content_type,
+      :source_content_id, :position, :show_next_nav, :template_path
+    )
+  end
+
+  def content_policy_attributes(attrs)
+    attrs.slice(:is_skippable_after_first_viewing)
+  end
+end