module ApplicationCable
          
        
      
        

          

            
            

            

              class Channel < ActionCable::Channel::Base
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            
            

            

            module ApplicationCable
          
        
      
        

          

            
            

            

              class Connection < ActionCable::Connection::Base
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class ApplicationController < ActionController::Base
          
        
      
        

          

            1
            

            

                before_action :set_current_user
          
        
      
        

          

            1
            

            

                def set_current_user
          
        
      
        

          

            
            

            

                    # finds user with session data and stores it if present
          
        
      
        

          

            34
            

            

                    @current_user = User.find_by(email: session[:user_email]) if session[:user_email]
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            1
            

            

                def require_user_logged_in!
          
        
      
        

          

            
            

            

                    # allows only logged in user
          
        
      
        

          

            2
            

            

                    redirect_to root_path, alert: 'You must be signed in' if @current_user.nil?
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class BlueprintsController < ApplicationController
          
        
      
        

          

            1
            

            

                layout "layouts/blueprints" 
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def index
          
        
      
        

          

            
            

            

                    # sending data to 3d module
          
        
      
        

          

            
            

            

                    # render '/docs/index.html'
          
        
      
        

          

            
            

            

                    # ADDED HERE, read the saved floorplan.json from public folder, render in 3D when page is opened
          
        
      
        

          

            4
            

            

                    @snapshot = JSON.parse(File.read(Rails.root.join('public', 'floorplan.json')))
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class HomeController < ApplicationController
          
        
      
        

          

            1
            

            

              def index
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class ItemsController < ApplicationController
          
        
      
        

          

            1
            

            

              before_action :set_item, only: %i[ show edit update destroy ]
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # POST /items or /items.json
          
        
      
        

          

            1
            

            

              def create
          
        
      
        

          

            4
            

            

                @item = Item.new(item_params)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            4
            

            

                if @item.save
          
        
      
        

          

            2
            

            

                  render json: @item, status: :ok
          
        
      
        

          

            
            

            

                else
          
        
      
        

          

            2
            

            

                  render json: @item.errors, status: :unprocessable_entity
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

                
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # search for items by step_id
          
        
      
        

          

            1
            

            

              def search
          
        
      
        

          

            2
            

            

                @items = Item.where(step_id: params[:step_id])
          
        
      
        

          

            2
            

            

                render json: @items
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

              
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # PATCH/PUT /items/1 or /items/1.json
          
        
      
        

          

            1
            

            

              def update
          
        
      
        

          

            1
            

            

                if @item.update(item_params)
          
        
      
        

          

            1
            

            

                  render json: @item, status: :ok
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # DELETE /items/1 or /items/1.json
          
        
      
        

          

            1
            

            

              def destroy
          
        
      
        

          

            2
            

            

                @item.destroy
          
        
      
        

          

            2
            

            

                respond_to do |format|
          
        
      
        

          

            4
            

            

                  format.json { head :no_content }
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              private
          
        
      
        

          

            
            

            

                # Use callbacks to share common setup or constraints between actions.
          
        
      
        

          

            1
            

            

                def set_item
          
        
      
        

          

            3
            

            

                  @item = Item.find(params[:id])
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Only allow a list of trusted parameters through.
          
        
      
        

          

            1
            

            

                def item_params
          
        
      
        

          

            5
            

            

                  params.require(:item).permit(:name, :model, :width, :length, :depth, :rotation, :description, :xpos, :ypos, :zpos, :step_id, :setup_start_time, :setup_end_time, :breakdown_start_time, :breakdown_end_time)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class PlansController < ApplicationController
          
        
      
        

          

            1
            

            

              before_action :set_plan, only: %i[ show edit update destroy ]
          
        
      
        

          

            
            

            

              
          
        
      
        

          

            15
            

            

              before_action :require_user_logged_in!, unless: -> { !Rails.env.production? }
          
        
      
        

          

            
            

            

              
          
        
      
        

          

            
            

            

              # def user_plans
          
        
      
        

          

            
            

            

              #   @user = User.from_omniauth(request.env['omniauth.auth'])
          
        
      
        

          

            
            

            

              #   @plans = @user.plans
          
        
      
        

          

            
            

            

              # end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def upload_existing_plan
          
        
      
        

          

            
            

            

                # Process the uploaded file
          
        
      
        

          

            
            

            

              
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Redirect to a different page upon successful file upload
          
        
      
        

          

            1
            

            

                redirect_to plans_path, notice: 'File uploaded successfully.'
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

              
          
        
      
        

          

            1
            

            

              layout "layouts/empty", only: [:new] 
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # GET /plans or /plans.json
          
        
      
        

          

            1
            

            

              def index
          
        
      
        

          

            
            

            

                # @plans = Plan.all
          
        
      
        

          

            
            

            

                # Only display plans of the logged in user
          
        
      
        

          

            1
            

            

                @plans = Plan.where(owner: session[:user_email])
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # GET /plans/1 or /plans/1.json
          
        
      
        

          

            1
            

            

              def show
          
        
      
        

          

            1
            

            

                redirect_to edit_plan_path(@plan)
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # GET /plans/new
          
        
      
        

          

            1
            

            

              def new
          
        
      
        

          

            1
            

            

                @plan = Plan.new
          
        
      
        

          

            1
            

            

                @plan.steps.build # Build an empty Step associated with the new Plan
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # GET /plans/1/edit
          
        
      
        

          

            1
            

            

              def edit
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def floorplans2d
          
        
      
        

          

            1
            

            

                @plan = Plan.find(params[:id])
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

              
          
        
      
        

          

            1
            

            

              def preview3d
          
        
      
        

          

            4
            

            

                snapshot_data_json = params[:snapshot_data]
          
        
      
        

          

            4
            

            

                snapshot_data = JSON.parse(snapshot_data_json)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            4
            

            

                scaler = 31.4
          
        
      
        

          

            4
            

            

                json_content = JSON.parse(File.read(Rails.root.join('lib', 'design.room3d')))
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Update the corners of the floorplan
          
        
      
        

          

            4
            

            

                json_content["floorplan"]["corners"] = {
          
        
      
        

          

            
            

            

                  "7922010e-f5f3-2e53-46f4-3819ea8cdc12" => {
          
        
      
        

          

            
            

            

                    "x" => 0,
          
        
      
        

          

            
            

            

                    "y" => 0,
          
        
      
        

          

            
            

            

                  },
          
        
      
        

          

            
            

            

                  "a8b17dd7-026c-de11-3077-01a169d1b795" => {
          
        
      
        

          

            
            

            

                    "x" => snapshot_data["venue_width"] * scaler,
          
        
      
        

          

            
            

            

                    "y" => 0,
          
        
      
        

          

            
            

            

                  },
          
        
      
        

          

            
            

            

                  "8039b51e-5a0b-8843-3129-32e647a42002" => {
          
        
      
        

          

            
            

            

                    "x" => 0,
          
        
      
        

          

            
            

            

                    "y" => snapshot_data["venue_length"] * scaler,
          
        
      
        

          

            
            

            

                  },
          
        
      
        

          

            
            

            

                  "8a66d562-2eb4-2147-763c-7962e4208a0a" => {
          
        
      
        

          

            
            

            

                    "x" => snapshot_data["venue_width"] * scaler,
          
        
      
        

          

            
            

            

                    "y" => snapshot_data["venue_length"] * scaler,
          
        
      
        

          

            
            

            

                  }
          
        
      
        

          

            
            

            

                }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Add items to the floorplan
          
        
      
        

          

            4
            

            

                snapshot_data["items"].each do |item, values|
          
        
      
        

          

            4
            

            

                  json_content["items"].append({
          
        
      
        

          

            
            

            

                    "item_name" => values["item_name"],
          
        
      
        

          

            
            

            

                    "item_type" => values["item_type"],
          
        
      
        

          

            
            

            

                    "model_url" => values["item_model"],
          
        
      
        

          

            
            

            

                    "xpos" => values["item_xpos"] * scaler,
          
        
      
        

          

            
            

            

                    "ypos" => 0,
          
        
      
        

          

            
            

            

                    "zpos" => values["item_zpos"] * scaler,
          
        
      
        

          

            
            

            

                    "rotation" => 0,
          
        
      
        

          

            
            

            

                    "scale_x" => 1,
          
        
      
        

          

            
            

            

                    "scale_y" => 1,
          
        
      
        

          

            
            

            

                    "scale_z" => 1,
          
        
      
        

          

            
            

            

                    "fixed" => false
          
        
      
        

          

            
            

            

                  })
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Write the updated information to a JSON file stored in the public folder called "floorplan.json"
          
        
      
        

          

            4
            

            

                File.write(Rails.root.join('public', 'floorplan.json'), JSON.pretty_generate(json_content))
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            4
            

            

                redirect_to blueprints_path
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # POST /plans or /plans.json
          
        
      
        

          

            1
            

            

              def create
          
        
      
        

          

            1
            

            

                @plan = Plan.new(plan_params)
          
        
      
        

          

            1
            

            

                respond_to do |format|
          
        
      
        

          

            1
            

            

                  if @plan.save
          
        
      
        

          

            2
            

            

                    format.html { redirect_to plans_path, notice: "Plan was successfully created." }
          
        
      
        

          

            
            

            

                  # else # Currently doesn't handle error cases
          
        
      
        

          

            
            

            

                  #   format.html { render :new, status: :unprocessable_entity }
          
        
      
        

          

            
            

            

                  #   format.json { render json: @plan.errors, status: :unprocessable_entity }
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # PATCH/PUT /plans/1 or /plans/1.json
          
        
      
        

          

            1
            

            

              def update
          
        
      
        

          

            2
            

            

                respond_to do |format|
          
        
      
        

          

            2
            

            

                  if update_plan_with_steps
          
        
      
        

          

            4
            

            

                    format.html { redirect_to plans_path, notice: 'Plan was successfully updated.' }
          
        
      
        

          

            2
            

            

                    format.json { render :show, status: :ok, location: @plan }
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def update_plan_with_steps
          
        
      
        

          

            2
            

            

                if plan_params[:steps_attributes].nil?
          
        
      
        

          

            1
            

            

                  return @plan.update(plan_params)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            1
            

            

                steps_attributes = plan_params[:steps_attributes].to_unsafe_h
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                steps_attributes.each do |key, step_params|
          
        
      
        

          

            1
            

            

                  %i[start_time end_time break1_start_time break1_end_time break2_start_time break2_end_time].each do |attr|
          
        
      
        

          

            6
            

            

                    step_params[attr] = combine_date_and_time(step_params[:start_date], step_params[attr])
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                @plan.update(plan_params.merge(steps_attributes: steps_attributes))
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def combine_date_and_time(date, time)
          
        
      
        

          

            6
            

            

                return nil if date.blank? || time.blank?
          
        
      
        

          

            6
            

            

                DateTime.parse("#{date} #{time} #{Time.zone.now.strftime("%Z")}")
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # DELETE /plans/1 or /plans/1.json
          
        
      
        

          

            1
            

            

              def destroy
          
        
      
        

          

            1
            

            

                @plan.destroy
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                respond_to do |format|
          
        
      
        

          

            2
            

            

                  format.html { redirect_to plans_url, notice: "Plan was successfully destroyed." }
          
        
      
        

          

            1
            

            

                  format.json { head :no_content }
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              private
          
        
      
        

          

            
            

            

                # Use callbacks to share common setup or constraints between actions.
          
        
      
        

          

            1
            

            

                def set_plan
          
        
      
        

          

            5
            

            

                  @plan = Plan.find(params[:id])
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Only allow a list of trusted parameters through.
          
        
      
        

          

            1
            

            

                def plan_params
          
        
      
        

          

            
            

            

                  # params.require(:plan).permit(:name, :owner, :venue_length, :venue_width, :user_email, steps_attributes: [:id, :start_date, :start_time, :end_time, :break1_start_time, :break1_end_time, :break2_start_time, :break2_end_time, :_destroy])
          
        
      
        

          

            6
            

            

                  params.require(:plan).permit(:name, :owner, :timezone, :venue_length, :venue_width, steps_attributes: [:id, :start_date, :start_time, :end_time, :break1_start_time, :break1_end_time, :break2_start_time, :break2_end_time, :_destroy])
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class SessionsController < ApplicationController
          
        
      
        

          

            1
            

            

                def new; end
          
        
      
        

          

            1
            

            

                def create
          
        
      
        

          

            3
            

            

                  if Rails.env.production?
          
        
      
        

          

            2
            

            

                    @user = User.from_omniauth(request.env['omniauth.auth'])
          
        
      
        

          

            2
            

            

                    logger.info("IN PRODUCTION")
          
        
      
        

          

            2
            

            

                    if @user.present?
          
        
      
        

          

            
            

            

                      # session[:user_id] = @user.id
          
        
      
        

          

            1
            

            

                      session[:user_email] = @user.email
          
        
      
        

          

            1
            

            

                      redirect_to plans_path, notice: 'Logged in successfully as ' + @user.email
          
        
      
        

          

            1
            

            

                      logger.info(@user.id)
          
        
      
        

          

            
            

            

                    else
          
        
      
        

          

            1
            

            

                      flash.alert = "User not found."
          
        
      
        

          

            1
            

            

                      flash.now[:alert] = 'Invalid request'
          
        
      
        

          

            1
            

            

                      redirect_to root_path, notice: 'Invalid username/email or password'
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  else
          
        
      
        

          

            1
            

            

                    logger.info("NOT IN PRODUCTION")
          
        
      
        

          

            1
            

            

                    @user = User.new(name: "Dummy User", email: "test@email.com")
          
        
      
        

          

            1
            

            

                    session[:user_email] = @user.email
          
        
      
        

          

            1
            

            

                    redirect_to plans_path, notice: 'Logged in successfully'
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

                
          
        
      
        

          

            1
            

            

                def destroy
          
        
      
        

          

            
            

            

                  # deletes user session
          
        
      
        

          

            1
            

            

                  session[:user_id] = nil 
          
        
      
        

          

            1
            

            

                  redirect_to root_path, notice: 'Logged Out'
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module ApplicationHelper
          
        
      
        

          

            
            

            

                
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module ItemsHelper
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module PlansHelper
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module StepsHelper
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            
            

            

            class ApplicationJob < ActiveJob::Base
          
        
      
        

          

            
            

            

              # Automatically retry jobs that encountered a deadlock
          
        
      
        

          

            
            

            

              # retry_on ActiveRecord::Deadlocked
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Most jobs are safe to ignore if the underlying records are no longer available
          
        
      
        

          

            
            

            

              # discard_on ActiveJob::DeserializationError
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class ApplicationMailer < ActionMailer::Base
          
        
      
        

          

            1
            

            

              default from: "from@example.com"
          
        
      
        

          

            1
            

            

              layout "mailer"
          
        
      
        

          

            
            

            

              
          
        
      
        

          

            1
            

            

              def example_email(user)
          
        
      
        

          

            1
            

            

                @user = user
          
        
      
        

          

            1
            

            

                mail(to: @user.email, subject: 'Subject of the email')
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class ApplicationRecord < ActiveRecord::Base
          
        
      
        

          

            1
            

            

              primary_abstract_class
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class Item < ActiveRecord::Base
          
        
      
        

          

            1
            

            

                belongs_to :step
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class Plan < ActiveRecord::Base
          
        
      
        

          

            1
            

            

                has_many :steps, dependent: :destroy
          
        
      
        

          

            1
            

            

                accepts_nested_attributes_for :steps, allow_destroy: true # allows steps to be destroyed when plan is destroyed
          
        
      
        

          

            
            

            

                # belongs_to :user
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class Step < ActiveRecord::Base
          
        
      
        

          

            1
            

            

                belongs_to :plan
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                has_many :items, dependent: :destroy
          
        
      
        

          

            1
            

            

                accepts_nested_attributes_for :items, allow_destroy: true # allows items to be destroyed when step is destroyed
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class User < ApplicationRecord
          
        
      
        

          

            
            

            

                # adds virtual attributes for authentication
          
        
      
        

          

            1
            

            

                has_secure_password
          
        
      
        

          

            
            

            

                # validates user_name
          
        
      
        

          

            1
            

            

                validates :name, presence: true, uniqueness: true
          
        
      
        

          

            
            

            

                # validates email
          
        
      
        

          

            1
            

            

                validates :email, presence: true, uniqueness: true, format: { with: /\A[^@\s]+@[^@\s]+\z/, message: 'Invalid email' }
          
        
      
        

          

            
            

            

                
          
        
      
        

          

            
            

            

                # relationship with Floorplan
          
        
      
        

          

            
            

            

                # has_many :plans
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def self.from_omniauth(access_token)
          
        
      
        

          

            2
            

            

                    data = access_token.info
          
        
      
        

          

            2
            

            

                    email = data['email']
          
        
      
        

          

            2
            

            

                    name = data['name']
          
        
      
        

          

            2
            

            

                    password = SecureRandom.urlsafe_base64(20).tr('lIO0', 'sxyz')
          
        
      
        

          

            
            

            

                    
          
        
      
        

          

            
            

            

                    # User.find_or_create_by(email:)
          
        
      
        

          

            2
            

            

                    where(email: email).first_or_create do |user|
          
        
      
        

          

            1
            

            

                        user.email          = email
          
        
      
        

          

            1
            

            

                        user.name           = name
          
        
      
        

          

            1
            

            

                        user.password = password
          
        
      
        

          

            1
            

            

                        user.password_confirmation = password
          
        
      
        

          

            
            

            

                        # user.initial_access = Time.now
          
        
      
        

          

            
            

            

                        # user.last_access    = Time.now
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            require 'omniauth-oauth2'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            module OmniAuth
          
        
      
        

          

            1
            

            

              module Strategies
          
        
      
        

          

            1
            

            

                class Events360 < OmniAuth::Strategies::OAuth2
          
        
      
        

          

            1
            

            

                  option :name, :events360
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  option :client_options,
          
        
      
        

          

            
            

            

                         site: ENV["NXT_APP_URL"],
          
        
      
        

          

            
            

            

                         authorize_path: "/oauth/authorize"
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  uid do
          
        
      
        

          

            1
            

            

                    raw_info["id"]
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  info do
          
        
      
        

          

            
            

            

                    {
          
        
      
        

          

            1
            

            

                      name: raw_info["name"],
          
        
      
        

          

            
            

            

                      email: raw_info["email"]
          
        
      
        

          

            
            

            

                    }
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def raw_info
          
        
      
        

          

            1
            

            

                    @raw_info ||= access_token.get("/api/user").parsed
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end