socializer 0.1.13

data/app/controllers/socializer/notifications_controller.rb

@@ -0,0 +1,29 @@
+module Socializer
+  class NotificationsController < ApplicationController
+    after_filter :reset_unread_notifications, only: [:index]
+
+    def index
+      @notifications = current_user.received_notifications
+    end
+
+    def show
+      n = Notification.find(params[:id])
+      read_notification(n) unless n.read?
+      redirect_to stream_path(provider: :activities, id: n.activity.id)
+    end
+
+    private
+
+    def read_notification(notification)
+      notification.read = true
+      notification.save!
+    end
+
+    def reset_unread_notifications
+      if current_user.activity_object.unread_notifications_count > 0
+        current_user.activity_object.unread_notifications_count = 0
+        current_user.activity_object.save!
+      end
+    end
+  end
+end

data/app/controllers/socializer/pages_controller.rb

@@ -0,0 +1,7 @@
+module Socializer
+  class PagesController < ApplicationController
+    def index
+      redirect_to stream_path if signed_in?
+    end
+  end
+end

data/app/controllers/socializer/people_controller.rb

@@ -0,0 +1,37 @@
+module Socializer
+  class PeopleController < ApplicationController
+    before_filter :set_person, only: [:show, :likes, :message]
+
+    def index
+      @people = Person.all
+    end
+
+    def show
+    end
+
+    def edit
+      @person = current_user
+    end
+
+    def update
+      current_user.update!(params[:person])
+      redirect_to current_user
+    end
+
+    # TODO: Should be handled by the likes controller.
+    # Used to display the likes in the user profile
+    def likes
+      @likes = @person.likes
+    end
+
+    def message
+      @current_id = @person.guid
+    end
+
+    private
+
+    def set_person
+      @person = Person.find(params[:id])
+    end
+  end
+end

data/app/controllers/socializer/person_addresses_controller.rb

@@ -0,0 +1,27 @@
+module Socializer
+  class PersonAddressesController < ApplicationController
+    before_filter :set_person_address, only: [:update, :destroy]
+
+    def create
+      @person_address = current_user.adresses.build(params[:person_address])
+      @person_address.save!
+      redirect_to current_user
+    end
+
+    def update
+      @person_address.update!(params[:person_address])
+      redirect_to current_user
+    end
+
+    def destroy
+      @person_address.destroy
+      redirect_to current_user
+    end
+
+    private
+
+    def set_person_address
+      @person_address = current_user.addresses.find(params[:id])
+    end
+  end
+end

data/app/controllers/socializer/person_contributions_controller.rb

@@ -0,0 +1,27 @@
+module Socializer
+  class PersonContributionsController < ApplicationController
+    before_filter :set_person_contribution, only: [:update, :destroy]
+
+    def create
+      @person_contribution = current_user.adresses.build(params[:person_contribution])
+      @person_contribution.save!
+      redirect_to current_user
+    end
+
+    def update
+      @person_contribution.update!(params[:person_contribution])
+      redirect_to current_user
+    end
+
+    def destroy
+      @person_contribution.destroy
+      redirect_to current_user
+    end
+
+    private
+
+    def set_person_contribution
+      @person_contribution = current_user.contributions.find(params[:id])
+    end
+  end
+end

data/app/controllers/socializer/person_educations_controller.rb

@@ -0,0 +1,27 @@
+module Socializer
+  class PersonEducationsController < ApplicationController
+    before_filter :set_person_education, only: [:update, :destroy]
+
+    def create
+      @person_education = current_user.adresses.build(params[:person_education])
+      @person_education.save!
+      redirect_to current_user
+    end
+
+    def update
+      @person_education.update!(params[:person_education])
+      redirect_to current_user
+    end
+
+    def destroy
+      @person_education.destroy
+      redirect_to current_user
+    end
+
+    private
+
+    def set_person_education
+      @person_education = current_user.educations.find(params[:id])
+    end
+  end
+end

data/app/controllers/socializer/person_employments_controller.rb

@@ -0,0 +1,27 @@
+module Socializer
+  class PersonEmploymentsController < ApplicationController
+    before_filter :set_person_employment, only: [:update, :destroy]
+
+    def create
+      @person_employment = current_user.adresses.build(params[:person_employment])
+      @person_employment.save!
+      redirect_to current_user
+    end
+
+    def update
+      @person_employment.update!(params[:person_employment])
+      redirect_to current_user
+    end
+
+    def destroy
+      @person_employment.destroy
+      redirect_to current_user
+    end
+
+    private
+
+    def set_person_employment
+      @person_employment = current_user.employments.find(params[:id])
+    end
+  end
+end

data/app/controllers/socializer/person_links_controller.rb

@@ -0,0 +1,27 @@
+module Socializer
+  class PersonLinksController < ApplicationController
+    before_filter :set_person_link, only: [:update, :destroy]
+
+    def create
+      @person_link = current_user.adresses.build(params[:person_link])
+      @person_link.save!
+      redirect_to current_user
+    end
+
+    def update
+      @person_link.update!(params[:person_link])
+      redirect_to current_user
+    end
+
+    def destroy
+      @person_link.destroy
+      redirect_to current_user
+    end
+
+    private
+
+    def set_person_link
+      @person_link = current_user.links.find(params[:id])
+    end
+  end
+end

data/app/controllers/socializer/person_phones_controller.rb

@@ -0,0 +1,27 @@
+module Socializer
+  class PersonPhonesController < ApplicationController
+    before_filter :set_person_phone, only: [:update, :destroy]
+
+    def create
+      @person_phone = current_user.adresses.build(params[:person_phone])
+      @person_phone.save!
+      redirect_to current_user
+    end
+
+    def update
+      @person_phone.update!(params[:person_phone])
+      redirect_to current_user
+    end
+
+    def destroy
+      @person_phone.destroy
+      redirect_to current_user
+    end
+
+    private
+
+    def set_person_phone
+      @person_phone = current_user.phones.find(params[:id])
+    end
+  end
+end

data/app/controllers/socializer/person_places_controller.rb

@@ -0,0 +1,27 @@
+module Socializer
+  class PersonPlacesController < ApplicationController
+    before_filter :set_person_place, only: [:update, :destroy]
+
+    def create
+      @person_place = current_user.adresses.build(params[:person_place])
+      @person_place.save!
+      redirect_to current_user
+    end
+
+    def update
+      @person_place.update!(params[:person_place])
+      redirect_to current_user
+    end
+
+    def destroy
+      @person_place.destroy
+      redirect_to current_user
+    end
+
+    private
+
+    def set_person_place
+      @person_place = current_user.places.find(params[:id])
+    end
+  end
+end

data/app/controllers/socializer/person_profiles_controller.rb

@@ -0,0 +1,27 @@
+module Socializer
+  class PersonProfilesController < ApplicationController
+    before_filter :set_person_profile, only: [:update, :destroy]
+
+    def create
+      @person_profile = current_user.adresses.build(params[:person_profile])
+      @person_profile.save!
+      redirect_to current_user
+    end
+
+    def update
+      @person_profile.update!(params[:person_profile])
+      redirect_to current_user
+    end
+
+    def destroy
+      @person_profile.destroy
+      redirect_to current_user
+    end
+
+    private
+
+    def set_person_profile
+      @person_profile = current_user.profiles.find(params[:id])
+    end
+  end
+end

data/app/controllers/socializer/sessions_controller.rb

@@ -0,0 +1,37 @@
+module Socializer
+  class SessionsController < ApplicationController
+    def create
+      auth = request.env['omniauth.auth']
+      user_auth = Authentication.where(provider: auth.provider, uid: auth.uid).first
+
+      if user_auth.nil?
+        if signed_in?
+          current_user.authentications.create!(provider: auth.provider, uid: auth.uid)
+          redirect_to authentications_path
+        else
+          user = Person.create_with_omniauth(auth)
+          user.activity_object.circles.create!(name: 'Friends',       content: 'Your real friends, the ones you feel comfortable sharing private details with.')
+          user.activity_object.circles.create!(name: 'Family',        content: 'Your close and extended family, with as many or as few in-laws as you want.')
+          user.activity_object.circles.create!(name: 'Acquaintances', content: "A good place to stick people you've met but aren't particularly close to.")
+          user.activity_object.circles.create!(name: 'Following',     content: "People you don't know personally, but whose posts you find interesting.")
+        end
+      else
+        user = user_auth.person if user_auth.present?
+      end
+
+      if user
+        cookies[:user_id] = { domain: :all, value: "#{user.id}" }
+        redirect_to root_url
+      end
+    end
+
+    def destroy
+      cookies.delete :user_id, domain: :all
+      redirect_to root_url
+    end
+
+    def failure
+      redirect_to root_url
+    end
+  end
+end

data/app/controllers/socializer/shares_controller.rb

@@ -0,0 +1,54 @@
+module Socializer
+  class SharesController < ApplicationController
+    # before_action :set_share, only: [:show, :edit, :update, :destroy]
+
+    def new
+      @activity_object = ActivityObject.find(params[:id])
+      @share = @activity_object.activitable
+    end
+
+    def create
+      # scope = params[:share][:scope]
+      object_ids = params[:share][:object_ids]
+
+      activity = Activity.new do |a|
+        a.actor_id           = current_user.guid
+        a.activity_object_id = params[:share][:activity_id]
+        a.verb               = Verb.find_or_create_by(name: 'share')
+      end
+
+      activity.build_activity_field(content: params[:share][:content]) if params[:share][:content]
+
+      public  = Socializer::Audience.privacy_level.find_value(:public).value.to_s
+      circles = Socializer::Audience.privacy_level.find_value(:circles).value.to_s
+
+      object_ids.split(',').each do |object_id|
+        # REFACTOR: remove duplication
+        if object_id == public || object_id == circles
+          activity.audiences.build(privacy_level: object_id)
+        else
+          activity.audiences.build do |a|
+            a.privacy_level = :limited
+            a.activity_object_id = object_id
+          end
+        end
+      end
+
+      activity.save!
+
+      redirect_to stream_path
+    end
+
+    private
+
+      # # Use callbacks to share common setup or constraints between actions.
+      # def set_share
+      #   @share = Share.find(params[:id])
+      # end
+
+      # # Never trust parameters from the scary internet, only allow the white list through.
+      # def share_params
+      #   params.require(:share).permit(:content, :actor_id)
+      # end
+  end
+end

data/app/controllers/socializer/ties_controller.rb

@@ -0,0 +1,16 @@
+module Socializer
+  class TiesController < ApplicationController
+    def create
+      @circle = Circle.find(params[:tie][:circle_id])
+      @circle.add_contact(params[:tie][:contact_id])
+      redirect_to @circle
+    end
+
+    def destroy
+      @tie = Tie.find(params[:id])
+      @circle = @tie.circle
+      @tie.destroy
+      redirect_to @circle
+    end
+  end
+end

data/app/helpers/socializer/application_helper.rb

@@ -0,0 +1,22 @@
+module Socializer
+  module ApplicationHelper
+    def signin_path(provider)
+      "/auth/#{provider.to_s}"
+    end
+
+    def current_user?(user)
+      user == current_user
+    end
+
+    def time_ago(time, options = {})
+      time = time.to_time.utc
+
+      options.reverse_merge! title: l(time, format: :short)
+
+      options[:data] ||= {}
+      options[:data].merge! time_ago: 'moment.js'
+
+      time_tag time, time.strftime('%B %e, %Y %l:%M%P'), options
+    end
+  end
+end

data/app/models/concerns/socializer/object_type_base.rb

@@ -0,0 +1,58 @@
+module Socializer
+  module ObjectTypeBase
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor   :activity_verb, :scope, :object_ids, :activity_target_id
+      attr_accessible :activity_verb, :scope, :object_ids, :author_id, :activity_target_id
+
+      has_one :activity_object, as: :activitable, dependent: :destroy
+
+      before_create :create_activity_object
+      after_create  :append_to_activity_stream
+
+    end
+
+    def guid
+      activity_object.id
+    end
+
+    protected
+
+    def create_activity_object
+      build_activity_object
+    end
+
+    def append_to_activity_stream
+      # REFACTOR: the activity_verb.blank? and object_ids.blank? checks shouldn't be needed
+      #           since the record should be invalid without them.
+      return if activity_verb.blank?
+
+      activity = Activity.new do |a|
+        a.target_id          = activity_target_id if activity_target_id.present?
+        a.actor_id           = author_id
+        a.activity_object_id = guid
+        a.verb               = Verb.find_or_create_by(name: activity_verb)
+      end
+
+      return if object_ids.blank?
+
+      public  = Socializer::Audience.privacy_level.find_value(:public).value.to_s
+      circles = Socializer::Audience.privacy_level.find_value(:circles).value.to_s
+
+      # REFACTOR: remove duplication
+      object_ids.each do |object_id|
+        if object_id == public || object_id == circles
+          activity.audiences.build(privacy_level: object_id)
+        else
+          activity.audiences.build do |a|
+            a.privacy_level = :limited
+            a.activity_object_id = object_id
+          end
+        end
+      end
+
+      activity.save!
+    end
+  end
+end