RoR Code Sample

Author: RajRoR

.gitignore

@@ -0,0 +1 @@
+.idea

RubyOnRails/README.md

@@ -0,0 +1,34 @@
+## Deck Creation & Collaboration Tool
+
+
+About Deck Creation & Collaboration Tool: Deck Creation & Collaboration Tool is application software which automate every aspect of Presentation creation.
+You can search slides within your organization, request a new slide design from your team or a external team,
+get notified of on going developemt on it, manage different version of a slide and combine a no of slide into
+a power point presentation with Click of button.
+
+It treats a Presentation as a project and make it reusable within the organization.
+
+Details of files included:
+
+Project Controller : Treat Power Point presentation as a project. The dashboard action list all the ongoing presentation within
+                     the team and allow the user to create a new one. The edit action provide ability to add or edit team memeber,
+                     tasks, calender events, meetings, coordinator , owner etc. It also show Time line showing different activiies
+                     on project in the rcent time. User get notified of any new notification in real time.
+                     
+Slide Controller : It manage the process of power point creation. The core action of this controller is desktop. The view is
+                   broadly divided into PPT carousel, Slide Library and incoming section, User can select any slides from 
+                   library or the incoming section and drag it into PPt carousel, he can suffel the slide within the PPT carousel.
+                   a Slide within the library can be searched based on text, category or tags.When user click Generate PPT button
+                   all the slides in the carousel are sent to Merger server which combine it in PPt and send it to the user email.
+                   
+User Model: It handles different user associations, authentication and authorization
+
+Project Model : It handles project business logic like due date, team members, tasks, meetings etc
+
+Slide Model : It implements Slide search within the library based on category, text and tags
+
+Lib/custom_cropper : It override paperclip's trasform method to support image cropping
+
+Lib/drive : It syncs google slide from user's google drive in the application
+
+Lib/tasks/import_country_states.rake : It import country and state list from CSV into DB

RubyOnRails/app/controllers/api/gslides_controller.rb

@@ -0,0 +1,94 @@
+class Api::GslidesController < ApplicationController
+  # This filter will be replaced by the common API auth filter, once implemented
+  before_action :authenticate_user!, except: :completion_notifier
+
+  rescue_from ActiveRecord::RecordNotFound, with: :not_found
+
+  # google_slides should be enabled to consume the API
+  require_feature :google_slides, except: :completion_notifier
+
+  # Notifies completion of the Assigned slide
+  def completion_notifier
+    # TODO: Add another constraint: (assigned_to_id: current_user.id), 
+    # once Authentication for API is in place
+    pslide = ProjectSlide.find_by!(
+                                    slide_id: params[:slide_id], 
+                                    project_id: google_slide_params[:project_id]
+                                  )
+    user = User.find(pslide.assigned_to_id) # After authentication, use current_user instead of this line of code
+    GslideImportJob.perform_later(user, pslide.project, pslide.slide)
+    head :ok
+  end
+
+  # List slides assigned to `current_user`
+  def list_assigned
+    @assigned_project_slides = ProjectSlide.joins(:slide)
+                                           .where('project_slides.project_id = ? AND project_slides.assigned_to_id = ? AND slides.gurl IS NOT ?',
+                                                  list_assigned_params[:project_id], current_user, nil)
+  end
+
+  # TODO: Assumption here is that current_user already have an access_token and refresh_token
+  # available, which at most can expire and we will re-authorize it.
+  # Ask for google drive access if not given by the user here. <eom>
+  # This returns temporary thumbnail url for assigned slide
+  def assigned_slide_url
+    pslide = ProjectSlide.find_by(id: params[:project_slide_id], assigned_to_id: current_user)
+    gsip = Google::SlideImageProcessor.new(current_user, pslide)
+    begin
+      thumb_name, raw_name = gsip.get_image_paths
+      @thumb_url = api_slide_temp_images_path(project_slide_id: pslide, image_name: thumb_name)
+      @raw_url = api_slide_temp_images_path(project_slide_id: pslide, image_name: raw_name)
+    rescue RestClient::Unauthorized => e
+      head 401
+    end
+  end
+
+  # This method responds to an Ajax call called within the application domain with logged in user
+  # Uses Devise session, API version yet to be included
+  def assigned_slide_completed
+    pslide = ProjectSlide.find(assigned_slide_completed_params[:project_slide_id])
+    GslideImportJob.perform_later(current_user, pslide.project, pslide.slide)
+
+    head :ok
+  end
+
+  # Send image preview of requested slide after an authorization check
+  def slide_temp_images
+    pslide = ProjectSlide.includes(:slide).find(params[:project_slide_id])
+    if authorize pslide.slide, :slide_assigned?
+      img_location = pslide_image_path(pslide).join(params[:image_name])
+      send_file img_location
+    else
+      head 401
+    end
+  end
+
+  private
+
+  # Derive path for temporary Slide preview image
+  def pslide_image_path(pslide)
+    derived_path = Google::SlideImageProcessor::BASE_TEMP_PATH
+                   .join(Google::SlideImageProcessor.slide_dir_name(current_user.id, pslide))
+    head 404 unless File.directory? derived_path
+    derived_path
+  end
+
+  # Returns 404 status
+  def not_found
+    head :not_found
+  end
+
+  # StrongParams filters
+
+  def list_assigned_params
+    params.permit(:project_id)
+  end
+
+  def assigned_slide_completed_params
+    params.permit(:project_slide_id)
+  end
+
+  def google_slide_params
+    params.require(:gslide_params).permit(:project_id, :user_id)
+  end
+end

RubyOnRails/lib/drive.rb

@@ -0,0 +1,88 @@
+module Google
+  module Drive
+
+    def self.included(base)
+      base.send :include, InstanceMethods
+    end
+
+    module InstanceMethods
+        #retrieve new Google AccessToken if it get expired
+        def refresh_access_token(user)
+          access_token_age = (Time.zone.now - user.google_token_updated_at)
+          if access_token_age >  APP_CONSTANTS["google_token_expire_time"]
+            client_id = Rails.application.secrets.google_drive["client_id"]
+            client_secret =  Rails.application.secrets.google_drive["client_secret"]
+            payload = "client_id=#{client_id}&client_secret=#{client_secret}&refresh_token=#{user.google_refresh_token}&grant_type=refresh_token"
+            rest_resource =  RestClient::Resource.new("https://www.googleapis.com/oauth2/v3/token")
+            response = rest_resource.post payload , :content_type => 'application/x-www-form-urlencoded'
+            new_access_token = JSON.parse(response)["access_token"]
+            # update user with new Google access token
+            user.update(google_access_token: new_access_token, google_token_updated_at: Time.now)
+          end
+        end
+
+        # Delete the file with the file_id from google drive using Google Drive API
+        def delete_current_presentation(file_id, user)
+          delete_url = "https://www.googleapis.com/drive/v2/files/#{file_id}"
+          headers = { 'Authorization': "Bearer #{user.google_access_token}", 'Content-type': 'application/json' }
+          rest_resource = RestClient::Resource.new(delete_url, :headers => headers)
+          rest_resource.delete
+        end
+
+        # Get presentation_id from Slide or Presentation URL
+        def get_presentation_id(slide_url)
+          starting_index = slide_url.index("/d/")
+          # Following string matching seems to be lengthy, But is faster the Regular Exp.
+          ending_index = slide_url.index("/present#slide") || slide_url.index("/present?slide") || slide_url.index("/edit#slide") || slide_url.index("/edit?slide")
+          return nil unless ending_index and starting_index
+          presentation_id = slide_url[starting_index + 3..ending_index-1]
+        end
+
+        # Extract slide_id from google presentation/slide url
+        def get_slide_id( slide_url )
+          idx = slide_url.index( "=id." )
+          return nil unless idx
+          slide_url.slice( idx + 4..-1 )
+        end
+
+        # Returns true if page contains text matching known messages of Unauthorization
+        def unauthorized?(browser_text)
+          !!(browser_text.match(/unauthorized/i) || browser_text.match(/You have been signed out/i))
+        end
+
+        # You can see google presentation in 2 modes.
+        # This returns string :present if slide url contains `/present?slide_id`||`/present#slide_id`
+        # Or returns string :edit if slide url contains `/edit#slide_id`||`/edit?slide_id`
+        def slide_url_mode(slide_url)
+          return :edit if slide_url.match(/\/edit(#|\?)/)
+          return :presentation if slide_url.match(/\/present(#|\?)/)
+        end
+
+        # Identifying whether it is a SlideUrl in presentation mode or Edit mode and toggles the state
+        # toggle_edit_present_slide_url('edit_url') #=> present_url
+        # toggle_edit_present_slide_url('present_url') #=> edit_url
+        # Warning : Do not use single regex for matching, Performance issues may occur
+        def toggle_edit_present_slide_url(slide_url)
+          # Identifying whether it is a SlideUrl in presentation mode or Edit mode
+          present_matchers = slide_url.match("/present#slide")
+
+          case slide_url.match(/\/(present|edit)(#|\?)/).to_s
+          when "/present#"
+            return slide_url.gsub("/present#", "/edit#")
+          when "/present?"
+            # return slide_url.gsub("/present?", "/edit#")
+            uri = Addressable::URI.parse(slide_url.gsub('/present?', '/edit?'))
+            query_values = uri.query_values || {}
+            uri.fragment = "slide=" + query_values.delete('slide') if query_values.present?
+            uri.query_values = query_values.present? ? query_values : nil
+            return uri.to_s
+          when "/edit#", "/edit?"
+            return slide_url.gsub(/\/edit(#|\?)/, "/present?")
+          else
+            return nil
+          end
+        end
+      end
+
+  end
+end

RubyOnRails/lib/slide_image_processor.rb

@@ -0,0 +1,104 @@
+module Google
+  # Fetches raw slide preview and processes it into thumbnail
+  class SlideImageProcessor
+    include Drive
+
+    # Parent directory path for storing images sub-directories
+    BASE_TEMP_PATH = Rails.root.join('temp_slide_images')
+    DIR_PREFIX = 'slide_image_dir_'.freeze
+    THUMB_PREFIX = 'processed_slide_thumb_'.freeze
+    RAW_IMAGE_PREFIX = 'raw_slide_thumb_'.freeze
+    IMAGE_EXTENSION = '.png'.freeze
+
+    DEFAULTS = { thumbnail_size: '150x150' }.freeze
+
+    attr_reader :temp_thumb_path, :raw_image_path
+
+    #
+    # SlideImageProcessor.new( <user>, <project_slide> )
+    #
+    def initialize(user, project_slide)
+      @user = user
+      @project_slide = project_slide
+      @slide = @project_slide.slide
+
+      verify_thumb_dir
+    end
+
+    # .get_image_paths( '<width>x<height>'(optional) )
+    def get_image_paths(dimensions = DEFAULTS[:thumbnail_size])
+      set_images_path
+
+      # Will return nil at success
+      return false if fetch_raw_image
+
+      image = MiniMagick::Image.open @raw_image_path
+      begin
+        image.resize dimensions
+      rescue MiniMagick::Error => e
+        raise "Cannot resize to #{dimensions} - #{e.message}"
+      end
+      image.write @temp_thumb_path
+      [@temp_thumb_path.split.last, @raw_image_path.split.last]
+    end
+
+    # #slide_dir_name( <user_id>, <project_slide_object> )
+    def self.slide_dir_name(user_id, project_slide)
+      "#{DIR_PREFIX}#{user_id}_#{project_slide.project_id}_#{project_slide.id}"
+    end
+
+    private
+
+    # Delete raw image
+    def cleanup_raw_image
+      File.delete(@raw_image_path) if File.exist?(@raw_image_path)
+    end
+
+    # Downloading slide preview from Google Docs
+    def fetch_raw_image
+      r_header = { 'Authorization' => "Bearer #{@user.google_access_token}" }
+      response = RestClient::Request.execute(method: :get, url: slide_download_url, headers: r_header)
+      img_file = File.open(@raw_image_path, 'wb')
+      img_file.write response
+      img_file.close
+    rescue RestClient::Unauthorized => e
+      puts e.inspect
+      raise RestClient::Unauthorized unless re_authorize
+      retry
+    end
+
+    def set_images_path
+      random_string = SecureRandom.hex
+      @temp_thumb_path ||= Pathname.new(@tmp_slide_dir).join("#{THUMB_PREFIX}#{random_string}#{IMAGE_EXTENSION}")
+      @raw_image_path ||= Pathname.new(@tmp_slide_dir).join("#{RAW_IMAGE_PREFIX}#{random_string}#{IMAGE_EXTENSION}")
+    end
+
+    # Creates directory for keeping thumbnail
+    # naming convention : <DIR_PREFIX>_<user_id>_<project_id>_<project_slide_id>
+    def verify_thumb_dir
+      temp_dir_name = self.class.slide_dir_name(@user.id, @project_slide)
+      @tmp_slide_dir = BASE_TEMP_PATH.join(temp_dir_name)
+      if File.directory? @tmp_slide_dir
+        FileUtils.rm_r(Dir.glob("#{@tmp_slide_dir}/*"))
+      else
+        Dir.mkdir(@tmp_slide_dir)
+      end
+    end
+
+    # Refresh auth token, with a retry pre-set limit
+    def re_authorize
+      @re_auth_tries ||= APP_CONSTANTS['authorization_tries_limit']
+      return false if @re_auth_tries < 1
+      refresh_access_token(@user)
+      @user.reload
+      @re_auth_tries -= 1
+    end
+
+    # Google Docs download url, dependent on service provider(Google Docs)
+    def slide_download_url
+      p_id = get_presentation_id(@slide.gurl)
+      s_id = get_slide_id(@slide.gurl)
+      'https://docs.google.com/presentation/d/' + p_id + '/export/png?id=' + p_id + '&pageid=' + s_id
+    end
+  end
+end

RubyOnRails/specs/controllers/api/gslides_controller_spec.rb

@@ -0,0 +1,44 @@
+require 'rails_helper'
+
+RSpec.describe Api::GslidesController, type: :controller do
+  describe '#completion_notifier' do
+    # google_slides/:slide_id
+    let(:user) do
+      user = create(:user)
+      user.skip_confirmation!
+      user
+    end
+    let(:project) { create(:project) }
+    let(:slide) { create('slide1', title: 'Library Slide1') }
+    let(:project_slide) do
+      create(:project_slide1, slide_id: slide.id,
+                              project: project, assigned_to_id: user.id)
+    end
+
+    context 'When valid params are passed' do
+      it 'should enqueue background job' do
+        expect do
+          response = get :completion_notifier, slide_id: slide.id, controller: :gslides,
+                                               action: :completion_notifier,
+                                               gslide_params: { project_id: project.id, user_id: user.id }
+        end.to change {
+          Delayed::Job.count
+        }.by(1)
+        expect(response.success?).to be_truthy
+      end
+    end
+
+    context 'When invalid params are passed' do
+      it 'should respond with 404' do
+        expect do
+          response = get :completion_notifier,
+                          slide_id: 'wrong_id',
+                          gslide_params: { project_id: 'wrong_id', user_id: 'wrong_id' }
+        end.to change {
+          Delayed::Job.count
+        }.by(0)
+        expect(response.success?).to be_falsey
+      end
+    end
+  end
+end