social_networking 0.9.3

data/app/controllers/social_networking/comments_controller.rb

@@ -0,0 +1,73 @@
+require_dependency "social_networking/application_controller"
+
+module SocialNetworking
+  # Manage Comments.
+  class CommentsController < ApplicationController
+    rescue_from ActiveRecord::RecordNotFound, with: :record_not_found
+
+    def create
+      @comment = Comment.new(sanitized_params)
+
+      if @comment.save
+        set_recipient
+        build_notification.notify
+        render json: Serializers::CommentSerializer.new(@comment).to_serialized
+      else
+        render json: { error: model_errors }, status: 400
+      end
+    end
+
+    private
+
+    def record_not_found
+      render json: { error: "not found" }, status: 404
+    end
+
+    def sanitized_params
+      s_params = { participant_id: current_participant.id }
+      [:itemId, :itemType, :text].each do |param|
+        unless params[param].nil?
+          s_params[param.to_s.underscore.to_sym] = params[param]
+        end
+      end
+
+      s_params
+    end
+
+    def model_errors
+      @comment.errors.full_messages.join(", ")
+    end
+
+    def build_notification
+      Notification.new(
+        current_participant: current_participant,
+        mailer: Mailer,
+        recipient: @recipient,
+        message_body: message_body,
+        subject: "You received a COMMENT on "\
+          "#{t('application_name', default: 'ThinkFeelDo')}")
+    end
+
+    def set_recipient
+      if @comment.item_type == "SocialNetworking::SharedItem"
+        comment_item_participant_id =
+          SharedItem.find(@comment.item_id).item_type.constantize
+          .find(@comment.item.item_id).participant_id
+        @recipient = Participant.find(comment_item_participant_id)
+      else
+        @recipient = Participant
+                     .find(@comment.item_type.constantize
+                     .find(@comment.item_id).participant_id)
+      end
+    end
+
+    def message_body
+      profile_url = social_networking_profile_url
+
+      ["You've sparked some activity! Log in [#{profile_url}] to see \
+who commented on your post.",
+       "Someone commented on your post! Log in [#{profile_url}] to\
+ learn more."].sample
+    end
+  end
+end

data/app/controllers/social_networking/concerns/invalid_auth_token.rb

@@ -0,0 +1,21 @@
+module SocialNetworking
+  module Concerns
+    # Rescues exception when authenticity token has expired
+    module InvalidAuthToken
+      extend ActiveSupport::Concern
+
+      included do
+        rescue_from ActionController::InvalidAuthenticityToken,
+                    with: :invalid_auth_token_redirect
+      end
+
+      private
+
+      def invalid_auth_token_redirect
+        redirect_to "/",
+                    alert: "Your authenticity token expired. "\
+                           "Please try again."
+      end
+    end
+  end
+end

data/app/controllers/social_networking/concerns/profile_page/feed.rb

@@ -0,0 +1,72 @@
+module SocialNetworking
+  module Concerns
+    module ProfilePage
+      # Displays feed data for profile page.
+      class Feed
+        attr_reader :participant_id, :page
+        SHARED_ITEM_PAGE_SIZE = 5
+
+        def initialize(participant_id:, page:)
+          @participant_id = participant_id
+          @page = page.try(:to_i) || 0
+        end
+
+        def page_items
+          if feed_items.size >= start_index
+            sorted_feed_items[
+              start_index..(start_index + SHARED_ITEM_PAGE_SIZE - 1)
+            ]
+          else
+            []
+          end
+        end
+
+        private
+
+        def feed_items
+          on_the_mind_statements + nudges + shared_items
+        end
+
+        def nudges
+          Serializers::NudgeSerializer
+            .from_collection(
+              Nudge
+                .where(initiator_id: participant_id)
+                .order(created_at: :desc)
+                .limit(SHARED_ITEM_PAGE_SIZE * (page + 1))
+                .includes(:comments))
+        end
+
+        def on_the_mind_statements
+          Serializers::OnTheMindStatementSerializer
+            .from_collection(
+              OnTheMindStatement
+                .where(participant_id: participant_id)
+                .order(created_at: :desc)
+                .limit(SHARED_ITEM_PAGE_SIZE * (page + 1))
+                .includes(:comments, :likes))
+        end
+
+        def shared_items
+          Serializers::SharedItemSerializer
+            .from_collection(
+              SharedItem
+                .includes(:item, :comments)
+                .joins(:participant)
+                .where(participant_id: participant_id)
+                .order(created_at: :desc)
+                .limit(SHARED_ITEM_PAGE_SIZE * (page + 1))
+            )
+        end
+
+        def sorted_feed_items
+          feed_items.sort_by { |item| item[:createdAtRaw] }.reverse!
+        end
+
+        def start_index
+          page * SHARED_ITEM_PAGE_SIZE
+        end
+      end
+    end
+  end
+end

data/app/controllers/social_networking/concerns/show_feed.rb

@@ -0,0 +1,44 @@
+module SocialNetworking
+  module Concerns
+    # Collects data for feed/profiles page.
+    module ShowFeed
+      def feed_data_for(participant, context)
+        @participant = participant
+        @context = context
+
+        {
+          action_items: action_items,
+          feed_items: [],
+          member_profiles: member_profiles,
+          profile_path: @context.social_networking_profile_path
+        }
+      end
+
+      private
+
+      def active_group
+        @participant.active_group
+      end
+
+      def action_items
+        items = ActionItem.for(@participant)
+        current_profile = Profile.find_by_participant_id(@participant.id)
+        unless current_profile.try(:started?)
+          items.unshift(
+            link: @context.social_networking_profile_path,
+            label: "Create a Profile"
+          )
+        end
+
+        items
+      end
+
+      def member_profiles
+        return unless active_group
+        Serializers::ProfileSerializer.from_collection(
+          Profile.where(
+            participant_id: active_group.active_participants.pluck(:id)))
+      end
+    end
+  end
+end

data/app/controllers/social_networking/goals_controller.rb

@@ -0,0 +1,83 @@
+require_dependency "social_networking/application_controller"
+
+module SocialNetworking
+  # Manage Goals.
+  class GoalsController < ApplicationController
+    rescue_from ActiveRecord::RecordNotFound, with: :record_not_found
+
+    def tool
+      goals = Goal.where(participant_id: current_participant.id)
+      render template: "social_networking/goals/tool",
+             locals: {
+               goals: Serializers::GoalSerializer.from_collection(goals)
+             }
+    end
+
+    def index
+      goals = Goal.where(participant_id: current_participant.id)
+
+      render json: Serializers::GoalSerializer.from_collection(goals)
+    end
+
+    def create
+      @goal = Goal.new(sanitized_params)
+
+      if @goal.save
+        SharedItem.create(item: @goal, action_type: Goal::Actions.created)
+        render json: Serializers::GoalSerializer.new(@goal).to_serialized
+      else
+        render json: { error: model_errors }, status: 400
+      end
+    end
+
+    def update
+      @goal = Goal.where(
+        participant_id: current_participant.id,
+        id: params[:id]
+      ).first || fail(ActiveRecord::RecordNotFound)
+
+      if @goal.update(sanitized_params)
+        if @is_completed_set
+          SharedItem.create(item: @goal, action_type: Goal::Actions.completed)
+        end
+        render json: Serializers::GoalSerializer.new(@goal).to_serialized
+      else
+        render json: { error: model_errors }, status: 400
+      end
+    end
+
+    private
+
+    def record_not_found
+      render json: { error: "not found" }, status: 404
+    end
+
+    def sanitized_params
+      s_params = { participant_id: current_participant.id }
+      [:description, :isCompleted, :isDeleted, :dueOn].each do |param|
+        unless params[param].nil?
+          s_params[param.to_s.underscore.to_sym] = params[param]
+        end
+      end
+      transform_goal_params(s_params)
+    end
+
+    def model_errors
+      @goal.errors.full_messages.join(", ")
+    end
+
+    def transform_goal_params(params)
+      if true == params[:is_completed]
+        params[:completed_at] = DateTime.now
+        @is_completed_set = true
+      end
+      if true == params[:is_deleted]
+        params[:deleted_at] = DateTime.now
+        @is_deleted_set = true
+      end
+      params.delete(:is_completed)
+      params.delete(:is_deleted)
+      params
+    end
+  end
+end

data/app/controllers/social_networking/homes_controller.rb

@@ -0,0 +1,12 @@
+require_dependency "social_networking/application_controller"
+
+module SocialNetworking
+  # Provide Participant home page tools.
+  class HomesController < ApplicationController
+    include Concerns::ShowFeed
+
+    def show
+      render locals: feed_data_for(current_participant, self)
+    end
+  end
+end

data/app/controllers/social_networking/likes_controller.rb

@@ -0,0 +1,76 @@
+require_dependency "social_networking/application_controller"
+
+module SocialNetworking
+  # Manage Likes.
+  class LikesController < ApplicationController
+    rescue_from ActiveRecord::RecordNotFound, with: :record_not_found
+
+    def create
+      @like = Like.new(sanitized_params)
+
+      if @like.save
+        set_recipient
+        build_notification.notify
+        render json: Serializers::LikeSerializer.new(@like).to_serialized
+      else
+        render json: { error: model_errors }, status: 400
+      end
+    end
+
+    private
+
+    def record_not_found
+      render json: { error: "not found" }, status: 404
+    end
+
+    def sanitized_params
+      s_params = { participant_id: current_participant.id }
+      [:itemId, :itemType].each do |param|
+        unless params[param].nil?
+          s_params[param.to_s.underscore.to_sym] = params[param]
+        end
+      end
+
+      s_params
+    end
+
+    def set_recipient
+      if @like.item_type == "SocialNetworking::SharedItem"
+        like_item_participant_id =
+          SharedItem.find(@like.item_id).item_type.constantize
+          .find(@like.item.item_id).participant_id
+        @recipient = Participant.find(like_item_participant_id)
+      else
+        @recipient = Participant
+                     .find(@like.item_type.constantize
+                     .find(@like.item_id).participant_id)
+      end
+    end
+
+    def model_errors
+      @like.errors.full_messages.join(", ")
+    end
+
+    def message_body
+      profile_url = social_networking_profile_url
+
+      [
+        "Someone liked your post! " \
+        "Log in (#{profile_url}) to see who.",
+        "People like what you're doing! " \
+        "Log in (#{profile_url}) " \
+        "to see what's happening!"
+      ].sample
+    end
+
+    def build_notification
+      Notification.new(
+        current_participant: current_participant,
+        mailer: Mailer,
+        recipient: @recipient,
+        message_body: message_body,
+        subject: "Someone LIKED what you did on "\
+        "#{t('application_name', default: 'ThinkFeelDo')}")
+    end
+  end
+end

data/app/controllers/social_networking/nudges_controller.rb

@@ -0,0 +1,64 @@
+require_dependency "social_networking/application_controller"
+
+# Controller used to Manage Nudges.
+module SocialNetworking
+  # Manage Nudges.
+  class NudgesController < ApplicationController
+    before_action :set_recipient
+
+    def index
+      @nudges = Nudge.search(sanitized_params[:recipient_id])
+      render json: Serializers::NudgeSerializer.from_collection(@nudges)
+    end
+
+    def create
+      @nudge = Nudge.new(sanitized_params)
+
+      if @nudge.save
+        build_notification.notify
+        render json: { message: "Nudge sent!" }
+      else
+        render json: { error: model_errors }, status: 400
+      end
+    end
+
+    private
+
+    def sanitized_params
+      {
+        initiator_id: current_participant.id,
+        recipient_id: params[:recipientId]
+      }
+    end
+
+    def model_errors
+      @nudge.errors.full_messages.join(", ")
+    end
+
+    def build_notification
+      Notification.new(
+        current_participant: current_participant,
+        mailer: Mailer,
+        recipient: @recipient,
+        message_body: message_body,
+        subject: "You've been NUDGED on "\
+          "#{t('application_name', default: 'ThinkFeelDo')}")
+    end
+
+    def message_body
+      profile_url = social_networking_profile_url
+      ["You've been nudged by #{current_participant.display_name}! Log \
+in (#{profile_url}) to view details.",
+       "#{current_participant.display_name} just nudged you! Log in \
+(#{profile_url}) to view your nudge!",
+       "Hey! #{current_participant.display_name} nudged you! Don't leave \
+them hanging - log in (#{profile_url}) to say hi!",
+       "Psst - you've been nudged by #{current_participant.display_name}! \
+Log in (#{profile_url}) to support a fellow group member!"].sample
+    end
+
+    def set_recipient
+      @recipient = Participant.find(sanitized_params[:recipient_id])
+    end
+  end
+end

data/app/controllers/social_networking/on_the_mind_statements_controller.rb

@@ -0,0 +1,30 @@
+require_dependency "social_networking/application_controller"
+
+module SocialNetworking
+  # Manage OnTheMindStatements.
+  class OnTheMindStatementsController < ApplicationController
+    def create
+      @on_the_mind_statement = OnTheMindStatement.new(sanitized_params)
+
+      if @on_the_mind_statement.save
+        render json: Serializers::OnTheMindStatementSerializer
+          .new(@on_the_mind_statement).to_serialized
+      else
+        render json: { error: model_errors }, status: 400
+      end
+    end
+
+    private
+
+    def sanitized_params
+      {
+        participant_id: current_participant.id,
+        description: params[:description]
+      }
+    end
+
+    def model_errors
+      @on_the_mind_statement.errors.full_messages.join(", ")
+    end
+  end
+end

data/app/controllers/social_networking/participants_controller.rb

@@ -0,0 +1,28 @@
+require_dependency "social_networking/application_controller"
+
+module SocialNetworking
+  # Manage Participants.
+  class ParticipantsController < ApplicationController
+    rescue_from ActiveRecord::RecordNotFound, with: :record_not_found
+
+    def index
+      participants = Participant.all
+
+      render json: Serializers::ParticipantSerializer
+        .from_collection(participants)
+    end
+
+    def show
+      participant = Participant.find(params[:id])
+
+      render json: Serializers::ParticipantSerializer.new(participant)
+        .to_serialized
+    end
+
+    private
+
+    def record_not_found
+      render json: { error: "participant not found" }, status: 404
+    end
+  end
+end

data/app/controllers/social_networking/profile_answers_controller.rb

@@ -0,0 +1,79 @@
+require_dependency "social_networking/application_controller"
+
+module SocialNetworking
+  # Manage Participants.
+  class ProfileAnswersController < ApplicationController
+    rescue_from ActiveRecord::RecordNotFound, with: :record_not_found
+
+    def index
+      if !profile_answer_params[:profile_id].blank? &&
+         !profile_answer_params[:profile_question_id].blank?
+
+        answer = ProfileAnswer.where(
+          social_networking_profile_id:
+            profile_answer_params[:profile_id],
+          social_networking_profile_question_id:
+            profile_answer_params[:profile_question_id]).first
+      end
+
+      if answer
+        render json:
+          Serializers::ProfileAnswerSerializer.new(answer).to_serialized
+      else
+        render json: {}, status: 404
+      end
+    end
+
+    def show
+    end
+
+    def create
+      profile_id = current_participant.social_networking_profile.try(:id)
+      @profile_answer = ProfileAnswer
+                        .new(social_networking_profile_id: profile_id,
+                             social_networking_profile_question_id:
+                               profile_answer_params[:profile_question_id],
+                             answer_text: profile_answer_params[:answer_text])
+
+      if @profile_answer.save
+        render json: Serializers::ProfileAnswerSerializer
+          .new(@profile_answer).to_serialized
+      else
+        render json: { error: model_errors }, status: 400
+      end
+    end
+
+    def update
+      @profile_answer = current_participant
+                        .social_networking_profile
+                        .profile_answers
+                        .where(id: profile_answer_params[:id]).first! ||
+                        fail(ActiveRecord::RecordNotFound)
+
+      if @profile_answer
+         .update(answer_text: profile_answer_params[:answer_text])
+        render json: Serializers::ProfileAnswerSerializer
+          .new(@profile_answer).to_serialized
+      else
+        render json: { error: model_errors }, status: 400
+      end
+    end
+
+    private
+
+    def profile_answer_params
+      params.permit(:profile_id,
+                    :profile_question_id,
+                    :id, :answer_text,
+                    :profile_answer)
+    end
+
+    def model_errors
+      @profile_answer.errors.full_messages.join(", ")
+    end
+
+    def record_not_found
+      render json: { error: "profile not found" }, status: 404
+    end
+  end
+end

data/app/controllers/social_networking/profile_icon_controller.rb

@@ -0,0 +1,26 @@
+require_dependency "social_networking/application_controller"
+
+module SocialNetworking
+  # Manage profile icons.
+  class ProfileIconController < ApplicationController
+    skip_before_action :verify_authenticity_token
+
+    def save
+      profile = Profile.find(profile_icon_params[:profile_id])
+      profile.icon_name = profile_icon_params[:icon_name]
+      profile.save
+
+      respond_to do |format|
+        format.html { render nothing: true, status: :accepted }
+        format.js   { render nothing: true, status: :accepted }
+        format.json { render nothing: true, status: :accepted }
+      end
+    end
+
+    private
+
+    def profile_icon_params
+      params.require(:profile).permit(:profile_id, :icon_name)
+    end
+  end
+end

data/app/controllers/social_networking/profile_pages_controller.rb

@@ -0,0 +1,87 @@
+require_dependency "social_networking/application_controller"
+
+module SocialNetworking
+  # Manage Participants.
+  class ProfilePagesController < ApplicationController
+    include Concerns::ProfilePage
+    rescue_from ActiveRecord::RecordNotFound, with: :record_not_found
+    before_action :set_current_profile,
+                  :set_profile_questions,
+                  :set_profile_icon_names,
+                  :set_navigation_status_context
+    def index
+    end
+
+    def show
+      store_nudge_initiators(@profile.participant_id)
+      set_member_profiles
+    end
+
+    def page
+      render json: { feedItems: feed.page_items }
+    end
+
+    private
+
+    def feed
+      Concerns::ProfilePage::Feed.new(
+        participant_id: profile_page_params[:participant_id],
+        page: profile_page_params[:page])
+    end
+
+    def profile_page_params
+      params
+        .permit(:id, :participant_id, :page)
+    end
+
+    def active_group
+      current_participant.active_group
+    end
+
+    def set_navigation_status_context
+      current_participant.navigation_status.context = nil
+    end
+
+    def set_member_profiles
+      return unless active_group
+      @member_profiles = Serializers::ProfileSerializer.from_collection(
+        Profile.where(
+          participant_id: active_group.active_participants.pluck(:id)))
+    end
+
+    def set_current_profile
+      if profile_id
+        @profile = Profile.find(profile_id)
+      else
+        @profile = Profile
+                   .find_or_initialize_by(
+                     participant_id: current_participant.id)
+        @profile.update_attributes(active: true)
+      end
+    end
+
+    def store_nudge_initiators(participant_id)
+      @nudging_display_names =  Nudge
+                                .search(participant_id)
+                                .map { |nudge| nudge.initiator.display_name }
+    end
+
+    def set_profile_questions
+      @profile_questions = current_participant
+                           .active_group
+                           .social_networking_profile_questions
+    end
+
+    def record_not_found
+      render json: { error: "profile not found" }, status: 404
+    end
+
+    def profile_id
+      profile_page_params[:id]
+    end
+
+    def set_profile_icon_names
+      @profile_icons = Profile.icon_names
+    end
+  end
+end