hackathon_manager 0.1.0

data/app/controllers/manage/dashboard_controller.rb

@@ -0,0 +1,112 @@
+class Manage::DashboardController < Manage::ApplicationController
+  def index
+  end
+
+  def map_data
+    @schools = School.where("questionnaire_count", 1..Float::INFINITY).select([:city, :state, :questionnaire_count])
+  end
+
+  def todays_activity_data
+    render json: activity_chart_data(["Applications", "Confirmations", "Denials", "Non-Applied Users"], "hour", Time.zone.today.beginning_of_day..Time.zone.today.end_of_day)
+  end
+
+  def todays_stats_data
+    date_min = Time.zone.today.beginning_of_day
+    render json: {
+      "Applications" => Questionnaire.where("created_at >= :date_min", date_min: date_min).count,
+      "Confirmations" => Questionnaire.where("acc_status = \"rsvp_confirmed\" AND acc_status_date >= :date_min", date_min: date_min).count,
+      "Denials" => Questionnaire.where("acc_status = \"rsvp_denied\" AND acc_status_date >= :date_min", date_min: date_min).count,
+      "Non-Applied Users" => User.without_questionnaire.where("users.created_at >= :date_min", date_min: date_min).count
+    }
+  end
+
+  def confirmation_activity_data
+    render json: activity_chart_data(["Confirmations", "Denials"], "day", 3.week.ago..Time.zone.now)
+  end
+
+  def application_activity_data
+    render json: activity_chart_data(["Non-RIT Applications", "RIT Applications", "Non-Applied Users"], "day", 3.week.ago..Time.zone.now)
+  end
+
+  def user_distribution_data
+    total_stats_data = {}
+    total_count = Questionnaire.count
+    rit_count = Questionnaire.where("school_id = \"2304\"").count
+    total_stats_data["Non-Applied Users"] = User.where(admin: false).count - total_count
+    total_stats_data["Non-RIT Applications"] = total_count - rit_count
+    total_stats_data["RIT Applications"] = rit_count
+    render json: total_stats_data
+  end
+
+  def application_distribution_data
+    counts = Questionnaire.group(:acc_status).count
+    results = Questionnaire::POSSIBLE_ACC_STATUS.map { |acc_status, status_title| [status_title, counts[acc_status] || 0] }
+    render json: results
+  end
+
+  def schools_confirmed_data
+    schools = Questionnaire.joins(:school).group('schools.name').where("acc_status = 'rsvp_confirmed'").order("schools.name ASC").count
+    schools_riding = Questionnaire.joins(:school).group('schools.name').where("acc_status = 'rsvp_confirmed' AND riding_bus AND schools.bus_list_id").count
+    schools = schools.map do |name, count|
+      bus_count_row = schools_riding.select { |school_bus_name, _| school_bus_name == name }
+      bus_count = bus_count_row ? bus_count_row[name] || 0 : 0
+      count_without_bus = count - bus_count
+      [name, count_without_bus, bus_count]
+    end
+    render json: [
+      { name: "Not riding bus", data: schools.sort_by { |_, no_bus, bus| [bus, no_bus] }.reverse },
+      { name: "Riding bus", data: schools_riding }
+    ]
+  end
+
+  def schools_applied_data
+    counted_schools = {
+      "pending" => {},
+      "denied" => {},
+      "rsvp_denied" => {},
+      "late_waitlist" => {},
+      "waitlist" => {},
+      "accepted" => {},
+      "rsvp_confirmed" => {}
+    }
+    # Temporary fix
+    # result = Questionnaire.joins(:school).group(:acc_status, "schools.name").where("schools.questionnaire_count >= 5").order("schools.questionnaire_count DESC").order("schools.name ASC").count
+    result = Questionnaire.joins(:school).group(:acc_status, "schools.name", "schools.questionnaire_count").order("schools.questionnaire_count DESC").where("schools.questionnaire_count >= 5").count
+    result.each do |group, count|
+      counted_schools[group[0]][group[1]] = count
+    end
+    render json: [
+      { name: "RSVP Confirmed", data: counted_schools["rsvp_confirmed"] },
+      { name: "Accepted", data: counted_schools["accepted"] },
+      { name: "Waitlisted", data: counted_schools["waitlist"] },
+      { name: "Late Waitlisted", data: counted_schools["late_waitlist"] },
+      { name: "RSVP Denied", data: counted_schools["rsvp_denied"] },
+      { name: "Denied", data: counted_schools["denied"] },
+      { name: "Pending", data: counted_schools["pending"] }
+    ]
+  end
+
+  private
+
+  def activity_chart_data(types, group_type, range)
+    chart_data = []
+    types.each do |type|
+      case type
+      when "Applications"
+        data = Questionnaire.send("group_by_#{group_type}", :created_at, range: range).count
+      when "RIT Applications"
+        data = Questionnaire.where("school_id = \"2304\"").send("group_by_#{group_type}", :created_at, range: range).count
+      when "Non-RIT Applications"
+        data = Questionnaire.where("school_id != \"2304\"").send("group_by_#{group_type}", :created_at, range: range).count
+      when "Confirmations"
+        data = Questionnaire.where(acc_status: "rsvp_confirmed").send("group_by_#{group_type}", :acc_status_date, range: range).count
+      when "Denials"
+        data = Questionnaire.where(acc_status: "rsvp_denied").send("group_by_#{group_type}", :acc_status_date, range: range).count
+      when "Non-Applied Users"
+        data = User.without_questionnaire.send("group_by_#{group_type}", "users.created_at", range: range).count
+      end
+      chart_data << { name: type, data: data }
+    end
+    chart_data
+  end
+end

data/app/controllers/manage/messages_controller.rb

@@ -0,0 +1,88 @@
+class Manage::MessagesController < Manage::ApplicationController
+  before_action :set_message, only: [:show, :edit, :update, :destroy, :deliver, :preview, :duplicate]
+  before_action :check_message_access, only: [:edit, :update, :destroy]
+
+  respond_to :html
+
+  def index
+  end
+
+  def datatable
+    render json: MessageDatatable.new(view_context)
+  end
+
+  def show
+    respond_with(:manage, @message)
+  end
+
+  def new
+    @message = Message.new
+    respond_with(:manage, @message)
+  end
+
+  def edit
+  end
+
+  def create
+    @message = Message.new(message_params)
+    @message.save
+    respond_with(:manage, @message)
+  end
+
+  def update
+    @message.update_attributes(message_params)
+    respond_with(:manage, @message)
+  end
+
+  def destroy
+    @message.destroy
+    respond_with(:manage, @message)
+  end
+
+  def deliver
+    if @message.status != "drafted"
+      flash[:notice] = "Message cannot be re-delivered"
+      return redirect_to manage_messages_path
+    end
+    @message.update_attribute(:queued_at, Time.now)
+    BulkMessageWorker.perform_async(@message.id)
+    flash[:notice] = "Message queued for delivery"
+    redirect_to manage_message_path(@message)
+  end
+
+  def preview
+    email = Mailer.bulk_message_email(@message.id, current_user.id)
+    render html: email.body.raw_source.html_safe
+  end
+
+  def duplicate
+    new_message = @message.dup
+    new_message.update_attributes(
+      delivered_at: nil,
+      started_at: nil,
+      queued_at: nil,
+      name: "Copy of #{@message.name}"
+    )
+    new_message.save
+    redirect_to edit_manage_message_path(new_message.reload)
+  end
+
+  private
+
+  def message_params
+    params.require(:message).permit(
+      :name, :subject, :template, :body, recipients: []
+    )
+  end
+
+  def set_message
+    @message = Message.find(params[:id])
+  end
+
+  def check_message_access
+    return if @message.can_edit?
+
+    flash[:notice] = "Message can no longer be modified"
+    redirect_to manage_message_path(@message)
+  end
+end

data/app/controllers/manage/questionnaires_controller.rb

@@ -0,0 +1,172 @@
+class Manage::QuestionnairesController < Manage::ApplicationController
+  include QuestionnairesControllable
+
+  before_action :set_questionnaire, only: [:show, :edit, :update, :destroy, :check_in, :convert_to_admin, :update_acc_status, :message_events, :invite_to_slack]
+
+  respond_to :html
+
+  def index
+  end
+
+  def datatable
+    render json: QuestionnaireDatatable.new(view_context)
+  end
+
+  def show
+    respond_with(:manage, @questionnaire)
+  end
+
+  def new
+    @questionnaire = ::Questionnaire.new
+    respond_with(:manage, @questionnaire)
+  end
+
+  def edit
+  end
+
+  def create
+    create_params = questionnaire_params
+    email = create_params.delete(:email)
+    create_params = convert_school_name_to_id(create_params)
+    @questionnaire = ::Questionnaire.new(create_params)
+    if @questionnaire.valid?
+      user = User.new(email: email, password: Devise.friendly_token.first(10))
+      if user.save
+        @questionnaire.user = user
+        @questionnaire.save
+      else
+        flash[:notice] = user.errors.full_messages.join(", ")
+        if user.errors.include?(:email)
+          @questionnaire.errors.add(:email, user.errors[:email].join(", "))
+        end
+        return render 'new'
+      end
+    end
+    respond_with(:manage, @questionnaire)
+  end
+
+  def update
+    update_params = questionnaire_params
+    email = update_params.delete(:email)
+    @questionnaire.user.update_attributes(email: email) if email.present?
+    update_params = convert_school_name_to_id(update_params)
+    @questionnaire.update_attributes(update_params)
+    respond_with(:manage, @questionnaire)
+  end
+
+  def check_in
+    if params[:check_in] == "true"
+      if params[:questionnaire]
+        q_params = params.require(:questionnaire).permit(:agreement_accepted, :phone, :can_share_info, :email)
+        email = q_params.delete(:email)
+        @questionnaire.update_attributes(q_params)
+        @questionnaire.user.update_attributes(email: email)
+      end
+      unless @questionnaire.valid?
+        flash[:notice] = @questionnaire.errors.full_messages.join(", ")
+        redirect_to manage_questionnaire_path @questionnaire
+        return
+      end
+      @questionnaire.update_attribute(:checked_in_at, Time.now)
+      @questionnaire.update_attribute(:checked_in_by_id, current_user.id)
+      @questionnaire.invite_to_slack
+      flash[:notice] = "Checked in #{@questionnaire.full_name}."
+    elsif params[:check_in] == "false"
+      @questionnaire.update_attribute(:checked_in_at, nil)
+      @questionnaire.update_attribute(:checked_in_by_id, current_user.id)
+      flash[:notice] = "#{@questionnaire.full_name} no longer checked in."
+    else
+      flash[:notice] = "No check-in action provided!"
+      redirect_to manage_questionnaire_path @questionnaire
+      return
+    end
+    redirect_to manage_questionnaires_path
+  end
+
+  def convert_to_admin
+    user = @questionnaire.user
+    @questionnaire.destroy
+    user.update_attributes(admin: true, admin_limited_access: true)
+    redirect_to edit_manage_admin_path(user)
+  end
+
+  def destroy
+    user = @questionnaire.user
+    @questionnaire.destroy
+    user.destroy if user.present?
+    respond_with(:manage, @questionnaire)
+  end
+
+  def update_acc_status
+    new_status = params[:questionnaire][:acc_status]
+    if new_status.blank?
+      flash[:notice] = "No status provided"
+      redirect_to(manage_questionnaire_path(@questionnaire))
+      return
+    end
+
+    @questionnaire.acc_status = new_status
+    @questionnaire.acc_status_author_id = current_user.id
+    @questionnaire.acc_status_date = Time.now
+
+    unless @questionnaire.save(validate: false)
+      flash[:notice] = "Failed to update acceptance status"
+    end
+
+    process_acc_status_notifications(@questionnaire, new_status)
+
+    redirect_to manage_questionnaire_path(@questionnaire)
+  end
+
+  def bulk_apply
+    action = params[:bulk_action]
+    ids = params[:bulk_ids]
+    if action.blank? || ids.blank?
+      head :bad_request
+      return
+    end
+    Questionnaire.find(ids).each do |q|
+      q.acc_status = action
+      q.acc_status_author_id = current_user.id
+      q.acc_status_date = Time.now
+      q.save(validate: false) && process_acc_status_notifications(q, action)
+    end
+    head :ok
+  end
+
+  def invite_to_slack
+    @questionnaire.invite_to_slack
+    flash[:notice] = 'Slack invite has been queued for delivery'
+    redirect_to manage_questionnaire_path @questionnaire
+  end
+
+  def message_events
+    render json: @questionnaire.message_events
+  end
+
+  private
+
+  def questionnaire_params
+    params.require(:questionnaire).permit(
+      :email, :experience, :first_name, :last_name, :gender,
+      :date_of_birth, :interest, :school_id, :school_name, :major, :level_of_study,
+      :shirt_size, :dietary_restrictions, :special_needs, :international,
+      :portfolio_url, :vcs_url, :agreement_accepted, :bus_captain_interest,
+      :riding_bus, :phone, :can_share_info, :code_of_conduct_accepted,
+      :travel_not_from_school, :travel_location, :data_sharing_accepted,
+      :resume, :delete_resume, :is_bus_captain
+    )
+  end
+
+  def set_questionnaire
+    @questionnaire = ::Questionnaire.find(params[:id])
+  end
+
+  def process_acc_status_notifications(questionnaire, new_status)
+    Mailer.delay.accepted_email(questionnaire.id) if new_status == "accepted"
+    Mailer.delay.rsvp_confirmation_email(questionnaire.id) if new_status == "rsvp_confirmed"
+    Mailer.delay.denied_email(questionnaire.id) if new_status == "denied"
+
+    questionnaire.invite_to_slack if ENV['INVITE_TO_SLACK_WHEN_ACCEPTED'] == 'true' && ['accepted', 'rsvp_confirmed'].include?(new_status)
+  end
+end

data/app/controllers/manage/schools_controller.rb

@@ -0,0 +1,87 @@
+class Manage::SchoolsController < Manage::ApplicationController
+  before_action :find_school, only: [:show, :edit, :update, :destroy, :merge, :perform_merge]
+
+  respond_to :html
+
+  def index
+  end
+
+  def datatable
+    render json: SchoolDatatable.new(view_context)
+  end
+
+  def show
+    respond_with(:manage, @school)
+  end
+
+  def new
+    @school = ::School.new
+    respond_with(:manage, @school)
+  end
+
+  def edit
+  end
+
+  def create
+    @school = ::School.new(school_params)
+    @school.save
+    respond_with(:manage, @school, location: manage_schools_path)
+  end
+
+  def update
+    @school.update_attributes(school_params)
+    respond_with(:manage, @school, location: manage_schools_path)
+  end
+
+  def destroy
+    @school.destroy
+    respond_with(:manage, @school, location: manage_schools_path)
+  end
+
+  def merge
+  end
+
+  def perform_merge
+    new_school_name = params[:school][:id]
+    if new_school_name.blank?
+      flash[:notice] = "Error: Must include the new school to merge into!"
+      render :merge
+      return
+    end
+
+    new_school = School.where(name: new_school_name).first
+    if new_school.blank?
+      flash[:notice] = "Error: School doesn't exist: #{new_school_name}"
+      render :merge
+      return
+    end
+
+    Questionnaire.where(school_id: @school.id).each do |q|
+      q.update_attribute(:school_id, new_school.id)
+    end
+
+    SchoolNameDuplicate.create(name: @school.name, school_id: new_school.id)
+
+    @school.reload
+
+    if @school.questionnaire_count < 1
+      @school.destroy
+    else
+      flash[:notice] = "*** Old school NOT deleted: #{@school.questionnaire_count} questionnaires still associated!\n"
+    end
+
+    redirect_to manage_schools_path(new_school)
+  end
+
+  private
+
+  def school_params
+    params.require(:school).permit(
+      :name, :address, :city, :state, :bus_list_id
+    )
+  end
+
+  def find_school
+    @school = ::School.find(params[:id])
+  end
+end

data/app/controllers/manage/stats_controller.rb

@@ -0,0 +1,77 @@
+class Manage::StatsController < Manage::ApplicationController
+  def index
+  end
+
+  def dietary_special_needs
+    data = Rails.cache.fetch(cache_key_for_questionnaires("dietary_special_needs")) do
+      attributes = [:first_name,
+                    :last_name,
+                    :email,
+                    :phone,
+                    :checked_in_at,
+                    :dietary_restrictions,
+                    :special_needs]
+      select_attributes = Array.new(attributes) << :user_id
+      data = Questionnaire.where("dietary_restrictions != '' AND acc_status = 'rsvp_confirmed' OR special_needs != '' AND acc_status = 'rsvp_confirmed'").select(select_attributes)
+      to_json_array(data, attributes)
+    end
+    render json: { data: data }
+  end
+
+  def sponsor_info
+    data = Rails.cache.fetch(cache_key_for_questionnaires("sponsor_info")) do
+      attributes = [:first_name,
+                    :last_name,
+                    :email,
+                    :vcs_url,
+                    :portfolio_url]
+      select_attributes = Array.new(attributes) << :user_id
+      data = Questionnaire.where("can_share_info = '1' AND acc_status = 'rsvp_confirmed'").select(select_attributes)
+      to_json_array(data, attributes)
+    end
+    render json: { data: data }
+  end
+
+  def alt_travel
+    data = Rails.cache.fetch(cache_key_for_questionnaires("alt_travel")) do
+      attributes = [:id,
+                    :first_name,
+                    :last_name,
+                    :email,
+                    :travel_location,
+                    :acc_status]
+      select_attributes = Array.new(attributes) << [:user_id, :school_id]
+      data = Questionnaire.where("travel_not_from_school = '1'").select(select_attributes)
+      json = to_json_array(data, attributes)
+      json.each do |e|
+        e[0] = view_context.link_to("View &raquo;".html_safe, manage_questionnaire_path(e[0]))
+      end
+    end
+    render json: { data: data }
+  end
+
+  def mlh_info
+    data = Rails.cache.fetch(cache_key_for_questionnaires("mlh_info")) do
+      attributes = [:first_name,
+                    :last_name,
+                    :email,
+                    :phone]
+      select_attributes = Array.new(attributes) << :user_id
+      data = Questionnaire.select(select_attributes)
+      to_json_array(data, attributes)
+    end
+    render json: { data: data }
+  end
+
+  private
+
+  def to_json_array(data, attributes)
+    data.map { |e| attributes.map { |a| e.send(a) } }
+  end
+
+  def cache_key_for_questionnaires(id)
+    count          = Questionnaire.count
+    max_updated_at = Questionnaire.maximum(:updated_at).try(:utc).try(:to_s, :number)
+    "stats/all-#{count}-#{max_updated_at}-#{id}"
+  end
+end

data/app/controllers/questionnaires_controller.rb

@@ -0,0 +1,145 @@
+class QuestionnairesController < ApplicationController
+  include QuestionnairesControllable
+
+  before_action :logged_in
+  before_action :find_questionnaire, only: [:show, :update, :edit, :destroy]
+
+  layout 'hackathon_manager'
+
+  def logged_in
+    authenticate_user!
+  end
+
+  # GET /apply
+  # GET /apply.json
+  def show
+    respond_to do |format|
+      format.html # show.html.erb
+      format.json { render json: @questionnaire }
+    end
+  end
+
+  # GET /apply/new
+  # GET /apply/new.json
+  def new
+    if current_user.questionnaire.present?
+      return redirect_to questionnaires_path
+    end
+    @questionnaire = Questionnaire.new
+
+    if session["devise.provider_data"] && session["devise.provider_data"]["info"]
+      @questionnaire.tap do |q|
+        q.first_name = session["devise.provider_data"]["info"]["first_name"]
+        q.last_name = session["devise.provider_data"]["info"]["last_name"]
+        q.phone = session["devise.provider_data"]["info"]["phone_number"]
+        q.level_of_study = session["devise.provider_data"]["info"]["level_of_study"]
+        q.major = session["devise.provider_data"]["info"]["major"]
+        q.date_of_birth = session["devise.provider_data"]["info"]["date_of_birth"]
+        q.shirt_size = session["devise.provider_data"]["info"]["shirt_size"]
+        q.dietary_restrictions = session["devise.provider_data"]["info"]["dietary_restrictions"]
+        q.special_needs = session["devise.provider_data"]["info"]["special_needs"]
+        q.gender = session["devise.provider_data"]["info"]["gender"]
+
+        school = School.where(name: session["devise.provider_data"]["info"]["school"]["name"]).first_or_create do |s|
+          s.name = session["devise.provider_data"]["info"]["school"]["name"]
+        end
+        q.school_id = school.id
+      end
+    end
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.json { render json: @questionnaire }
+    end
+  end
+
+  # GET /apply/edit
+  def edit
+  end
+
+  # POST /apply
+  # POST /apply.json
+  def create
+    if current_user.questionnaire.present?
+      return redirect_to questionnaires_path, notice: 'Application already exists.'
+    end
+    @questionnaire = Questionnaire.new(convert_school_name_to_id(questionnaire_params))
+
+    respond_to do |format|
+      if @questionnaire.save
+        current_user.questionnaire = @questionnaire
+        @questionnaire.update_attribute(:acc_status, default_acc_status)
+        Mailer.delay.application_confirmation_email(@questionnaire.id)
+        format.html { redirect_to questionnaires_path, notice: 'Application was successfully created.' }
+        format.json { render json: @questionnaire, status: :created, location: @questionnaire }
+      else
+        format.html { render action: "new" }
+        format.json { render json: @questionnaire.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PUT /apply
+  # PUT /apply.json
+  def update
+    update_params = questionnaire_params
+    update_params = convert_school_name_to_id(update_params)
+
+    respond_to do |format|
+      if @questionnaire.update_attributes(update_params)
+        format.html { redirect_to questionnaires_path, notice: 'Application was successfully updated.' }
+        format.json { head :no_content }
+      else
+        format.html { render action: "edit" }
+        format.json { render json: @questionnaire.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /apply
+  # DELETE /apply.json
+  def destroy
+    @questionnaire.destroy
+
+    respond_to do |format|
+      format.html { redirect_to questionnaires_url }
+      format.json { head :no_content }
+    end
+  end
+
+  # GET /apply/schools
+  def schools
+    if params[:name].blank? || params[:name].length < 3
+      head :bad_request
+      return
+    end
+    schools = School.where('name LIKE ?', "%#{params[:name]}%").order(questionnaire_count: :desc).limit(20).select(:name).all
+    render json: schools.map(&:name)
+  end
+
+  private
+
+  def questionnaire_params
+    params.require(:questionnaire).permit(
+      :email, :experience, :first_name, :last_name, :gender,
+      :date_of_birth, :interest, :school_id, :school_name, :major, :level_of_study,
+      :shirt_size, :dietary_restrictions, :special_needs, :international,
+      :portfolio_url, :vcs_url, :agreement_accepted, :bus_captain_interest,
+      :riding_bus, :phone, :can_share_info, :code_of_conduct_accepted,
+      :travel_not_from_school, :travel_location, :data_sharing_accepted,
+      :resume, :delete_resume
+    )
+  end
+
+  def find_questionnaire
+    unless current_user.questionnaire.present?
+      return redirect_to new_questionnaires_path
+    end
+    @questionnaire = current_user.questionnaire
+  end
+
+  def default_acc_status
+    return "late_waitlist" if Rails.configuration.hackathon['auto_late_waitlist']
+    "pending"
+  end
+end