ingang/app/controllers/users_controller.rb

class UsersController < ApplicationController
  http_basic_authenticate_with name: Rails.application.config.admin_name,
                               password: Rails.application.config.admin_password

  before_action :set_user, only: [:show, :edit, :update, :destroy, :test_invite]
  before_action :set_users, only: [:index, :destroy_all, :mark_invited, :mark_presence]
  before_action :set_room, only: [:index, :bulk]

  # GET /users
  # GET /users.json
  def index
  end

  # POST /users/invite
  def invite
    @users = User.where(room_id: params[:room_id], invited: false, proxy: false)
    invited = []
    @users.each do |user|
      url = join_room_url(user.token)
      begin
        RoomMailer.with(room_id: params[:room_id], user: user, url: url).invite.deliver_now
        User.find(user.id).update(invited: true)
        invited.push(user.id)
      rescue

      end
    end
    respond_to do |format|
      format.html {
        count = invited.length
        redirect_to room_users_url, notice: "Sent invitation to #{count} users."
      }
      format.json { head :no_content }
    end
  end

  # POST /rooms/1/users/1/test_invite
  def test_invite
    url = join_room_url(@user.token)
    RoomMailer.with(room_id: params[:room_id], user: @user, url: url).invite.deliver_now
    respond_to do |format|
      format.html { redirect_to room_users_url, notice: "Sent test invitation." }
      format.json { head :no_content }
    end
  end

  # DELETE /users/invite
  def uninvite
    @users = User.where(room_id: params[:room_id], invited: true)
    @users.in_batches.update_all(invited: false)
    respond_to do |format|
      format.html {
        count = @users.length
        redirect_to room_users_url, notice: "Reset invitation status of #{count} users."
      }
      format.json { head :no_content }
    end
  end

  # POST /users/mark_invited
  def mark_invited
    @users.in_batches.update_all(invited: true)
    respond_to do |format|
      format.html {
        count = @users.length
        redirect_to room_users_url, notice: "Marked #{count} users as invited."
      }
      format.json { head :no_content }
    end
  end

  # POST /users/mark_presence
  def mark_presence
    presence = ActiveModel::Type::Boolean.new.cast(params[:v])
    @users.in_batches.update_all(presence: presence)
    respond_to do |format|
      format.html {
        count = @users.length
        redirect_to room_users_url, notice: "Updated presence for #{count} users."
      }
      format.json { head :no_content }
    end
  end

  # GET /users/1
  # GET /users/1.json
  def show
  end

  # GET /users/new
  def new
    @user = User.new
  end

  # GET /users/1/edit
  def edit
  end

  # POST /users
  # POST /users.json
  def create
    @user = User.new(user_params)
    @user.room_id = params[:room_id]

    respond_to do |format|
      if @user.save
        format.html { redirect_to room_users_url(@user.room_id), notice: 'User was successfully created.' }
        format.json { render :show, status: :created, location: @user }
      else
        format.html { render :new }
        format.json { render json: @user.errors, status: :unprocessable_entity }
      end
    end
  end

  # PATCH/PUT /users/1
  # PATCH/PUT /users/1.json
  def update
    respond_to do |format|
      if @user.update(user_params)
        format.html { redirect_to room_users_url(@user.room_id), notice: 'User was successfully updated.' }
        format.json { render :show, status: :ok, location: @user }
      else
        format.html { render :edit }
        format.json { render json: @user.errors, status: :unprocessable_entity }
      end
    end
  end

  # DELETE /users/1
  # DELETE /users/1.json
  def destroy
    Vote.where(user_id: @user.id).each do |vote|
      vote.destroy
    end
    @user.destroy
    respond_to do |format|
      format.html { redirect_to room_users_url(@user.room_id), notice: 'User was successfully destroyed.' }
      format.json { head :no_content }
    end
  end

  # DELETE /rooms/1/users/
  # DELETE /rooms/1/users.json
  def destroy_all
    @users.each do |user|
      Vote.where(user_id: user.id).each do |vote|
        vote.destroy
      end
      user.destroy
    end
    respond_to do |format|
      format.html { redirect_to room_users_url(params[:room_id]), notice: 'Users successfully destroyed.' }
      format.json { head :no_content }
    end
  end

  # GET /users/bulk
  def bulk
    @sample = "email,name,moderator,vote,proxy,invited,presence\n,,FALSE,TRUE,FALSE,FALSE,FALSE\n"
  end

  # POST /users/bulk
  # POST /users/bulk.json
  def create_bulk
    room_id = params[:room_id]
    users_csv = params[:users_csv]

    require 'csv'

    users = CSV.parse(users_csv, :headers => true).map { |row|
      fields = row.to_hash
      fields[:room_id] = room_id
      fields
    }
    User.upsert_all(users, unique_by: [:room_id, :email])

    respond_to do |format|
      format.html { redirect_to room_users_url(room_id), notice: 'Users were successfully created.' }
      format.json { render :show, status: :created, location: @user }
    end
  end

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

    def set_room
      @room = Room.find(params[:room_id])
    end

    def set_user
      @user = User.find(params[:id])
    end

    def set_users
      @users = User.where(room_id: params[:room_id])
    end

    # Only allow a list of trusted parameters through.
    def user_params
      params.require(:user).permit(:name, :email, :token, :moderator, :invited, :vote, :proxy, :presence)
    end
end