social_networking 0.9.3

data/app/controllers/social_networking/profiles_controller.rb

@@ -0,0 +1,53 @@
+require_dependency "social_networking/application_controller"
+
+module SocialNetworking
+  # Manage Participants.
+  class ProfilesController < ApplicationController
+    rescue_from ActiveRecord::RecordNotFound, with: :record_not_found
+
+    def index
+      group_participants = current_participant.active_group.active_participants
+      render json: Serializers::ProfileSerializer.from_collection(Profile
+        .where(participant_id: group_participants.pluck(:id)))
+    end
+
+    def show
+      if params[:id]
+        profile = Profile.find(params[:id])
+      else
+        profile = Profile
+                  .find_or_initialize_by(
+                    participant_id: current_participant.id) do |profile_new|
+          begin
+            SharedItem.create(
+              item: profile_new,
+              action_type: Profile::Actions.created)
+          rescue ActiveRecord::StatementInvalid
+            logger.info("Shared item already created for existing profile.")
+          end
+        end
+      end
+
+      render json: Serializers::ProfileSerializer.new(profile).to_serialized
+    end
+
+    def update
+      profile = current_participant.social_networking_profile
+      if profile.update(profile_params)
+        render json: Serializers::ProfileSerializer.new(profile).to_serialized
+      else
+        render json: { error: profile.errors.full_messages }, status: 400
+      end
+    end
+
+    private
+
+    def profile_params
+      params.permit(:icon_name)
+    end
+
+    def record_not_found
+      render json: { error: "profile not found" }, status: 404
+    end
+  end
+end

data/app/controllers/social_networking/shared_item_controller.rb

@@ -0,0 +1,95 @@
+require_dependency "social_networking/application_controller"
+
+module SocialNetworking
+  # Manage shared items
+  class SharedItemController < ApplicationController
+    SHARED_ITEM_PAGE_SIZE = 5
+
+    skip_before_action :verify_authenticity_token
+    def hide
+      shared_item_to_hide = SharedItem.find_by_id(shared_item_params[:id])
+      if current_participant.id == shared_item_to_hide.item.participant.id
+        if shared_item_to_hide.update_attribute(:is_public, false)
+          status = :accepted
+        else
+          status = :internal_server_error
+        end
+      else
+        status = :unauthorized
+      end
+
+      respond_to do |format|
+        format.html { render nothing: true, status: status }
+        format.js   { render nothing: true, status: status }
+        format.json { render nothing: true, status: status }
+      end
+    end
+
+    def page
+      items_by_page = []
+      requested_page = shared_item_params[:page]
+      start_index =
+        requested_page ? requested_page.to_i * SHARED_ITEM_PAGE_SIZE : 0
+      feed_items_page =
+        aggregate_feed_items(
+          Participant.find(shared_item_params[:participant_id]),
+          requested_page.to_i
+        )
+
+      if feed_items_page.size >= start_index
+        feed_items =
+          feed_items_page.sort_by { |item| item[:createdAtRaw] }.reverse!
+        items_by_page =
+          feed_items[start_index..(start_index + SHARED_ITEM_PAGE_SIZE - 1)]
+      end
+
+      render json: { feedItems: items_by_page }
+    end
+
+    private
+
+    def shared_item_params
+      params.permit(:id, :participant_id, :page)
+    end
+
+    def group_shared_items(participant, requested_page)
+      SocialNetworking::SharedItem
+        .joins(participant: [{ memberships: :group }])
+        .where(groups: { id: participant.active_group.id })
+        .order(created_at: :desc)
+        .limit(SHARED_ITEM_PAGE_SIZE * (requested_page + 1))
+        .includes(:comments, :likes)
+    end
+
+    def aggregate_feed_items(participant, page)
+      on_the_minds_for_pariticipant_group(participant, page) +
+        nudges_for_participant_group(participant, page) +
+        shared_items_for_participant_group(participant, page)
+    end
+
+    def on_the_minds_for_pariticipant_group(participant, page)
+      Serializers::OnTheMindStatementSerializer
+        .from_collection(
+          OnTheMindStatement.joins(participant: [{ memberships: :group }])
+            .where(groups: { id: participant.active_group.id })
+            .order(created_at: :desc)
+            .limit(SHARED_ITEM_PAGE_SIZE * (page + 1))
+            .includes(:comments, :likes))
+    end
+
+    def nudges_for_participant_group(participant, page)
+      Serializers::NudgeSerializer
+        .from_collection(
+          Nudge.joins(initiator: [{ memberships: :group }])
+            .where(groups: { id: participant.active_group.id })
+            .order(created_at: :desc)
+            .limit(SHARED_ITEM_PAGE_SIZE * (page + 1))
+            .includes(:comments))
+    end
+
+    def shared_items_for_participant_group(participant, requested_page)
+      Serializers::SharedItemSerializer
+        .from_collection(group_shared_items(participant, requested_page))
+    end
+  end
+end

data/app/controllers/social_networking/templates_controller.rb

@@ -0,0 +1,14 @@
+require_dependency "social_networking/application_controller"
+
+module SocialNetworking
+  # Sends back static templates.
+  class TemplatesController < ApplicationController
+    # Renders either the engine template if it exists or the host template.
+    def page
+      @path = params[:path].gsub(/[^_a-z\/]+/m, "")
+      template = "social_networking/templates/#{ @path }.html"
+
+      render file: template, layout: nil
+    end
+  end
+end

data/app/mailers/social_networking/mailer.rb

@@ -0,0 +1,9 @@
+module SocialNetworking
+  # Notifies participants of comments, likes, and nudges.
+  class Mailer < ActionMailer::Base
+    def notify(recipient:, body:, subject:)
+      @message_body = body
+      mail(to: recipient.email, subject: subject)
+    end
+  end
+end

data/app/models/social_networking/action_item.rb

@@ -0,0 +1,14 @@
+module SocialNetworking
+  # A helper for aggregating "todo" items.
+  class ActionItem
+    class << self
+      attr_writer :source_class_name
+
+      def for(participant)
+        return [] if @source_class_name.nil?
+
+        @source_class_name.constantize.for(participant)
+      end
+    end
+  end
+end

data/app/models/social_networking/comment.rb

@@ -0,0 +1,20 @@
+module SocialNetworking
+  # A comment written by a Participant and attached to a piece of content.
+  class Comment < ActiveRecord::Base
+    belongs_to :participant
+    belongs_to :item, polymorphic: true
+
+    validates :participant, :item, :text, presence: true
+
+    scope :for_today, lambda {
+      where(arel_table[:created_at]
+                .gteq(Date.today.beginning_of_day)
+                .and(arel_table[:created_at].lteq(Date.today.end_of_day)))
+    }
+
+    scope :for_week, lambda {
+      where(arel_table[:created_at]
+                 .gteq(Time.current.advance(days: -7).beginning_of_day))
+    }
+  end
+end

data/app/models/social_networking/concerns/membership.rb

@@ -0,0 +1,27 @@
+module SocialNetworking
+  module Concerns
+    # adds scops to Membership class
+    module Membership
+      extend ActiveSupport::Concern
+      def comments
+        SocialNetworking::Comment.where(participant: participant)
+      end
+
+      def likes
+        SocialNetworking::Like.where(participant: participant)
+      end
+
+      def nudges
+        SocialNetworking::Nudge.where(initiator_id: participant)
+      end
+
+      def goals
+        SocialNetworking::Goal.where(participant: participant)
+      end
+
+      def on_the_minds
+        SocialNetworking::OnTheMindStatement.where(participant: participant)
+      end
+    end
+  end
+end

data/app/models/social_networking/concerns/participant.rb

@@ -0,0 +1,43 @@
+module SocialNetworking
+  module Concerns
+    # adds associations to Participant class
+    module Participant
+      extend ActiveSupport::Concern
+
+      included do
+        has_many :social_networking_comments,
+                 class_name: "SocialNetworking::Comment",
+                 dependent: :destroy
+        has_many :social_networking_goals,
+                 class_name: "SocialNetworking::Goal",
+                 dependent: :destroy
+        has_many :social_networking_likes,
+                 class_name: "SocialNetworking::Like",
+                 dependent: :destroy
+        has_many :initiator_nudges,
+                 foreign_key: :initiator_id,
+                 class_name: "SocialNetworking::Nudge",
+                 dependent: :destroy
+        has_many :recipient_nudges,
+                 foreign_key: :recipient_id,
+                 class_name: "SocialNetworking::Nudge",
+                 dependent: :destroy
+        has_many :social_networking_on_the_mind_statements,
+                 class_name: "SocialNetworking::OnTheMindStatement",
+                 dependent: :destroy
+        has_one :social_networking_profile,
+                class_name: "SocialNetworking::Profile",
+                dependent: :destroy
+
+        validates :email, presence: true, if: "contact_preference == 'email'"
+        validates :phone_number, presence: true, if: :phone_number?
+
+        private
+
+        def phone_number?
+          %w(sms phone).include?(contact_preference)
+        end
+      end
+    end
+  end
+end

data/app/models/social_networking/goal.rb

@@ -0,0 +1,91 @@
+module SocialNetworking
+  # Something to be completed by a Participant.
+  class Goal < ActiveRecord::Base
+    # create a mini DSL for types of Goal actions
+    ACTION_TYPES = %w( created completed did_not_complete )
+    Actions = Struct.new(*ACTION_TYPES.map(&:to_sym))
+              .new(*(ACTION_TYPES.map { |t| t.gsub(/_/, " ") }))
+
+    belongs_to :participant
+    has_many :comments, as: "item"
+    has_many :likes, as: "item"
+
+    validates :participant, :description, presence: true
+    validate :not_due_in_the_past, on: :create
+    validate :due_before_membership_ends, on: :create
+
+    # Within the last day, used for shared item generation
+    scope :did_not_complete, (lambda do
+      where(deleted_at: nil, completed_at: nil)
+      .where(arel_table[:due_on].lt(Time.zone.today))
+      .where(arel_table[:due_on].gteq(Time.zone.today - 1.day))
+    end)
+
+    def to_serialized
+      if due_on
+        {
+          description: description,
+          dueOn: due_on.to_s(:participant_date)
+        }
+      else
+        {}
+      end
+    end
+
+    def shared_description
+      "Goal: #{description}"
+    end
+
+    # Necessary for legacy front-end code.
+    # rubocop:disable Style/PredicateName
+    def is_completed
+      completed_at?
+    end
+    # rubocop:enable Style/PredicateName
+
+    # Necessary for legacy front-end code.
+    # rubocop:disable Style/PredicateName
+    def is_deleted
+      deleted_at?
+    end
+    # rubocop:enable Style/PredicateName
+
+    def action
+      if is_completed
+        "Completed"
+      elsif due_on && due_on < Time.zone.today
+        "Did Not Complete"
+      else
+        "Created"
+      end
+    end
+
+    private
+
+    def not_due_in_the_past
+      return if due_on.nil? || due_on >= Date.today
+
+      errors.add :due_on, "must not be in the past"
+    end
+
+    def due_before_membership_ends
+      return if due_on.nil? ||
+                participant_id.nil? ||
+                participant.active_membership_end_date.nil? ||
+                due_on <= participant.active_membership_end_date
+
+      errors.add :due_on, "must be during study enrollment"
+    end
+
+    scope :for_today, lambda {
+      where(arel_table[:created_at]
+                .gteq(Date.today.beginning_of_day)
+                .and(arel_table[:created_at].lteq(Date.today.end_of_day)))
+    }
+
+    scope :for_week, lambda {
+      where(arel_table[:created_at]
+             .gteq(Time.current.advance(days: -7).beginning_of_day))
+    }
+  end
+end

data/app/models/social_networking/like.rb

@@ -0,0 +1,37 @@
+module SocialNetworking
+  # A sign of approval of a piece of content by a Participant.
+  class Like < ActiveRecord::Base
+    belongs_to :participant
+    belongs_to :item, polymorphic: true
+
+    validates :participant, :item, presence: true
+    # a Participant may only Like an item once
+    validates :item_id, uniqueness: { scope: [:item_type, :participant_id] }
+
+    scope :for_today,
+          lambda {
+            where(arel_table[:created_at]
+                    .gteq(Date.today.beginning_of_day)
+                    .and(arel_table[:created_at].lteq(Date.today.end_of_day)))
+          }
+
+    scope :for_week,
+          lambda {
+            where(arel_table[:created_at]
+                    .gteq(Time.current.advance(days: -7).beginning_of_day))
+          }
+
+    def item_description
+      case item_type
+      when "SocialNetworking::OnTheMindStatement"
+        Shareable.new(item).description
+      when "SocialNetworking::SharedItem"
+        if item
+          Shareable.new(item.item).description
+        else
+          Shareable.new(nil).description
+        end
+      end
+    end
+  end
+end

data/app/models/social_networking/notification.rb

@@ -0,0 +1,42 @@
+module SocialNetworking
+  # Sends sms or emails to participants.
+  class Notification
+    include Sms
+    attr_reader :current_participant,
+                :mailer,
+                :recipient,
+                :message_body,
+                :subject
+
+    def initialize(
+      current_participant:,
+      mailer:,
+      recipient:,
+      message_body:,
+      subject:)
+      @current_participant = current_participant
+      @mailer = mailer
+      @message_body = message_body
+      @recipient = recipient
+      @subject = subject
+    end
+
+    def notify
+      return if current_participant == recipient
+      if recipient.contact_preference == "email"
+        send_email
+      else
+        send_sms(recipient, message_body)
+      end
+    end
+
+    def send_email
+      mailer
+        .notify(
+          recipient: recipient,
+          body: message_body,
+          subject: subject)
+        .deliver_now
+    end
+  end
+end

data/app/models/social_networking/nudge.rb

@@ -0,0 +1,38 @@
+module SocialNetworking
+  # A form of contact between two Participants.
+  class Nudge < ActiveRecord::Base
+    belongs_to :initiator,
+               class_name: "Participant",
+               foreign_key: "initiator_id"
+    belongs_to :recipient, class_name: "Participant"
+    has_many :comments, as: "item"
+
+    accepts_nested_attributes_for :recipient
+
+    alias_attribute :participant_id, :initiator_id
+
+    validates :initiator, :recipient, presence: true
+
+    def self.search(recipient_id = nil)
+      if recipient_id
+        select(:initiator_id)
+          .where(recipient_id: recipient_id)
+          .where("created_at > ?", 1.day.ago)
+          .group(:initiator_id)
+      else
+        all
+      end
+    end
+
+    scope :for_today, lambda {
+      where(arel_table[:created_at]
+                .gteq(Date.today.beginning_of_day)
+                .and(arel_table[:created_at].lteq(Date.today.end_of_day)))
+    }
+
+    scope :for_week, lambda {
+      where(arel_table[:created_at]
+             .gteq(Time.current.advance(days: -7).beginning_of_day))
+    }
+  end
+end

data/app/models/social_networking/on_the_mind_statement.rb

@@ -0,0 +1,26 @@
+module SocialNetworking
+  # A statement by a Participant to be shared with the Group.
+  class OnTheMindStatement < ActiveRecord::Base
+    belongs_to :participant
+    has_many :comments, as: "item", dependent: :destroy
+    has_many :likes, as: "item", dependent: :destroy
+
+    validates :participant, :description, presence: true
+
+    scope :for_today, lambda {
+      where(
+        "created_at <= ? AND created_at >= ?",
+        Date.today.end_of_day,
+        Date.today.beginning_of_day
+      )
+    }
+
+    scope :for_week, lambda {
+      where("created_at >= ?", Time.current.advance(days: -7).beginning_of_day)
+    }
+
+    def shared_description
+      description
+    end
+  end
+end

data/app/models/social_networking/profile.rb

@@ -0,0 +1,88 @@
+module SocialNetworking
+  # A set of data representing a Social Profile belonging to a Participant.
+  class Profile < ActiveRecord::Base
+    ACTION_TYPES = %w( created completed )
+    Actions = Struct.new(*ACTION_TYPES.map(&:to_sym)).new(*ACTION_TYPES)
+
+    after_create :share_profile
+
+    belongs_to :participant
+    has_many :profile_answers,
+             class_name: "SocialNetworking::ProfileAnswer",
+             foreign_key: :social_networking_profile_id,
+             dependent: :destroy
+    has_many :comments, as: "item"
+    has_many :likes, as: "item"
+
+    validates :participant, presence: true
+    validates :participant_id, uniqueness: true
+
+    delegate :latest_action_at, :active_membership_end_date,
+             to: :participant
+
+    def self.icon_names
+      %w(
+        art
+        bike
+        bolt
+        bookshelf
+        die
+        fashion
+        flower
+        genius
+        heart
+        helicopter
+        hourglass
+        keyboard
+        magnifyingglass
+        megaphone2
+        microphone
+        music
+        paintbrush2
+        plane
+        polaroidcamera
+        present
+        recycle
+        scooter
+        shipwheel
+        shoeprints
+        star
+        travelerbag
+        ufo
+        umbrella
+        weather)
+    end
+
+    def to_serialized
+      {}
+    end
+
+    def started?
+      profile_answers.any?
+    end
+
+    def description
+      "Welcome, #{user_name}!"
+    end
+
+    def shared_description
+      "Profile Created: #{participant.display_name}"
+    end
+
+    def user_name
+      if participant.is_admin
+        Rails.application.config.moderating_participant_display_name
+      else
+        participant.display_name
+      end
+    end
+
+    private
+
+    def share_profile
+      SharedItem.create(
+        item: self,
+        action_type: Profile::Actions.created)
+    end
+  end
+end

data/app/models/social_networking/profile_answer.rb

@@ -0,0 +1,17 @@
+module SocialNetworking
+  # A question that is posed to participants when a profile is being created or
+  # updated.
+  class ProfileAnswer < ActiveRecord::Base
+    belongs_to :profile,
+               class_name: "SocialNetworking::Profile",
+               foreign_key: :social_networking_profile_id
+    belongs_to :profile_question,
+               class_name: "SocialNetworking::ProfileQuestion",
+               foreign_key: :social_networking_profile_question_id
+
+    validates :profile, :profile_question, presence: true
+    validates :social_networking_profile_question_id, uniqueness: {
+      scope: :social_networking_profile_id, message: "has already been answered"
+    }
+  end
+end

data/app/models/social_networking/profile_question.rb

@@ -0,0 +1,14 @@
+module SocialNetworking
+  # A question that is posed to participants when a profile is being created or
+  # updated.
+  class ProfileQuestion < ActiveRecord::Base
+    belongs_to :group,
+               class_name: "ThinkFeelDoEngine::Group",
+               foreign_key: :group_id
+
+    has_many :profile_answers,
+             class_name: "SocialNetworking::ProfileAnswer",
+             foreign_key: :social_networking_profile_question_id,
+             dependent: :destroy
+  end
+end

data/app/models/social_networking/reports/comment.rb

@@ -0,0 +1,31 @@
+module SocialNetworking
+  module Reports
+    # Scenario: a Participant comments on a feed item.
+    class Comment
+      def self.columns
+        %w( participant_id occurred_at item_type text )
+      end
+
+      def self.all
+        Participant.select(:id, :study_id).map do |participant|
+          ::SocialNetworking::Comment
+            .where(participant_id: participant.id).map do |comment|
+              item = (comment.item.try(:item) || comment.item)
+              next if item.nil?
+
+              {
+                participant_id: participant.study_id,
+                occurred_at: comment.created_at.iso8601,
+                item_type: item.class.to_s,
+                text: comment.text
+              }
+            end
+        end.flatten.compact
+      end
+
+      def self.to_csv
+        ThinkFeelDoEngine::Reports::Reporter.new(self).write_csv
+      end
+    end
+  end
+end