Module: Vapid::Controllers::DashboardController

Extended by:

Sinatra::Extension

Defined in:

lib/vapid/controllers/dashboard_controller.rb

Overview

Dashboard routes

Defined Under Namespace

Classes: RecordFormBuilder

Class Method Summary

• .registered(app) ⇒ Object

  rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, MethodLength.

Class Method Details

.registered(app) ⇒ Object

rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, MethodLength

# File 'lib/vapid/controllers/dashboard_controller.rb', line 45

def self.registered(app)
  # rubocop:disable Lint/NestedMethodDefinition
  app.helpers do
    def installed!
      if ActiveRecord::Migrator.current_version.zero? || !Models::User.any?
        redirect "/dashboard/install" unless dashboard_action == "install"
        false
      else
        redirect "/dashboard" if dashboard_action == "install"
        true
      end
    end

    def authenticated!
      if !current_user
        redirect "/dashboard/login" unless %w(login logout).include?(dashboard_action)
        false
      else
        true
      end
    end

    def dashboard_action
      request.path_info.split("/")[2]
    end

    def render_dashboard_template(template)
      render_view template, layout: :dashboard
    end

    def render_auth_template(template)
      render_view template, layout: :modal
    end

    def dashboard_partial(template, options = {}, &block)
      partial "dashboard/#{template}", options, &block
    end

    def record_form_for(name, *args, &block)
      options = args.extract_options!
      args << options.merge(builder: RecordFormBuilder)
      form_for(name, *args, &block)
    end

    def group_or_records_path(group)
      path = if group.records.empty?
        "/new"
      elsif group.repeating?
        ""
      else
        "/#{group.records.first.id}/edit"
      end

      "/dashboard/groups/#{group.id}/records#{path}"
    end

    def flash_class(level)
      case level
      when :success then "ui positive message"
      when :error then "ui negative message"
      when :notice then "ui warning message"
      end
    end

    def current_user
      @current_user ||= Vapid::Models::User.find_by(id: session[:user_id])
    end

    def all_groups
      Models::Group.with_fields
    end

    def current_group
      Models::Group.find_by!(id: params[:group_id]) if params[:group_id]
    end

    def current_record
      Models::Record.joins(:group).find_by(id: params[:id]) if params[:id]
    end

    def livereload
      if settings.development?
        cache_clear
        FileUtils.touch(settings.reload)
      end
    end

    def run_builder
      CLI.new.invoke(:build)
    end
  end
  # rubocop:enable Lint/NestedMethodDefinition

  app.before("/dashboard/?*") do
    @groups = all_groups if installed! && authenticated!
  end

  app.namespace "/dashboard/?" do
    # TODO: Namespace before filters are currently broken on Sinatra 2.0
    # before do
    #   @groups = all_groups if installed! && authenticated!
    #   @group = current_group
    #   @record = current_record
    # end

    get do
      render_dashboard_template "dashboard/overview/index"
    end

    get "/login/?" do
      @user = Models::User.new
      render_auth_template "dashboard/login"
    end

    post "/login/?" do
      user = Models::User.authenticate(params[:vapid_models_user][:email], params[:vapid_models_user][:password])

      if user
        session[:user_id] = user.id
        redirect "/dashboard"
      else
        @user = Models::User.new email: params[:vapid_models_user][:email]
        flash.now[:error] = "Invalid Email or password."
        render_auth_template "dashboard/login"
      end
    end

    get "/logout/?" do
      session.delete(:user_id)
      redirect "/dashboard/login"
    end

    get "/install/?" do
      @code = Settings.install_code
      render_auth_template "/dashboard/install"
    end

    post "/install/?" do
      Models.migrate!

      user = Models::User.new(email: params[:email], password: params[:password])
      @code = Settings.install_code

      # TODO: Should display contextually-relevant error message
      if (@code.nil? || @code.casecmp(params[:code]).zero?) && user.save
        run_builder
        session[:user_id] = user.id
        flash[:success] = "Successfully created admin account."
        redirect "/dashboard"
      else
        flash.now[:error] = "Could not create admin account."
        render_auth_template "/dashboard/install"
      end
    end

    get "/build/?" do
      run_builder
      flash[:success] = "Site build complete."
      redirect "/dashboard"
    end

    get "/settings/?" do
      render_dashboard_template "dashboard/settings/edit"
    end

    post "/settings/?" do
      attrs = if params[:password].blank?
          params.slice(:email)
        else
          params.slice(:email, :password, :password_confirmation)
        end

      if current_user.update_attributes attrs
        flash[:success] = "Settings updated."
        redirect "/dashboard/settings"
      else
        flash.now[:error] = current_user.errors.full_messages.to_sentence
        render_dashboard_template "dashboard/settings/edit"
      end
    end

    get "/groups/:group_id/records/?" do
      @group = current_group
      @user = Vapid::Models::User.new

      render_dashboard_template "dashboard/records/index"
    end

    post "/groups/:group_id/records/?" do
      @group = current_group
      @record = @group.records.build(params[:record])

      if @record.update_content params[:record]["content"]
        flash[:success] = "Record created."
        livereload
      else
        flash[:error] = "Problem creating record."
      end
      redirect group_or_records_path(@group)
    end

    get "/groups/:group_id/records/new/?" do
      @group = current_group
      @record = @group.records.build

      render_dashboard_template "dashboard/records/new"
    end

    post "/groups/:group_id/records/:id/?" do
      @group = current_group
      @record = current_record

      if @record.update_content params[:record]["content"], params[:_destroy]
        flash[:success] = "Record updated."
        livereload
      else
        flash.now[:error] = "Problem updating record."
      end
      redirect group_or_records_path(@group)
    end

    delete "/groups/:group_id/records/:id/?" do
      @group = current_group
      @record = current_record

      if @record.destroy
        flash[:success] = "Record deleted."
        livereload
      else
        flash[:error] = "Problem deleting record."
      end
      redirect group_or_records_path(@group)
    end

    get "/groups/:group_id/records/:id/edit/?" do
      @group = current_group
      @record = current_record

      render_dashboard_template "dashboard/records/edit"
    end
  end
end