Ruby on Rails Facebook Implementation: SpyBook

$ rails new fakebook --database=postgresql 

# Use postgresql as the database for Active Record
gem 'pg', '>= 0.18', '< 2.0'
# Rubocop gem to correct linter related issues keeping your code close to standard coding practices
gem 'rubocop'
# Devise security gem
gem 'devise'
# To handle images
gem 'carrierwave', '~> 2.0'
gem 'mini_magick'
# Use omniauth-facebook gem allows Facebook login integration
gem 'omniauth-facebook'

# Allows access to twitter's Bootstrap framework
gem 'bootstrap'
# Hirb gem organizes the display for active record information into tables when using the rails console… eg. After opening rails console type Hirb.enable to activate it
gem 'hirb'
# All gems below are related to the RSpec Gem except the dotenv-rails gem
group :development, :test do
  # RSpec Testing
  gem 'database_cleaner'
  gem 'rspec-rails'
  # A Ruby gem to load environment variables from `.env` files.
  gem 'dotenv-rails'
end
group :test do
  gem 'capybara'
  gem 'selenium-webdriver'
end

$ bundle install 

$ bundle 

$ apt-get -y install postgresql postgresql-contrib libpq-dev 

$ sudo apt-get -y install postgresql postgresql-contrib libpq-dev

$ su — postgres 
$ psql

$ sudo su — postgres 

$ \password postgres
 Enter new password:

$ create role rails_dev with createdb login password ‘aqwe123’;

$ /du

username: rails_dev

password: aqwe123

host: localhost
port: 5432

database: fakebook_test
 host: localhost
 port: 5432
 username: rails_dev
 password: aqwe123

# PostgreSQL. Versions 9.3 and up are supported.
#
# Install the pg driver:
# gem install pg
# On macOS with Homebrew:
# gem install pg - - with-pg-config=/usr/local/bin/pg_config
# On macOS with MacPorts:
# gem install pg - - with-pg-config=/opt/local/lib/postgresql84/bin/pg_config
# On Windows:
# gem install pg
# Choose the win32 build.
# Install PostgreSQL and put its /bin directory on your path.
#
# Configure Using Gemfile
# gem 'pg'
#
default: &default
adapter: postgresql
encoding: unicode
# For details on connection pooling, see Rails configuration guide
# https://guides.rubyonrails.org/configuring.html#database-pooling
pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
development:
<<: *default
database: fakebook_development

# The specified database role being used to connect to postgres.
# To create additional roles in postgres see `$ createuser - help`.
# When left blank, postgres will use the default role. 
# This is
# the same name as the operating system user that initialized the database.
username: rails_dev

# The password associated with the postgres role (username).
password: aqwe123

# Connect on a TCP socket. Omitted by default since the client uses 
# a domain socket that doesn't need configuration. Windows does not 
# have domain sockets, so uncomment these lines.
host: localhost
# The TCP port the server listens on. Defaults to 5432.
# If your server runs on a different port number, change
# accordingly.
port: 5432

# Schema search path. The server defaults to $user,public
#schema_search_path: myapp,sharedapp,public
# Minimum log levels, in increasing order:
# debug5, debug4, debug3, debug2, debug1,
# log, notice, warning, error, fatal, and panic
# Defaults to warning.
# min_messages: notice
# Warning: The database defined as "test" will be erased and
# re-generated from your development database when you run "rake".
# Do not set this db to the same as development or production.
test:
  <<: *default
  database: fakebook_test
  host: localhost
  port: 5432
  username: rails_dev
  password: aqwe123
# As with config/credentials.yml, you never want to store sensitive # information,like your database password, in your source code.
# If your source code is
# ever seen by anyone, they now have access to your database.
#
# Instead, provide the password as a unix environment variable when # you boot the app.
# Read https://guides.rubyonrails.org/configuring.html#configuring-a-database
# for a full rundown on how to provide these environment variables
# in a production deployment.
#
# On Heroku and other platform providers, you may have a full 
# connection URL available as an environment variable. For example:
#
# DATABASE_URL="postgres://myuser:mypass@localhost/somedatabase"
#
# You can use this database configuration with:
#
# production:
# url: <%= ENV['DATABASE_URL'] %>
#
production:
  <<: *default
  database: fakebook_production
  username: rails_dev
  password: <%= ENV['FAKEBOOK_DATABASE_PASSWORD'] %>

$ rails db:setup

USERNAME = 'rails_dev'
PASSWORD = 'aqwe123'

username: rails_dev
password: aqwe123

username: <%=ENV['USERNAME']%>
password: <%=ENV['PASSWORD']%>

*= require_tree .
*= require_self

// Custom bootstrap variables must be set or imported *before* bootstrap.
@import "bootstrap";
@import "custom";

$ yarn add bootstrap jquery popper.js

import 'bootstrap';
import 'jquery';
import 'popper.js';

$ rails generate devise:install

config.action_mailer.default_url_options = { host: 'localhost', port: 3000 }

$ rails generate devise User

$ rails generate devise User fname:string lname:string image:string

$ rails db:migrate

1  class ApplicationController < ActionController::Base
2    before_action :authenticate_user!
3    before_action :configure_permitted_parameters, if: devise_controller?
4  
5    protected
6  
7    def configure_permitted_parameters
8      devise_parameter_sanitizer.permit(:sign_up, keys: %i[fname lname image])
9      devise_parameter_sanitizer.permit(:account_update, keys: %i[fname lname image])
10   end
11 end

$ rails generate controller Users index show

$ rails generate devise:views

<div class="col-md-6 mx-auto mb-5">
  <h1 class="center bold">Sign up</h1>
  <%= form_for(resource, as: resource_name, url: registration_path(resource_name)) do |f| %>
    <%= render "devise/shared/error_messages", resource: resource%>
    <div class="form-group row">
      <div class="col">
        <%= f.label :first_name %>
        <%= f.text_field :fname, class:"form-control col", autofocus: true, autocomplete: "fname" %>
      </div>
      <div class="col">
        <%= f.label :last_name %><br />
        <%= f.text_field :lname, class:"form-control col", autofocus: true, autocomplete: "lname" %>
      </div>
    </div>
    <div class="form-group">
      <%= f.label :email %><br />
      <%= f.email_field :email, class:"form-control", autofocus: true, autocomplete: "email" %>
   </div>
   <div class="form-group">
     <%= f.label :password %>
     <% if @minimum_password_length %>
       <em>(<%= @minimum_password_length %> characters minimum)</em>
     <% end %><br />
    <%= f.password_field :password, class:"form-control", autocomplete: "new-password" %>
   </div>
   <div class="form-group">
     <%= f.label :password_confirmation %><br />
     <%= f.password_field :password_confirmation, class:"form-control", autocomplete: "new-password" %>
   </div>
   <div class="row">
     <div class="actions col-md-3">
       <%= f.submit "Sign up", class:"btn btn-secondary" %>
     </div>
    <div class="col">
      <%= render "devise/shared/links" %>
    </div>
   </div>
  <% end %>
</div>

$ rails generate uploader Image

1  class User < ApplicationRecord
2    mount_uploader :image, ImageUploader
3    # Include default devise modules. Others available are:
4    # :confirmable, :lockable, :timeoutable, :trackable and   
5    # :omniauthable
6    devise :database_authenticatable, :registerable, :recoverable, :rememberable, :validatable,
7           :omniauthable, omniauth_providers: %i[facebook]
8    validate :picture_size
9  
10   private
11    # Validates the size of an uploaded picture.
12    def picture_size
13      errors.add(:image, 'should be less than 1MB') if image.size > 1.megabytes
14    end
15  end

<!-- ...Doesn't show other code up above -->
<div class="picture form-group">
  <%= f.label :upload_your_profile_picture %><br />
  <%= f.file_field :image, class:"form-control", accept: 'image/jpeg,image/gif,image/png' %>
</div>
<div class="row">
  <div class="actions col-md-3">
    <%= f.submit "Sign up", class:"btn btn-secondary" %>
  </div>
  <div class="col">
    <%= render "devise/shared/links" %>
  </div>
</div>
<% end %>
</div>

<script type="text/javascript">
document.getElementById('user_image').addEventListener('change', function() {
  var size_in_megabytes = this.files[0].size/1024/1024;
  if (size_in_megabytes > 1) {
    alert('Maximum file size is 1 MB. Please choose a smaller      
    file.');
  }
});
</script>

$ rails generate model Post content:text user:references

class Post < ApplicationRecord
  belongs_to :user
end

class User < ApplicationRecord
  has_many :posts
end

$ rails generate controller Posts index show new create

$ rails generate model Comment content:text post:references user:references

class Comment < ApplicationRecord
  belongs_to :user
  belongs_to :post
end

class User < ApplicationRecord
  has_many :comments
end

class Post < ApplicationRecord
  belongs_to :user
  has_many :comments
end

$ rails generate controller Comments new create

$ rails generate model Likes user:references post:references comment:references

class Like < ApplicationRecord
  belongs_to :user
  belongs_to :post
  belongs_to :comment
end

class Like < ApplicationRecord
  belongs_to :user
  belongs_to :post, optional: true
  belongs_to :comment, optional: true
end

class User < ApplicationRecord
  has_many :likes, dependent: :destroy
end

class Post < ApplicationRecord
  belongs_to :user
  has_many :comments
  has_many :likes, dependent: :destroy
end

class Comment < ApplicationRecord
  belongs_to :user
  belongs_to :post
  has_many :likes, dependent: :destroy
end

1  class CreateLikes < ActiveRecord::Migration[6.0]
2    def change
3      create_table :likes do |t|
4        t.references :user, null: false, foreign_key: true
5        t.references :post, null: true, foreign_key: true
6        t.references :comment, null: true, foreign_key: true
7
8        t.timestamps
9      end
10   end
11  end

$ rails generate controller Likes create

$ rails generate model Friendship sent_to:references sent_by:references

class CreateFriendships < ActiveRecord::Migration[6.0]
  def change
    create_table :friendships do |t|
      t.references :sent_by, null: false, foreign_key: { to_table: :users }
      t.references :sent_to, null: false, foreign_key: { to_table: :users }
      t.boolean :status, default: false
      
      t.timestamps
    end
  end
end

class Friendship < ApplicationRecord
  belongs_to :sent_to, class_name: ‘User’, foreign_key: ‘sent_to_id’
  belongs_to :sent_by, class_name: ‘User’, foreign_key: ‘sent_by_id’
  scope :friends, -> { where(‘status =?’, true) }
  scope :not_friends, -> { where(‘status =?’, false) }
end

1  class User < ApplicationRecord
2    has_many :friend_sent, class_name: 'Friendship',
3                          foreign_key: 'sent_by_id',
4                          inverse_of: 'sent_by',
5                          dependent: :destroy
6    has_many :friend_request, class_name: 'Friendship',
7                          foreign_key: 'sent_to_id',
8                          inverse_of: 'sent_to',
9                          dependent: :destroy
10   has_many :friends, -> { merge(Friendship.friends) },
11            through: :friend_sent, source: :sent_to
12   has_many :pending_requests, -> { merge(Friendship.not_friends) },
13            through: :friend_sent, source: :sent_to
14   has_many :received_requests, -> { merge(Friendship.not_friends) },
15            through: :friend_request, source: :sent_by
16  end

3  belongs_to :sent_by, class_name: 'User', foreign_key: 'sent_by_id'

2  belongs_to :sent_to, class_name: ‘User’, foreign_key: ‘sent_to_id’

10  has_many :friends, -> { merge(Friendship.friends) },
11           through: :friend_sent, source: :sent_to

SELECT "users".* FROM "users" INNER JOIN "friendships"
ON "users"."id" = "friendships"."sent_to_id" 
WHERE "friendships"."sent_by_id" = $1 AND (status =TRUE) LIMIT $2

12  has_many :pending_requests, -> { merge(Friendship.not_friends) },
13           through: :friend_sent, source: :sent_to

SELECT "users".* FROM "users" INNER JOIN "friendships"
ON "users"."id" = "friendships"."sent_to_id"
WHERE "friendships"."sent_by_id" = $1 AND (status =FALSE) LIMIT $2

14   has_many :received_requests, -> { merge(Friendship.not_friends) },
15            through: :friend_request, source: :sent_by

SELECT "users".* FROM "users" INNER JOIN "friendships"
ON "users"."id" = "friendships"."sent_by_id"
WHERE "friendships"."sent_to_id" = $1 AND (status =FALSE) LIMIT $2

$ rails generate controller Friendships create

$ rails generate model Notification notice_id:integer notice_type:string user:references

class Notification < ApplicationRecord
  belongs_to :user
  scope :friend_requests, -> { where('notice_type = friendRquest') }
  scope :likes, -> { where('notice_type = like') }
  scope :comments, -> { where('notice_type = comment') }
end

class User < ApplicationRecord
  has_many :notifications, dependent: :destroy
end

module ApplicationHelper 
  # Returns the new record created in notifications table
  def new_notification(user, notice_id, notice_type)
    notice = user.notifications.build(notice_id: notice_id,   
    notice_type: notice_type)
    user.notice_seen = false
    user.save
    notice
  end
  
  # Receives the notification object as parameter along with a type
  # and returns a User record, Post record or a Comment record
  # depending on the type supplied 
  def notification_find(notice, type)
    return User.find(notice.notice_id) if type == 'friendRequest'
    return Post.find(notice.notice_id) if type == 'comment'
    return Post.find(notice.notice_id) if type == 'like-post'
    return unless type == 'like-comment'
    comment = Comment.find(notice.notice_id)
    Post.find(comment.post_id)
  end
end

Rails.application.routes.draw do
  root 'users#index'
  devise_for :users
  resources :users, only: %i[index show] do
    resources :friendships, only: %i[create]
  end
  resources :posts, only: %i[index new create show destroy] do
    resources :likes, only: %i[create]
  end
  resources :comments, only: %i[new create destroy] do
    resources :likes, only: %i[create]
  end
end

class User < ApplicationRecord
  # Include default devise modules. Others available are:
  # :confirmable, :lockable, :timeoutable, :trackable and 
  # :omniauthable
  devise :database_authenticatable, :registerable,
         :recoverable, :rememberable, :validatable
  has_many :posts
  has_many :comments, dependent: :destroy
  has_many :likes, dependent: :destroy
  has_many :friend_sent, class_name: 'Friendship',
                         foreign_key: 'sent_by_id',
                         inverse_of: 'sent_by',
                         dependent: :destroy
  has_many :friend_request, class_name: 'Friendship',
                         foreign_key: 'sent_to_id',
                         inverse_of: 'sent_to',
                         dependent: :destroy
  has_many :friends, -> { merge(Friendship.friends) },
           through: :friend_sent, source: :sent_to
  has_many :pending_requests, -> { merge(Friendship.not_friends) },
           through: :friend_sent, source: :sent_to
  has_many :received_requests, -> { merge(Friendship.not_friends) },
           through: :friend_request, source: :sent_by
  has_many :notifications, dependent: :destroy
  mount_uploader :image, PictureUploader
  validate :picture_size
  
  # Returns a string containing this user's first name and last name
  def full_name
    "#{fname} #{lname}"
  end
  
  # Returns all posts from this user's friends and self
  def friends_and_own_posts
    myfriends = friends
    our_posts = []
    myfriends.each do |f|
      f.posts.each do |p|
        our_posts << p
      end
    end
    posts.each do |p|
      our_posts << p
    end
    our_posts
  end
  
  private
  
  # Validates the size of an uploaded picture.
  def picture_size
    errors.add(:image, 'should be less than 1MB') if image.size > 
    1.megabytes
  end
end

def full_name
  "#{fname} #{lname}"
end

def friends_and_own_posts
    myfriends = friends
    our_posts = []
    myfriends.each do |f|
      f.posts.each do |p|
        our_posts << p
      end
    end
    posts.each do |p|
      our_posts << p
    end
    our_posts
  end

class PostsController < ApplicationController
  def index
    @our_posts = current_user.friends_and_own_posts
  end
  
  def show
    @post = Post.find(params[:id])
  end
  
  def new
    @post = Post.new
  end
  
 def create
    @post = current_user.posts.build(posts_params)
    if @post.save
      redirect_to @post
    else
      render 'new'
    end
  end
  
  def destroy; end
  
  private
  
  def posts_params
    params.require(:post).permit(:content, :imageURL)
  end
end

def index
  @our_posts = current_user.friends_and_own_posts
end

def show
  @post = Post.find(params[:id])
end

def new
  @post = Post.new
end

def create
  @post = current_user.posts.build(posts_params)
  if @post.save
    redirect_to @post
  else
    render 'new'
  end
end

private
def posts_params
  params.require(:post).permit(:content, :imageURL)
end

# => <ActionController::Parameters {"content"=>"Example post", "imageURL"=>"http://example.com"} permitted: true>

class UsersController < ApplicationController
  def index
    @users = User.all
    @friends = current_user.friends
    @pending_requests = current_user.pending_requests
    @friend_requests = current_user.received_requests
  end
  
  def show
    @user = User.find(params[:id])
  end
  
  def update_img
    @user = User.find(params[:id])
    unless current_user.id == @user.id
      redirect_back(fallback_location: users_path(current_user))
      return
    end
    image = params[:user][:image] unless params[:user].nil?
    if image
      @user.image = image
      if @user.save
        flash[:success] = 'Image uploaded'
      else
        flash[:danger] = 'Image uploaded failed'
      end
    end
    redirect_back(fallback_location: root_path)
  end
end

def index
    @users = User.all
    @friends = current_user.friends
    @pending_requests = current_user.pending_requests
    @friend_requests = current_user.recieved_requests
  end

def update_img
  @user = User.find(params[:id])
  unless current_user.id == @user.id
    redirect_back(fallback_location: users_path(current_user))
    return
  end
  image = params[:user][:image] unless params[:user].nil?
  if image
    @user.image = image
    if @user.save
      flash[:success] = 'Image uploaded'
    else
      flash[:danger] = 'Image uploaded failed'
    end
  end
  redirect_back(fallback_location: root_path)
 end

class CommentsController < ApplicationController
  include ApplicationHelper
  
  def new
    @comment = Comment.new
  end
  
  def create
    @comment = current_user.comments.build(comment_params)
    @post = Post.find(params[:comment][:post_id])
    if @comment.save
      @notification = new_notification(@post.user, @post.id, 
                                      'comment')
      @notification.save
    end
    redirect_to @post
  end
  
  def destroy
    @comment = Comment.find(params[:id])
    return unless current_user.id == @comment.user_id
    @comment.destroy
    flash[:success] = 'Comment deleted'
    redirect_back(fallback_location: root_path)
  end
  
  private

  def comment_params
    params.require(:comment).permit(:content, :post_id)
  end
end

def create
  @post = Post.find(params[:comment][:post_id])    
  @comment = current_user.comments.build(comment_params)
  if @comment.save
    @notification = new_notification(@post.user, @post.id, 
                                     'comment')
    @notification.save
  end
  redirect_to @post
end

  if @comment.save
    @notification = new_notification(@post.user, @post.id, 'comment')
    @notification.save
  end

def destroy
    @comment = Comment.find(params[:id])
    return unless current_user.id == @comment.user_id

    @comment.destroy
    flash[:success] = 'Comment deleted'
    redirect_back(fallback_location: root_path) 
 end

class LikesController < ApplicationController
  include ApplicationHelper
  
  def create
    type = type_subject?(params)[0]
    @subject = type_subject?(params)[1]
    notice_type = "like-#{type}"
    return unless @subject
    if already_liked?(type)
      dislike(type)
    else
      @like = @subject.likes.build(user_id: current_user.id)
      if @like.save
        flash[:success] = "#{type} liked!"
        @notification = new_notification(@subject.user, @subject.id,
                                         notice_type)
        @notification.save
      else
        flash[:danger] = "#{type} like failed!"
      end
      redirect_back(fallback_location: root_path)
    end
  end
  
  private
  
  def type_subject?(params)
    type = 'post' if params.key?('post_id')
    type = 'comment' if params.key?('comment_id')
    subject = Post.find(params[:post_id]) if type == 'post'
    subject = Comment.find(params[:comment_id]) if type == 'comment'
    [type, subject]
  end
  
  def already_liked?(type)
    result = false
    if type == 'post'
      result = Like.where(user_id: current_user.id,
                          post_id: params[:post_id]).exists?
    end
    if type == 'comment'
      result = Like.where(user_id: current_user.id,
                          comment_id: params[:comment_id]).exists?
    end
    result
  end
  
  def dislike(type)
    @like = Like.find_by(post_id: params[:post_id]) if type ==
                                                       'post'
    @like = Like.find_by(comment_id: params[:comment_id]) if type ==
                                                          'comment'
    return unless @like
    
    @like.destroy
    redirect_back(fallback_location: root_path)
  end
end

def type_subject?(params)
  type = 'post' if params.key?('post_id')
  type = 'comment' if params.key?('comment_id')
  subject = Post.find(params[:post_id]) if type == 'post'
  subject = Comment.find(params[:comment_id]) if type == 'comment'
  
  [type, subject]
end

resources :posts, only: %i[index new create show destroy] do
  resources :likes, only: %i[create]
end
resources :comments, only: %i[new create destroy] do
  resources :likes, only: %i[create]
end

def already_liked?(type)
  result = false
  if type == 'post'
    result = Like.where(user_id: current_user.id,
                        post_id: params[:post_id]).exists?
  end
  if type == 'comment'
    result = Like.where(user_id: current_user.id,
                        comment_id: params[:comment_id]).exists?
  end
  result
end

def dislike(type)
  @like = Like.find_by(post_id: params[:post_id]) if type ==
                                                  'post'
  @like = Like.find_by(comment_id: params[:comment_id]) if type ==
                                                        'comment'
  return unless @like
    
  @like.destroy
  redirect_back(fallback_location: root_path)
end

module ApplicationHelper
  # Checks whether a post or comment has already been liked by the 
  # current user returning either true or false
  def liked?(subject, type)
    result = false
    result = Like.where(user_id: current_user.id, post_id: 
                        subject.id).exists? if type == 'post'
    result = Like.where(user_id: current_user.id, comment_id: 
                        subject.id).exists? if type == 'comment'
    result
  end
end

module ApplicationHelper
  def friend_request_sent?(user)
    current_user.friend_sent.exists?(sent_to_id: user.id, status: false)
  end
  
  def friend_request_received?(user)
    current_user.friend_request.exists?(sent_by_id: user.id, status: false)
  end
  
  # Checks whether a user has had a friend request sent to them by the current user or 
  # if the current user has been sent a friend request by the user returning either true or false
  def possible_friend?(user)
    request_sent = current_user.friend_sent.exists?(sent_to_id: user.id)
    request_received = current_user.friend_request.exists?(sent_by_id: user.id)
    
    return true if request_sent != request_recieved    
    return true if request_sent == request_recieved && request_sent == true    
    return false if request_sent == request_recieved && request_sent == false
  end
end

def friend_request_sent?(user)
  current_user.friend_sent.exists?(sent_to_id: user.id, status: false)
end

def friend_request_received?(user)
  current_user.friend_request.exists?(sent_by_id: user.id, status: false)
end

def possible_friend?(user)
  request_sent = current_user.friend_sent.exists?(sent_to_id: user.id)
  request_received = current_user.friend_request.exists? (sent_by_id: user.id)

  return true if request_sent != request_recieved
  return true if request_sent == request_recieved && request_sent == true
  return false if request_sent == request_recieved && request_sent == false
end

class FriendshipsController < ApplicationController
  include ApplicationHelper

  def create
    return if current_user.id == params[:user_id] # Disallow the ability to send yourself a friend request
    # Disallow the ability to send friend request more than once to same person
    return if friend_request_sent?(User.find(params[:user_id]))
    # Disallow the ability to send friend request to someone who already sent you one
    return if friend_request_recieved?(User.find(params[:user_id]))

    @user = User.find(params[:user_id])
    @friendship = current_user.friend_sent.build(sent_to_id: params[:user_id])
    if @friendship.save
      flash[:success] = 'Friend Request Sent!'
      @notification = new_notification(@user, @current_user.id, 'friendRequest')
      @notification.save
    else
      flash[:danger] = 'Friend Request Failed!'
    end
    redirect_back(fallback_location: root_path)
  end

  def accept_friend
    @friendship = Friendship.find_by(sent_by_id: params[:user_id], sent_to_id: current_user.id, status: false)
    return unless @friendship # return if no record is found

    @friendship.status = true
    if @friendship.save
      flash[:success] = 'Friend Request Accepted!'
      @friendship2 = current_user.friend_sent.build(sent_to_id: params[:user_id], status: true)
      @friendship2.save
    else
      flash[:danger] = 'Friend Request could not be accepted!'
    end
    redirect_back(fallback_location: root_path)
  end

  def decline_friend
    @friendship = Friendship.find_by(sent_by_id: params[:user_id], sent_to_id: current_user.id, status: false)
    return unless @friendship # return if no record is found

    @friendship.destroy
    flash[:success] = 'Friend Request Declined!'
    redirect_back(fallback_location: root_path)
  end
end

def create
  return if current_user.id == params[:user_id]
  return if friend_request_sent?(User.find(params[:user_id]))
  return if friend_request_received?(User.find(params[:user_id]))

  @user = User.find(params[:user_id])
  @friendship = current_user.friend_sent.build(sent_to_id: 
                                         params[:user_id])
  if @friendship.save
    flash[:success] = 'Friend Request Sent!'
    @notification = new_notification(@user, @current_user.id, 
                                     'friendRequest')
    @notification.save
  else
    flash[:danger] = 'Friend Request Failed!'
  end
  redirect_back(fallback_location: root_path)
end

@friendship = current_user.friend_sent.build(sent_to_id: params[:user_id])

def accept_friend
  @friendship = Friendship.find_by(sent_by_id: params[:user_id], sent_to_id: current_user.id, status: false)
  return unless @friendship # return if no record is found

  @friendship.status = true
  if @friendship.save
    flash[:success] = 'Friend Request Accepted!'
    @friendship2 = current_user.friend_sent.build(sent_to_id: params[:user_id], status: true)
    @friendship2.save
  else
    flash[:danger] = 'Friend Request could not be accepted!'
  end
  redirect_back(fallback_location: root_path)
end

def decline_friend
  @friendship = Friendship.find_by(sent_by_id: params[:user_id],
                                   sent_to_id: current_user.id,
                                   status: false)
  return unless @friendship # return if no record is found

    @friendship.destroy
    flash[:success] = 'Friend Request Declined!'
    redirect_back(fallback_location: root_path)
  end
end

Rails.application.routes.draw do
  root 'users#index'
  devise_for :users
  resources :users, only: %i[index show] do
    resources :friendships, only: %i[create] do
      collection do
        get 'accept_friend'
        get 'decline_friend'
      end
    end
  end
  
  put '/users/:id', to:  'users#update_img'

  resources :posts, only: %i[index new create show destroy] do
      resources :likes, only: %i[create]
  end
  resources :comments, only: %i[new create destroy] do
    resources :likes, only: %i[create]
  end
  # For details on the DSL available within this file, see https://guides.rubyonrails.org/routing.html
end

<% flash.each do |message_type, message| %>
  <%= content_tag(:div, message, class: "alert alert-#{message_type}") %>
<% end %>

<div class= "container mx-auto"> 
  <div class= "row mx-auto"> 
    <div class= "col-auto"> 
      <%= link_to posts_path, class: "text-light nav-link font-
      raleway" do%> 
        <i class="fas fa-home fa-2x"></i> Timeline 
      <%end%> 
    </div>
<!-- ...Code below not shown -->

<div class= "col-auto"> 
  <%= link_to users_path, class: "text-light nav-link font-raleway" 
  do%> 
    <i class="fas fa-users fa-2x"></i> Find Friends 
  <%end%> 
</div>

<ul class="navbar-nav ml-auto">
 <% if user_signed_in? %>
   <li class="nav-item">
     <button class="text-white btn btn-secondary", data-
     toggle="modal" data-target="#noticeModal">
       <i class="fas fa-bell"></i>
       <%= current_user.notifications.count%>
     </button>
   </li>
<!-- ... -->

<div class="dropdown-menu" aria-labelledby="navbarDropdown">
  <%= link_to "My Profile", user_path(current_user), class: "dropdown-item font-raleway" %>
  <%= link_to "Log out", destroy_user_session_path, class: "dropdown-item font-raleway", method: :delete %>
</div>

<% if user_signed_in? %>
  <%= render 'shared/notifications', object:
  current_user.notifications%>
<%end%>

<body>
  <%= render 'layouts/header' %>
  <div class='container'>
    <br>
    <%= render 'layouts/flash' %>
    <%= yield %>
  </div>
</body>

<div class="modal-body">
  <h5 class="modal-title" id="imageUploadModalLabel"> Change Profile
  Picture </h5>
  <%= form_for(object, html: { method: :put }) do |f| %>
    <%= render "devise/shared/error_messages", resource: object %>
    <div class="field">
      <%= f.label :Profile_image %><br />
      <%= f.file_field :image, accept:
      'image/jpeg,image/gif,image/png' %>
    </div>
    <div class="actions">
      <%= f.submit "Update" %>
    </div>
  <% end %>
</div>

<%= form_for(object, html: { method: :put }) do |f| %>
    <%= render "devise/shared/error_messages", resource: object %>

<%= render 'shared/imageUploadModal', object: @user%>

<script type="text/javascript">
document.getElementById('user_image').addEventListener('change', function() {
  var size_in_megabytes = this.files[0].size/1024/1024;
  if (size_in_megabytes > 1) {
    alert('Maximum file size is 1 MB. Please choose a smaller      
    file.');
  }
});
</script>

<div class="modal-body">
  <% object.each do |n|%>
  <!--If Notification type is a Friend Request -->
    <% if n.notice_type == "friendRequest"%>
      <% user = notification_find(n, 'friendRequest')%>
      <%= "Friend Request sent from #{user.full_name}" %>
    <% end %>

<% if user_signed_in? %>
  <%= render 'shared/notifications', object:
  current_user.notifications%>
<%end%>

<!-- ...Code above not shown -->
<div class="modal-body">
  <% object.each do |n|%>
    <!-- If Notification type is a Friend Request -->
    <% if n.notice_type == "friendRequest"%>
      <% user = notification_find(n, 'friendRequest')%>
      <%= "Friend Request sent from #{user.full_name}" %>
    <% end %>
    <!-- If Notification type is a comment -->
    <% if n.notice_type == "comment"%>
      <%= link_to post_path(notification_find(n, 'comment')) do %>
         Someone commented on your post
      <% end %>
    <% end %>
    <!-- If Notification type is a liked post -->
    <% if n.notice_type == "like-post"%>
      <%= link_to post_path(notification_find(n, 'like-post')) do %>
         Someone liked your post
      <% end %>
    <% end %>
    <!-- If Notification type is a liked comment -->
    <% if n.notice_type == "like-comment"%>
      <%= link_to post_path(notification_find(n, 'like-comment')) do %>
         Someone liked your comment under this post
      <% end %>
    <% end %>          
    <br>
  <% end %>
</div>

<%= form_for @comment = Comment.new do |f| %>

<%= distance_of_time_in_words(c.created_at, Time.now) %>

<%= render 'likes/like_comments', object: c%>

<span>
<%= object.likes.count %>

<%= link_to comment_likes_path(object), class: "text-light", method: :post do %>
  <% if liked?(subject = object, type = 'comment') %>
      <button class="btn btn-liked size-12"><i class="fas fa-thumbs-up"></i></button>
    <% else %>
      <button class="btn btn-neutral size-12"><i class="fas fa-thumbs-up"></i></button>
  <% end %>
<% end %>
Likes
</span>

<span>
<%= object.likes.count %>

<%= link_to post_likes_path(object), class: "text-light", method: :post do %>
  <% if liked?(object, 'post') %>
      <button class="btn btn-liked"><i class="fas fa-thumbs-up"></i></button>
    <% else %>
      <button class="btn btn-neutral"><i class="fas fa-thumbs-up"></i></button>
  <% end %>
<% end %>
Likes
</span>

<%= link_to post_likes_path(object), class: "text-light", method: :post do %>

<h1>Post</h1>
<%= render 'posts/post_layout', object: @post %>

<h1> Timeline - My posts and my friends posts</h1>
<div class="center font-raleway ">
  <%= link_to new_post_path, class: "btn btn-secondary" do%>
    New Post?
  <%end%>
</div>

<% @our_posts.each do |p|%>
  <%= render 'posts/post_layout', object: p %>
<% end %>

<% unless @friends.empty? %>
...
<% unless @pending_requests.empty? %>
...
<% unless @friend_requests.empty? %>
...

<!-- ...Doesn't show all code up above -->
<% unless @friend_requests.empty? %>
  <div class="card my-5 py-3 bg-light shadow">
      <h2 class="center pb-3 text-dark border-bottom">Pending Friend Requests</h2> 
      <% @friend_requests.each do |user|%> <!-- Shows all users friend requests has been sent to -->
        <div class="d-flex align-items-center mb-2 border-bottom py-2">
          <div class="col-auto p-0 pl-5 text-capitalize"> 
            <%= link_to user_path(user) do %>
            <%= user.full_name %>
            <% end %>
          </div>
          <div class="col-auto p-0 px-1">|</div>
          <div class="col-auto p-0">
            <button class= "btn btn-pending shadow" data-toggle="modal" data-target="#decisionModal">
                <i class="fas fa-envelope"></i> Pending Friend Request... 
            </button>
          </div>
        </div>
          <%= render 'friendships/decisionModal', object: user %>
        <br><br>
      <% end %>
  </div>
<% end %>
<!-- ...Doesn't show all code down below -->

<!-- Modal -->
<div class="modal fade" id="decisionModal" tabindex="-1" role="dialog" aria-labelledby="decisionModal" aria-hidden="true">
  <div class="modal-dialog" role="document">
    <div class="modal-content">
      <div class="modal-body">
        <h5 class="modal-title" id="decisionModalLabel">Friend Request from <%= "#{object.full_name}" %></h5>
      </div>
      <div class="modal-footer">
        <%= link_to accept_friend_user_friendships_path(object) do %>
          <button type="button" class="btn btn-accept text-white font-weight-bold"> <i class="fas fa-user-check"></i> Accept</button>
        <% end %>
        <%= link_to decline_friend_user_friendships_path(object) do %>
          <button type="button" class="btn btn-decline text-white font-weight-bold"><i class="fas fa-user-times"></i> Decline</button>
        <% end %>
      </div>
    </div>
  </div>
</div>

FACEBOOK_APP_ID = 'FILL IN WITH YOUR APP ID'
FACEBOOK_APP_SECRET = 'FILL IN WITH YOUR APP SECRET'

$ rails g migration AddOmniauthToUsers provider:string uid:string

$ rails db:migrate

class User < ApplicationRecord
  has_many :posts
  has_many :comments, dependent: :destroy
  has_many :likes, dependent: :destroy
  has_many :friend_sent, class_name: 'Friendship', foreign_key: 'sent_by_id', inverse_of: 'sent_by', dependent: :destroy
  has_many :friend_request, class_name: 'Friendship', foreign_key: 'sent_to_id',
                            inverse_of: 'sent_to', dependent: :destroy
  has_many :friends, -> { merge(Friendship.friends) }, through: :friend_sent, source: :sent_to
  has_many :pending_requests, -> { merge(Friendship.not_friends) }, through: :friend_sent, source: :sent_to
  has_many :recieved_requests, -> { merge(Friendship.not_friends) }, through: :friend_request, source: :sent_by
  has_many :notifications, dependent: :destroy
  mount_uploader :image, PictureUploader
  # Include default devise modules. Others available are:
  # :confirmable, :lockable, :timeoutable, :trackable and :omniauthable
  devise :database_authenticatable, :registerable,
         :recoverable, :rememberable, :validatable,
         :omniauthable, omniauth_providers: %i[facebook]
  validates :fname, length: { in: 3..15 }, presence: true
  validates :lname, length: { in: 3..15 }, presence: true
  validate :picture_size

  def full_name
    "#{fname} #{lname}"
  end

  # Returns all posts from this user's friends and self
  def friends_and_own_posts
    myfriends = friends
    our_posts = []
    myfriends.each do |f|
      f.posts.each do |p|
        our_posts << p
      end
    end

    posts.each do |p|
      our_posts << p
    end

    our_posts
  end

  def self.from_omniauth(auth)
    where(provider: auth.provider, uid: auth.uid).first_or_create do |user|
      user.email = auth.info.email
      user.password = Devise.friendly_token[0, 20]
      user.fname = auth.info.first_name # assuming the user model has a first name
      user.lname = auth.info.last_name # assuming the user model has a last name
      user.image = auth.info.image # assuming the user model has an image
      # If you are using confirmable and the provider(s) you use validate emails,
      # uncomment the line below to skip the confirmation emails.
      # user.skip_confirmation!
    end
  end

  def self.new_with_session(params, session)
    super.tap do |user|
      if (data = session['devise.facebook_data'] && session['devise.facebook_data']['extra']['raw_info'])
        user.email = data['email'] if user.email.blank?
      end
    end
  end

  private

  # Validates the size of an uploaded picture.
  def picture_size
    errors.add(:image, 'should be less than 1MB') if image.size > 1.megabytes
  end
end

def self.from_omniauth(auth)
    where(provider: auth.provider, uid: auth.uid).first_or_create do
    |user|
      user.email = auth.info.email
      user.password = Devise.friendly_token[0, 20]
      user.fname = auth.info.first_name
      user.lname = auth.info.last_name
      user.image = auth.info.image
    end
end

Devise.setup do |config|
  # ...Doesn't show other code up above
  config.action_mailer.default_url_options = { host: 'localhost', port: 3000 }
  
  config.omniauth :facebook,  ENV['FACEBOOK_APP_ID'], ENV['FACEBOOK_APP_SECRET'], 
                    token_params: { parse: :json }, scope: 'public_profile,email',
                    info_fields: 'email,first_name,last_name,gender,birthday,location,picture'
end

Rails.application.routes.draw do
  root 'users#index'
  devise_for :users, controllers: { omniauth_callbacks: 'users/omniauth_callbacks' }
  resources :users, only: %i[index show] do
  resources :users, only: %i[index show] do
    resources :friendships, only: %i[create] do
      collection do
        get 'accept_friend'
        get 'decline_friend'
      end
    end
  end
  
  put '/users/:id', to:  'users#update_img'

  resources :posts, only: %i[index new create show destroy] do
      resources :likes, only: %i[create]
  end
  resources :comments, only: %i[new create destroy] do
    resources :likes, only: %i[create]
  end
  # For details on the DSL available within this file, see https://guides.rubyonrails.org/routing.html
end

devise_for :users, controllers: { omniauth_callbacks:'users/omniauth_callbacks' }

$ heroku create

$ git push heroku master

$ heroku run rails db:migrate

$ heroku config:set FACEBOOK_APP_ID=YOURFACEBOOKAPPID

$ heroku config:set FACEBOOK_APP_SECRET=YOURFACEBOOKAPPSECRET

$ heroku open