raddar 0.0.1.pre

data/app/controllers/raddar/users/privacies_controller.rb

@@ -0,0 +1,25 @@
+module Raddar
+  class Users::PrivaciesController < Raddar::ApplicationController
+    skip_after_action :verify_authorized
+
+    def edit
+      @user = current_user
+      @user.privacy ||= {}
+    end
+
+    def update
+      @user = current_user
+      @user.privacy ||= {}
+
+      @user.update_attributes(privacy_params)
+
+      redirect_to edit_user_privacy_path, notice: t('flash.users.privacies.update')
+    end
+
+    private
+
+    def privacy_params
+      params.require(:user).permit(privacy: @user.privacy_keys)
+    end
+  end
+end

data/app/controllers/raddar/users/registrations_controller.rb

@@ -0,0 +1,51 @@
+module Raddar
+  class Users::RegistrationsController < Devise::RegistrationsController
+    before_action :configure_permitted_parameters
+
+    def update
+      @user = User.find(current_user.id)
+
+      prev_unconfirmed_email = @user.unconfirmed_email if @user.respond_to?(:unconfirmed_email)
+
+      if @user.update_attributes(account_update_params)
+        if is_navigational_format?
+          flash_key = update_needs_confirmation?(@user, prev_unconfirmed_email) ?
+            :update_needs_confirmation : :updated
+          set_flash_message :notice, flash_key
+        end
+
+        sign_in @user, bypass: true
+        respond_with @user, location: @user
+      else
+        clean_up_passwords @user
+        respond_with @user
+      end
+    end
+
+    def destroy
+      @user = current_user
+
+      if request.request_method_symbol == :delete
+        if @user.valid_password?(params[:user][:password])
+          super
+        else
+          @user.valid?
+          @user.errors.add :password, params[:user][:password].blank? ? :blank : :invalid
+          clean_up_passwords @user
+        end
+      end
+    end
+
+    private
+
+    def configure_permitted_parameters
+      devise_parameter_sanitizer.for(:sign_up) do |u|
+        u.permit(:name, :email, :password, :password_confirmation)
+      end
+
+      devise_parameter_sanitizer.for(:account_update) do |u|
+        u.permit(:name, :email, :gender, :bio, :location, :birthday, :avatar)
+      end
+    end
+  end
+end

data/app/controllers/raddar/users/sessions_controller.rb

@@ -0,0 +1,11 @@
+module Raddar
+  class Users::SessionsController < Devise::SessionsController
+    before_action :configure_permitted_parameters
+
+    private
+
+    def configure_permitted_parameters
+      devise_parameter_sanitizer.for(:sign_in) { |u| u.permit(:login) }
+    end
+  end
+end

data/app/controllers/raddar/users_controller.rb

@@ -0,0 +1,8 @@
+module Raddar
+  class UsersController < Raddar::ApplicationController
+    def show
+      @user = User.find(params[:id])
+      authorize(@user)
+    end
+  end
+end

data/app/helpers/raddar/admin/dashboard_helper.rb

@@ -0,0 +1,4 @@
+module Raddar
+  module Admin::DashboardHelper
+  end
+end

data/app/helpers/raddar/application_helper.rb

@@ -0,0 +1,4 @@
+module Raddar
+  module ApplicationHelper
+  end
+end

data/app/helpers/raddar/notifications_helper.rb

@@ -0,0 +1,19 @@
+module Raddar
+  module NotificationsHelper
+    def unread_notifications_count(user)
+      user.notifications.where(unread: true).count
+    end
+
+    def last_notifications(user)
+      user.notifications.order('created_at DESC').limit(10)
+    end
+
+    def link_to_notification(notification)
+      text = t(notification.token, scope: 'notifications.tokens', notifiable: notification.notifiable.name)
+
+      unread_class = notification.unread ? 'unread' : 'read'
+
+      link_to(text, [raddar, notification], class: "notification #{ unread_class }")
+    end
+  end
+end

data/app/helpers/raddar/users/privacies_helper.rb

@@ -0,0 +1,4 @@
+module Raddar
+  module Users::PrivaciesHelper
+  end
+end

data/app/mailers/raddar/notification_mailer.rb

@@ -0,0 +1,16 @@
+module Raddar
+  class NotificationMailer < ActionMailer::Base
+    default from: "#{ Raddar.app_name } <#{ Raddar.default_from }>"
+
+    def new_follower(notification)
+      @user         = notification.user
+      @follower     = notification.notifiable
+      @notification = notification
+
+      mail(
+        to: @user.email,
+        subject: t('mailers.notification.new_follower.subject', follower: @follower.name)
+      )
+    end
+  end
+end

data/app/models/raddar/external_account.rb

@@ -0,0 +1,12 @@
+module Raddar
+  class ExternalAccount < ActiveRecord::Base
+    belongs_to :user
+
+    validates :provider, presence: true
+    validates :uid, presence: true, uniqueness: { scope: :provider }
+    validates :name, presence: true, uniqueness: { scope: :provider }
+    validates :url, presence: true, uniqueness: { scope: :provider }
+    validates :token, presence: true, uniqueness: { scope: :provider }
+    validates :user_id, presence: true, uniqueness: { scope: :provider }
+  end
+end

data/app/models/raddar/followership.rb

@@ -0,0 +1,20 @@
+module Raddar
+  class Followership < ActiveRecord::Base
+    belongs_to :user
+    belongs_to :followable, polymorphic: true, inverse_of: :followers
+
+    validates :user_id, presence: true, uniqueness: { scope: [:followable_id, :followable_type] }
+    validates :followable_id, presence: true
+
+    validate :user_and_followable_must_be_different
+
+
+    private
+
+    def user_and_followable_must_be_different
+      if self.user.present? && self.user == self.followable
+        self.errors[:base] << 'User cannot follow himself/herself.'
+      end
+    end
+  end
+end

data/app/models/raddar/followership_completion.rb

@@ -0,0 +1,37 @@
+module Raddar
+  class FollowershipCompletion
+    def initialize(followership)
+      @followership = followership
+    end
+
+    def create
+      successful = @followership.save
+
+      if successful
+        notify_followed_user
+      end
+
+      successful
+    end
+
+    private
+
+    def notify_followed_user
+      followable = @followership.followable
+
+      if followable.is_a?(User)
+        notification            = Notification.new
+        notification.user       = followable
+        notification.token      = 'new_follower'
+        notification.notifiable = @followership.user
+        notification.save!
+
+        email_preferences = followable.email_preferences || {}
+
+        if email_preferences[:new_follower] != false
+          NotificationMailer.new_follower(notification).deliver
+        end
+      end
+    end
+  end
+end

data/app/models/raddar/notification.rb

@@ -0,0 +1,10 @@
+module Raddar
+  class Notification < ActiveRecord::Base
+    belongs_to :user
+    belongs_to :notifiable, polymorphic: true
+
+    validates :token, presence: true
+    validates :user_id, presence: true
+    validates :notifiable_id, presence: true
+  end
+end

data/app/models/raddar/omniauth_completion.rb

@@ -0,0 +1,83 @@
+module Raddar
+  class OmniauthCompletion
+    def self.complete(auth_data, current_user = nil)
+      user = User.new(password: Devise.friendly_token[0,20])
+
+      provider = auth_data[:provider]
+
+      account = ExternalAccount.find_by(provider: provider, uid: auth_data[:uid])
+
+      if current_user.present?
+        if account.present?
+          if account.user != current_user
+            raise 'Another user already owns this account.'
+          end
+        else
+          create_account_for(current_user, auth_data)
+        end
+
+        user = current_user
+      elsif account.present?
+        user = account.user
+      elsif auth_data[:info][:email].present?
+        user_with_the_given_email = User.find_by(email: auth_data[:info][:email])
+
+        if user_with_the_given_email.present?
+          create_account_for(user_with_the_given_email, auth_data)
+
+          user = user_with_the_given_email
+        end
+      end
+
+      populate(user, auth_data)
+
+      if user.valid?
+        if user.new_record?
+          user.confirm!
+
+          user.save
+
+          create_account_for(user, auth_data)
+        else
+          user.save
+        end
+      end
+
+      user
+    end
+
+    private
+
+    def self.create_account_for(user, auth_data)
+      account = user.external_accounts.new
+
+      account.provider = auth_data[:provider]
+      account.token    = auth_data[:credentials][:token]
+      account.secret   = auth_data[:credentials][:secret]
+      account.verified = auth_data[:info][:verified]
+      account.name     = auth_data[:info][:nickname]
+      account.uid      = auth_data[:uid]
+      account.email    = auth_data[:info][:email]
+      account.url      = auth_data[:info][:urls][account.provider.titleize.to_sym]
+
+      account.save!
+    end
+
+    def self.populate(user, auth_data)
+      user.email    = user.email.presence || auth_data[:info][:email]
+
+      user.name     ||= auth_data[:info][:nickname]
+      user.bio      ||= auth_data[:info][:description]
+      user.location ||= auth_data[:info][:location]
+
+      user.remote_avatar_url = auth_data[:info][:image] if user.avatar.blank?
+
+      if auth_data[:provider] == 'facebook'
+        fb_birthday = auth_data[:extra][:raw_info][:birthday]
+
+        user.birthday ||= Date.strptime(fb_birthday, '%m/%d/%Y') if fb_birthday
+        user.gender   ||= auth_data[:extra][:raw_info][:gender]
+      end
+    end
+  end
+end

data/app/models/raddar/role.rb

@@ -0,0 +1,7 @@
+module Raddar
+  class Role < ActiveRecord::Base
+    has_and_belongs_to_many :users
+
+    validates :name, presence: true, uniqueness: { case_sensitive: false }
+  end
+end

data/app/models/raddar/user.rb

@@ -0,0 +1,70 @@
+module Raddar
+  class User < ActiveRecord::Base
+    attr_accessor :login
+
+    store_accessor :privacy
+    store_accessor :email_preferences
+
+    serialize :email_preferences, Raddar::HstoreSerializer
+    serialize :privacy, Raddar::HstoreSerializer
+
+    has_many :followerships, dependent: :destroy
+    has_many :followers, class_name: 'Followership', as: :followable, dependent: :destroy
+    has_and_belongs_to_many :roles
+    has_many :notifications, dependent: :destroy
+    has_many :external_accounts, dependent: :destroy
+
+    mount_uploader :avatar, AvatarUploader
+
+    # Include default devise modules. Others available are:
+    # :token_authenticatable,
+    # :lockable and :timeoutable
+    devise :database_authenticatable, :registerable, :omniauthable,
+           :recoverable, :rememberable, :trackable, :validatable,
+           :confirmable, authentication_keys: [:login]
+
+    validates :name,
+              presence: true,
+              uniqueness: {
+                case_sensitive: false
+              },
+              format: { with: /\A(([a-z]|[A-Z]|[0-9]|_)+)\z/ },
+              length: { maximum: 20, minimum: 3 }
+
+    validates :state, presence: true, inclusion: { in: ['active', 'blocked'] }
+
+    def self.find_first_by_auth_conditions(warden_conditions)
+      conditions = warden_conditions.dup
+      if login = conditions.delete(:login)
+        where(conditions).where('lower(name) = :value OR lower(email) = :value', value: login.downcase).first
+      else
+        where(conditions).first
+      end
+    end
+
+    cattr_accessor(:privaciable_fields) do
+      [:email, :gender, :location, :birthday]
+    end
+
+    cattr_accessor(:email_preferences_keys) do
+      [:new_follower]
+    end
+
+    def admin?
+      self.roles.exists?(name: 'admin') == '1'
+    end
+
+    def active_for_authentication?
+      super && self.state == 'active'
+    end
+
+    def inactive_message
+      (self.state == 'active') ? super : I18n.t('flash.users.sessions.blocked')
+    end
+
+    def privacy_keys
+      account_keys = self.external_accounts.map(&:provider)
+      @@privaciable_fields + account_keys
+    end
+  end
+end

data/app/policies/raddar/admin/dashboard_policy.rb

@@ -0,0 +1,7 @@
+module Raddar
+  class Admin::DashboardPolicy < ApplicationPolicy
+    def index?
+      @user.admin?
+    end
+  end
+end

data/app/policies/raddar/admin/user_policy.rb

@@ -0,0 +1,15 @@
+module Raddar
+  class Admin::UserPolicy < ApplicationPolicy
+    def index?
+      @user.admin?
+    end
+
+    def show?
+      @user.admin?
+    end
+
+    def update?
+      @user.admin?
+    end
+  end
+end

data/app/policies/raddar/application_policy.rb

@@ -0,0 +1,42 @@
+module Raddar
+  class ApplicationPolicy
+    attr_reader :user, :record
+
+    def initialize(user, record)
+      @user = user
+      @record = record
+    end
+
+    def index?
+      false
+    end
+
+    def show?
+      scope.where(:id => record.id).exists?
+    end
+
+    def create?
+      false
+    end
+
+    def new?
+      create?
+    end
+
+    def update?
+      false
+    end
+
+    def edit?
+      update?
+    end
+
+    def destroy?
+      false
+    end
+
+    def scope
+      Pundit.policy_scope!(user, record.class)
+    end
+  end
+end