socializer 0.1.13

data/app/controllers/socializer/activities_controller.rb

@@ -0,0 +1,84 @@
+module Socializer
+  class ActivitiesController < ApplicationController
+    def index
+      @activities = Activity.stream(provider: params[:provider], actor_id: params[:id], viewer_id: current_user.id)
+      @current_id = nil
+      if params[:provider] == 'circles'
+        @circle = Circle.find(params[:id])
+        @title = @circle.name
+        @current_id = @circle.guid
+      elsif params[:provider] == 'people'
+        @person = Person.find(params[:id])
+        @title = @person.display_name
+        @current_id = @person.guid
+      elsif params[:provider] == 'groups'
+        @group = Group.find(params[:id])
+        @title = @group.name
+        @current_id = @group.guid
+      else
+        @title = 'Activity stream'
+      end
+    end
+
+    def audience
+      activities = Activity.stream(provider: 'activities', actor_id: params[:id], viewer_id: current_user.id)
+
+      @object_ids = []
+      is_public = false
+
+      activities.each do |activity|
+        activity.audiences.each do |audience|
+          # In case of CIRCLES audience, add each contacts of every circles
+          # of the actor of the activity.
+          if audience.privacy_level.public?
+            @object_ids.push audience.privacy_level
+            is_public = true
+          elsif audience.privacy_level.circles?
+            activity.actor.circles.each do |circle|
+              circle.activity_contacts.each do |contact|
+                @object_ids.push contact
+              end
+            end
+          else
+            if audience.activity_object.activitable_type == 'Socializer::Circle'
+              # In the case of LIMITED audience, then go through all the audience
+              # circles and add contacts from those circles in the list of allowed
+              # audience.
+              audience.activity_object.activitable.activity_contacts.each do |contact|
+                @object_ids.push contact
+              end
+            else
+              # Otherwise, the target audience is either a group or a person,
+              # which means we can add it as it is in the audience list.
+              @object_ids.push audience.activity_object
+            end
+          end
+        end
+      end
+
+      unless is_public
+        activities.each do |activity|
+          # The actor of the activity is always part of the audience.
+          @object_ids.push activity.activitable_actor
+        end
+      end
+
+      # Remove any duplicates from the list. It can happen when, for example, someone
+      # post a message to itself.
+      @object_ids.uniq!
+
+      respond_to do |format|
+        format.html { render layout: false if request.xhr? }
+      end
+    end
+
+    def destroy
+      @activity = Activity.find(params[:id])
+      @activity_guid = @activity.guid
+      @activity.destroy
+      respond_to do |format|
+        format.js
+      end
+    end
+  end
+end

data/app/controllers/socializer/application_controller.rb

@@ -0,0 +1,37 @@
+module Socializer
+  class ApplicationController < ActionController::Base
+    # Prevent CSRF attacks by raising an exception.
+    # For APIs, you may want to use :null_session instead.
+    # FIXME: Not sure why protect_from_forgery is no longer working
+    # protect_from_forgery with: :exception
+
+    helper_method :current_user
+    helper_method :signed_in?
+
+    before_action :set_locale
+
+    private
+
+    def current_user
+      @current_user ||= Person.find_by(id: cookies[:user_id]) if cookies[:user_id].present?
+    end
+
+    def signed_in?
+      current_user.present?
+    end
+
+    def set_locale
+      if signed_in? && current_user.language.present? && params[:locale].nil?
+        I18n.locale =  current_user.language
+      else
+        I18n.locale =  params[:locale] || extract_locale_from_accept_language_header || I18n.default_locale
+      end
+    end
+
+    def extract_locale_from_accept_language_header
+      if request.present? && request.env['HTTP_ACCEPT_LANGUAGE'].present?
+        request.env['HTTP_ACCEPT_LANGUAGE'].scan(/^[a-z]{2}/).first
+      end
+    end
+  end
+end

data/app/controllers/socializer/audiences_controller.rb

@@ -0,0 +1,30 @@
+module Socializer
+  class AudiencesController < ApplicationController
+    def index
+      if params[:q].present? && params[:q].size > 0
+        query_value = "%#{params[:q]}%"
+
+        @people = Person.where { display_name.like query_value }
+        @circles = current_user.circles.where { name.like query_value }
+        @groups = current_user.groups.where { name.like query_value }
+      else
+        @people = []
+        @circles = current_user.circles
+        @groups = current_user.groups
+      end
+
+      public  = Socializer::Audience.privacy_level.find_value(:public)
+      circles = Socializer::Audience.privacy_level.find_value(:circles)
+
+      @audiences = [id: public.value, name: public.text] +
+                   [id: circles.value, name: circles.text] +
+                   @people.map { |x| { id: x.guid, name: x.display_name } } +
+                   @circles.map { |x| { id: x.guid, name: x.name } } +
+                   @groups.map { |x| { id: x.guid, name: x.name } }
+
+      respond_to do |format|
+        format.json { render json: @audiences }
+      end
+    end
+  end
+end

data/app/controllers/socializer/authentications_controller.rb

@@ -0,0 +1,13 @@
+module Socializer
+  class AuthenticationsController < ApplicationController
+    def index
+      @authentications = current_user.services
+    end
+
+    def destroy
+      @authentication = current_user.authentications.find(params[:id])
+      @authentication.destroy
+      redirect_to authentications_path
+    end
+  end
+end

data/app/controllers/socializer/circles_controller.rb

@@ -0,0 +1,54 @@
+module Socializer
+  class CirclesController < ApplicationController
+    before_filter :set_circle, only: [:show, :edit, :update, :destroy]
+
+    def index
+      @circles = current_user.circles
+    end
+
+    def contacts
+      @circles = current_user.circles
+    end
+
+    def contact_of
+      @circles = current_user.circles
+    end
+
+    def find_people
+      @circles = current_user.circles
+    end
+
+    def show
+      @users = Person.all
+    end
+
+    def new
+      @circle = Circle.new
+    end
+
+    def create
+      @circle = current_user.circles.build(params[:circle])
+      @circle.save!
+      redirect_to circles_contacts_path
+    end
+
+    def edit
+    end
+
+    def update
+      @circle.update!(params[:circle])
+      redirect_to @circle
+    end
+
+    def destroy
+      @circle.destroy
+      redirect_to circles_contacts_path
+    end
+
+    private
+
+    def set_circle
+      @circle = current_user.circles.find(params[:id])
+    end
+  end
+end

data/app/controllers/socializer/comments_controller.rb

@@ -0,0 +1,37 @@
+module Socializer
+  class CommentsController < ApplicationController
+    before_filter :set_comment, only: [:edit, :update, :destroy]
+
+    def new
+      @comment = Comment.new
+    end
+
+    def create
+      @comment = current_user.comments.build(params[:comment])
+      @comment.activity_verb = 'add'
+      # TODO: Is scope needed? Try commenting it out to see what happens
+      @comment.scope = Audience.privacy_level.find_value(:public)
+      @comment.save!
+      redirect_to stream_path
+    end
+
+    def edit
+    end
+
+    def update
+      @comment.update!(params[:comment])
+      redirect_to stream_path
+    end
+
+    def destroy
+      @comment.destroy
+      redirect_to stream_path
+    end
+
+    private
+
+    def set_comment
+      @comment = current_user.comments.find(params[:id])
+    end
+  end
+end

data/app/controllers/socializer/groups_controller.rb

@@ -0,0 +1,70 @@
+module Socializer
+  class GroupsController < ApplicationController
+    before_filter :set_group, only: [:edit, :update, :destroy]
+
+    def index
+    end
+
+    def public
+      @groups = Socializer::Group.public
+    end
+
+    def restricted
+      @groups = Socializer::Group.restricted
+    end
+
+    def joinable
+      @groups = Socializer::Group.joinable
+    end
+
+    def memberships
+      @memberships = current_user.memberships
+    end
+
+    def ownerships
+      @ownerships = current_user.groups
+    end
+
+    def pending_invites
+      @pending_invites = current_user.pending_memberships_invites
+    end
+
+    def show
+      @group = Group.find(params[:id])
+      @membership = Membership.find_by(group_id: @group.id)
+    end
+
+    def new
+      @group = Group.new
+    end
+
+    def create
+      @group = current_user.groups.build(params[:group])
+
+      if @group.save
+        redirect_to @group
+      else
+        render :new
+      end
+    end
+
+    def edit
+    end
+
+    def update
+      @group.update!(params[:group])
+      redirect_to @group
+    end
+
+    def destroy
+      @group.destroy
+      redirect_to groups_path
+    end
+
+    private
+
+    def set_group
+      @group = current_user.groups.find(params[:id])
+    end
+  end
+end

data/app/controllers/socializer/likes_controller.rb

@@ -0,0 +1,50 @@
+module Socializer
+  class LikesController < ApplicationController
+    before_action :set_likable, only: [:create, :destroy]
+
+    # REFACTOR: should handle activity/tooltip as well as people likes
+    # Used to display the Like tooltip
+    def index
+      activity = Activity.find(params[:id])
+      @object_ids = []
+
+      activity.activity_object.likes.each do |person|
+        @object_ids.push person.activity_object
+      end
+
+      respond_to do |format|
+        format.html { render layout: false if request.xhr? }
+      end
+    end
+
+    def create
+      @likable.like!(current_user) unless current_user.likes?(@likable)
+      @activity = @likable.activitable
+
+      respond_to do |format|
+        format.js
+      end
+    end
+
+    def destroy
+      @likable.unlike!(current_user) if current_user.likes?(@likable)
+      @activity = @likable.activitable
+
+      respond_to do |format|
+        format.js
+      end
+    end
+
+    private
+
+    # Use callbacks to share common setup or constraints between actions.
+    def set_likable
+      @likable = ActivityObject.find(params[:id])
+    end
+
+      # # Never trust parameters from the scary internet, only allow the white list through.
+      # def like_params
+      #   params.require(:like).permit(:actor_id, :activity_object_id)
+      # end
+  end
+end

data/app/controllers/socializer/memberships_controller.rb

@@ -0,0 +1,46 @@
+module Socializer
+  class MembershipsController < ApplicationController
+    before_filter :set_membership, only: [:approve, :confirm, :decline]
+
+    def create
+      @group = Group.find(params[:membership][:group_id])
+      @group.join(current_user)
+      redirect_to @group
+    end
+
+    def destroy
+      @membership = current_user.memberships.find(params[:id])
+      @group = @membership.group
+      @group.leave(current_user)
+      redirect_to @group
+    end
+
+    def approve
+      @membership.approve!
+      redirect_to @membership.group
+    end
+
+    def invite
+      invited_user = Person.find(params[:user_id])
+      group = Group.find(params[:group_id])
+      group.invite(invited_user)
+      redirect_to group
+    end
+
+    def confirm
+      @membership.confirm!
+      redirect_to @membership.group
+    end
+
+    def decline
+      @membership.decline!
+      redirect_to groups_pending_invites_path
+    end
+
+    private
+
+    def set_membership
+      @membership = Membership.find(params[:id])
+    end
+  end
+end

data/app/controllers/socializer/notes_controller.rb

@@ -0,0 +1,43 @@
+module Socializer
+  class NotesController < ApplicationController
+    before_filter :set_note, only: [:edit, :update, :destroy]
+
+    def new
+      @note = Note.new
+      @current_id = params[:id]
+    end
+
+    def create
+      @note = current_user.activity_object.notes.build(params[:note])
+      @note.object_ids = @note.object_ids.split(',')
+      @note.activity_verb = 'post'
+      @note.save!
+      @activity = Activity.find_by(activity_object_id: @note.guid)
+      respond_to do |format|
+        format.js
+      end
+    end
+
+    def edit
+    end
+
+    def update
+      @note.update!(params[:note])
+      redirect_to stream_path
+    end
+
+    def destroy
+      @activity_guid = Activity.find_by(activity_object_id: @note.guid).guid
+      @note.destroy
+      respond_to do |format|
+        format.js
+      end
+    end
+
+    private
+
+    def set_note
+      @note = current_user.activity_object.notes.find(params[:id])
+    end
+  end
+end