pairer 1.0.0

data/app/controllers/pairer/boards_controller.rb

@@ -0,0 +1,202 @@
+require_dependency "pairer/application_controller"
+
+module Pairer
+  class BoardsController < ApplicationController
+    before_action do
+      if !signed_in?
+        redirect_to sign_in_path
+      end
+    end
+
+    before_action :get_board, except: [:index, :new, :create]
+
+    helper_method :people_by_id
+
+    def index
+      if params[:password].present?
+        @board = Pairer::Board.find_by(org_id: session[:pairer_current_org_id], password: params[:password])
+
+        if @board
+          session[:pairer_current_board_id] = @board.to_param
+          redirect_to action: :show, id: session[:pairer_current_board_id]
+        else
+          flash.now.alert = "Board not found."
+
+          render
+        end
+      end
+    end
+
+    def create
+      @board = Pairer::Board.new(password: params[:password], org_id: session[:pairer_current_org_id])
+
+      if @board.save
+        session[:pairer_current_board_id] = @board.to_param
+        flash.notice = "Board created."
+        redirect_to(action: :show, id: @board.to_param)
+      else
+        other_board = Pairer::Board.find_by(org_id: session[:pairer_current_org_id], password: params[:password])
+
+        if other_board
+          session[:pairer_current_board_id] = other_board.to_param
+          flash.notice = "Existing board found."
+          redirect_to(action: :show, id: other_board.to_param)
+        else
+          flash.alert = "Board not saved. Please choose a different password."
+          redirect_to(action: :index)
+        end
+      end
+    end
+
+    def show
+      session_key = :pairer_board_access_list
+
+      access_list = session[session_key] || {}
+
+      access_list[@board.public_id] = Time.now.to_s
+
+      session[session_key] = access_list
+    end
+
+    def update
+      if params[:add_role_name]
+        params[:board] = {}
+        params[:board][:roles] = @board.roles_array + [params[:add_role_name]]
+      elsif params[:remove_role_name]
+        params[:board] = {}
+        params[:board][:roles] = @board.roles_array - [params[:remove_role_name]]
+      end
+
+      if params[:clear_board]
+        @board.groups.destroy_all
+        @board.update!(current_iteration_number: 0)
+        saved = true
+      else
+        saved = @board.update(params.require(:board).permit(:name, :password, :group_size, :num_iterations_to_track, roles: []))
+      end
+      
+      if saved
+        if params.dig(:board, :password)
+          flash.notice = "Password updated."
+        else
+          flash.notice = "Board updated."
+        end
+      else
+        if @board.errors[:num_iterations_to_track].present?
+          flash.alert = "Number of Iterations to Track #{@board.errors[:num_iterations_to_track].first}"
+        else
+          flash.alert = "Board not saved."
+        end
+      end
+
+      redirect_to(action: :show)
+    end
+
+    def destroy
+      @board.destroy!
+      flash.notice = "Board deleted."
+      redirect_to(action: :index)
+    end
+
+    def shuffle
+      @board.shuffle!
+      redirect_to(action: :show)
+    end
+
+    def create_person
+      @person = @board.people.create(name: params[:name])
+
+      if request.format.js?
+        render
+      else
+        redirect_to(action: :show)
+      end
+    end
+
+    def lock_person
+      @person = @board.people.find_by!(public_id: params.require(:person_id))
+
+      @person.toggle!(:locked)
+
+      if request.format.js?
+        render
+      else
+        redirect_to(action: :show)
+      end
+    end
+
+    def delete_person
+      @person = @board.people.find_by!(public_id: params.require(:person_id))
+
+      @person.destroy!
+
+      redirect_to(action: :show)
+    end
+
+    def create_group
+      @group = @board.groups.create!(board_iteration_number: @board.current_iteration_number)
+
+      if request.format.js?
+        render
+      else
+        redirect_to(action: :show)
+      end
+    end
+
+    def lock_group
+      @group = @board.groups.find_by!(public_id: params.require(:group_id))
+
+      @group.toggle!(:locked)
+
+      if request.format.js?
+        render
+      else
+        redirect_to(action: :show)
+      end
+    end
+
+    def delete_group
+      @group = @board.groups.find_by!(public_id: params.require(:group_id))
+
+      @group.destroy!
+
+      if request.format.js?
+        render
+      else
+        redirect_to(action: :show)
+      end
+    end
+
+    def update_group
+      @group = @board.groups.find_by!(public_id: params.require(:group_id))
+
+      attrs = {
+        person_ids: (params[:person_ids] if params[:person_ids].present?),
+        roles: (params[:roles] if params[:roles].present?),
+      }.compact
+
+      @group.update!(attrs)
+
+      if request.format.js?
+        render
+      else
+        redirect_to(action: :show)
+      end
+    end
+
+    private
+
+    def get_board
+      if session[:pairer_current_board_id].blank?
+        redirect_to(action: :index)
+      end
+
+      @board = Pairer::Board.find_by!(org_id: session[:pairer_current_org_id], public_id: params[:id])
+    end
+
+    def people_by_id
+      @people_by_id ||= @board.people.map{|x| [x.to_param, x] }.to_h
+    end
+
+  end
+end

data/app/controllers/pairer/sessions_controller.rb

@@ -0,0 +1,32 @@
+require_dependency "pairer/application_controller"
+
+module Pairer
+  class SessionsController < ApplicationController
+
+    def sign_in
+      if request.method == "GET"
+        if signed_in?
+          redirect_to boards_path
+        end
+
+      elsif request.method == "POST"
+        if Pairer.config.allowed_org_ids.include?(params[:org_id]&.downcase)
+          session[:pairer_current_org_id] = params[:org_id].downcase
+          redirect_to boards_path
+        end
+      end
+    end
+
+    def sign_out
+      if !signed_in?
+        redirect_to action: :sign_in
+      else
+        session.delete(:pairer_current_org_id)
+        session.delete(:pairer_current_board_id)
+        flash.notice = "Signed out"
+        redirect_to sign_in_path
+      end
+    end
+
+  end
+end

data/app/helpers/pairer/application_helper.rb

@@ -0,0 +1,4 @@
+module Pairer
+  module ApplicationHelper
+  end
+end

data/app/jobs/pairer/application_job.rb

@@ -0,0 +1,5 @@
+module Pairer
+  class ApplicationJob < ActiveJob::Base
+    self.queue_adapter = :async
+  end
+end

data/app/jobs/pairer/cleanup_boards_job.rb

@@ -0,0 +1,9 @@
+module Pairer
+  class CleanupBoardsJob < ApplicationJob
+
+    def perform
+      Board.where.not(org_id: Pairer.config.allowed_org_ids).destroy_all
+    end
+
+  end
+end

data/app/mailers/pairer/application_mailer.rb

@@ -0,0 +1,5 @@
+module Pairer
+  class ApplicationMailer < ActionMailer::Base
+    #default from: Pairer.from_email
+  end
+end

data/app/models/pairer/application_record.rb

@@ -0,0 +1,19 @@
+module Pairer
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+
+    after_create do
+      salt = Pairer.config.hash_id_salt
+      pepper = self.class.table_name
+
+      self.update_columns(public_id: Hashids.new("#{salt}_#{pepper}", 8).encode(id))
+    end
+
+    validates :public_id, uniqueness: {case_sensitive: true, allow_blank: true}
+
+    def to_param
+      try(:public_id) || id
+    end
+
+  end
+end

data/app/models/pairer/board.rb

@@ -0,0 +1,226 @@
+module Pairer
+  class Board < ApplicationRecord
+    RECENT_RESHUFFLE_DURATION = 1.minute.freeze
+    NUM_CANDIDATE_GROUPINGS = 5
+
+    has_many :people, class_name: "Pairer::Person", dependent: :destroy
+    has_many :groups, class_name: "Pairer::Group", dependent: :destroy
+
+    validates :name, presence: true
+    validates :org_id, presence: true, inclusion: {in: ->(x){ Pairer.config.allowed_org_ids }}
+    validates :password, presence: true, uniqueness: {message: "invalid password, please use a different one", scope: :org_id}
+    validates :current_iteration_number, presence: true, numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+    validates :num_iterations_to_track, presence: true, numericality: { only_integer: true, greater_than_or_equal_to: 0, less_than_or_equal_to: ->(x){ Pairer.config.max_iterations_to_track } }
+    validates :group_size, presence: true, numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+
+    before_validation on: :create do
+      self.name ||= "New Board"
+      self.current_iteration_number ||= 0
+      self.num_iterations_to_track ||= 15
+      self.group_size ||= 2
+    end
+
+    def current_groups
+      groups.where(board_iteration_number: current_iteration_number)
+    end
+
+    def tracked_groups
+      groups
+        .order(board_iteration_number: :desc)
+        .where("board_iteration_number > #{current_iteration_number - num_iterations_to_track}")
+    end
+
+    def roles=(val)
+      if val.is_a?(Array)
+        self[:roles] = val.map{|x| x.presence&.strip }.uniq(&:downcase).compact.sort.join(";;")
+      else
+        raise "invalid behaviour"
+      end
+    end
+
+    def roles_array
+      self[:roles]&.split(";;") || []
+    end
+
+    def shuffle!
+      new_groups = []
+
+      prev_iteration_number = current_iteration_number
+      next_iteration_number = current_iteration_number + 1
+
+      available_person_ids = people.select{|x| !x.locked? }.collect(&:public_id)
+      available_roles = roles_array
+
+      ### Build New Groups
+      groups.where(board_iteration_number: prev_iteration_number).each do |g|
+        if g.locked?
+          ### Clone Locked Groups
+          
+          new_group = g.dup
+
+          new_group.assign_attributes(
+            public_id: nil,
+            board_iteration_number: next_iteration_number,
+          )
+
+          new_groups << new_group
+
+          available_person_ids = (available_person_ids - g.person_ids_array)
+
+          available_roles = (available_roles - new_group.roles_array)
+        else
+          ### Retain Position of Locked People within Existing Groups
+          
+          group_locked_person_ids = (g.person_ids_array - available_person_ids)
+
+          if group_locked_person_ids.any?
+            new_group = groups.new(
+              board_iteration_number: next_iteration_number,
+              roles: [],
+              person_ids: group_locked_person_ids,
+            )
+
+            new_groups << new_group
+
+            available_person_ids = (available_person_ids - group_locked_person_ids)
+          end
+        end
+      end
+
+      self.increment!(:current_iteration_number)
+
+      if available_person_ids.any?
+        pair_stats_hash = stats_hash_for_two_pairs
+
+        ### Assign People to Non-Full Unlocked Groups
+        new_groups.select{|x| !x.locked? }.each do |g|
+          break if available_person_ids.empty?
+
+          num_to_add = self.group_size - g.person_ids_array.size
+
+          next if num_to_add <= 0
+
+          if available_person_ids.size < num_to_add
+            ### Add to group whatever is left
+            
+            g.person_ids = g.person_ids_array + available_person_ids
+
+            available_person_ids = []
+
+            break
+          end
+
+          group_size_combinations = available_person_ids.combination(num_to_add).map{|x| x + g.person_ids_array }.shuffle
+
+          ### Choose group using minimum score
+          chosen_person_ids = group_size_combinations.min_by do |person_ids|
+            person_ids.combination(2).map(&:sort).sum{|k| pair_stats_hash[k] || 0 }
+          end
+
+          g.person_ids = (g.person_ids_array | chosen_person_ids).sort
+        end
+
+        ### Assign People to New Groups
+        while available_person_ids.any? do
+          if available_person_ids.size <= self.group_size
+            ### Create group using whats left
+            
+            new_groups << groups.new(
+              board_iteration_number: next_iteration_number,
+              person_ids: available_person_ids,
+            )
+
+            available_person_ids = []
+          else
+            group_size_combinations = available_person_ids.combination(self.group_size).to_a.shuffle
+
+            ### Choose group using minimum score
+            chosen_person_ids = group_size_combinations.min_by do |person_ids|
+              person_ids.combination(2).map(&:sort).sum{|k| pair_stats_hash[k] || 0 }
+            end
+
+            new_groups << groups.new(
+              board_iteration_number: next_iteration_number,
+              person_ids: chosen_person_ids,
+            )
+
+            available_person_ids = (available_person_ids - chosen_person_ids)
+          end
+        end
+
+        ### Shuffle Roles
+        available_roles = available_roles.shuffle
+
+        unlocked_new_groups = new_groups.select{|x| !x.locked? }
+
+        ### Assign Roles to Groups
+        available_roles.in_groups(unlocked_new_groups.size, false).each_with_index do |roles, i|
+          unlocked_new_groups[i].roles = unlocked_new_groups[i].roles_array + roles
+          available_roles = available_roles - roles
+        end
+
+        ### Save New Groups
+        new_groups.each{|x| x.save! }
+      end
+
+      ### Delete empty groups
+      groups
+        .where(person_ids: [nil, ""])
+        .each{|x| x.destroy! }
+
+      ### Delete outdated groups
+      groups
+        .where.not(id: tracked_groups.collect(&:id))
+        .each{|x| x.destroy! }
+
+      ### Ensure stats do not contain bogus entries caused by re-shuffling, groups created less than x time ago are deleted upon shuffle
+      if !Rails.env.test? || (Rails.env.test? && ENV['DELETE_RECENT_RESHUFFLED'].to_s == "true")
+        groups
+          .where.not(id: new_groups.collect(&:id))
+          .where("#{Pairer::Group.table_name}.created_at >= ?", RECENT_RESHUFFLE_DURATION.ago)
+          .each{|x| x.destroy! }
+      end
+
+      ### Reload groups to fix any issues with caching after creations and deletions
+      groups.reload
+        
+      return true
+    end
+
+    def stats
+      array = []
+
+      stats_hash_for_two_pairs.sort_by{|k,count| -count }.each do |person_ids, count|
+        array << [person_ids, count]
+      end
+
+      return array
+    end
+
+    private
+    
+    def stats_hash_for_two_pairs
+      h = {}
+
+      tracked_groups.each do |group|
+        group_person_ids = group.person_ids_array
+
+        ### For combinations size, we use 2 instead of self.group_size as we are running stats on pairs, not groups
+        if group_person_ids.size == 1
+          h[group_person_ids] ||= 0
+          h[group_person_ids] += 1
+        else
+          combinations = group_person_ids.combination(2)
+
+          combinations.map{|x| x.sort }.each do |sorted_pair_person_ids|
+            h[sorted_pair_person_ids] ||= 0
+            h[sorted_pair_person_ids] += 1
+          end
+        end
+      end
+
+      return h
+    end
+
+  end
+end

data/app/models/pairer/group.rb

@@ -0,0 +1,45 @@
+module Pairer
+  class Group < ApplicationRecord
+    belongs_to :board, class_name: "Pairer::Board"
+
+    validates :board_id, presence: true
+    validates :board_iteration_number, presence: true, numericality: { only_integer: true, minimum: 0 }
+
+    def person_ids=(val)
+      if val.is_a?(Array)
+        sanitized_array = val.map{|x| x.presence&.strip }.uniq(&:downcase).compact
+
+        if !new_record?
+          sanitized_array = sanitized_array.intersection(board.people.map(&:public_id)) ### This may slow the query down
+        end
+
+        self[:person_ids] = sanitized_array.join(";;")
+      else
+        raise "invalid behaviour"
+      end
+    end
+
+    def person_ids_array
+      self[:person_ids]&.split(";;") || []
+    end
+
+    def roles=(val)
+      if val.is_a?(Array)
+        sanitized_array = self[:roles] = val.map{|x| x.presence&.strip }.uniq(&:downcase).compact
+
+        if !new_record?
+          sanitized_array = sanitized_array.intersection(board.roles_array) ### This may slow the query down
+        end
+
+        self[:roles] = sanitized_array.join(";;")
+      else
+        raise "invalid behaviour"
+      end
+    end
+
+    def roles_array
+      self[:roles]&.split(";;") || []
+    end
+
+  end
+end

data/app/models/pairer/person.rb

@@ -0,0 +1,7 @@
+module Pairer
+  class Person < ApplicationRecord
+    belongs_to :board, class_name: "Pairer::Board"
+
+    validates :name, presence: true, uniqueness: {scope: :board_id, case_sensitive: false}
+  end
+end

data/app/views/layouts/pairer/application.html.slim

@@ -0,0 +1,53 @@
+- @title ||= 'Pairer'
+- @description ||= "A tool to help assign working pairs"
+
+doctype html
+html
+  head
+    title = @title
+
+    = csrf_meta_tags
+    meta name="viewport" content="width=device-width, height=device-height, initial-scale=1.0"
+
+    = favicon_link_tag "pairer/favicon.ico"
+
+    = stylesheet_link_tag 'pairer/application', media: 'all'
+    
+    script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.6.0/jquery.min.js" referrerpolicy="no-referrer"
+
+    link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/3.2.1/css/font-awesome.min.css" integrity="sha512-IJ+BZHGlT4K43sqBGUzJ90pcxfkREDVZPZxeexRigVL8rzdw/gyJIflDahMdNzBww4k0WxpyaWpC2PLQUWmMUQ==" crossorigin="anonymous" referrerpolicy="no-referrer"
+
+    link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css" integrity="sha512-SfTiTlX6kk+qitfevl/7LibUOeJWlt9rbyDn92a1DqWOw9vWG2MFoays0sgObmWazO5BQPiFucnnEAjpAB+/Sw==" crossorigin="anonymous" referrerpolicy="no-referrer"
+
+    link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/jqueryui/1.13.2/themes/base/jquery-ui.min.css" integrity="sha512-ELV+xyi8IhEApPS/pSj66+Jiw+sOT1Mqkzlh8ExXihe4zfqbWkxPRi8wptXIO9g73FSlhmquFlUOuMSoXz5IRw==" crossorigin="anonymous" referrerpolicy="no-referrer"
+    script src="https://cdnjs.cloudflare.com/ajax/libs/jqueryui/1.13.2/jquery-ui.min.js" integrity="sha512-57oZ/vW8ANMjR/KQ6Be9v/+/h6bq9/l3f0Oc7vn6qMqyhvPd1cvKBRWWpzu0QoneImqr2SkmO4MSqU+RpHom3Q==" crossorigin="anonymous" referrerpolicy="no-referrer"
+
+    = javascript_include_tag 'pairer/application'
+    
+  body
+    nav.navbar.navbar-inverse.navbar-fixed-top
+      .container-fluid
+        .navbar-header
+          i.fa.fa-bars.navbar-toggle.visible-sm.visible-xs style="color: white; cursor: pointer;"  data-toggle="collapse" data-target="#nav" title="Show/Hide Menu"
+          h1.hidden = @title
+          a.navbar-brand href=root_path = "#{@title}"
+
+        .navbar-collapse.collapse#nav
+          - if signed_in?
+            ul.nav.navbar-nav
+              li class=('active' if params[:action] == "index")
+                a href=boards_path Find Board
+              - if @board
+                li.active
+                  a href=board_path(@board) View Board
+
+          ul.nav.navbar-nav.navbar-right
+            li
+              a href=sign_out_path
+                i.fa.fa-sign-out
+                span.space-left.space-left Sign Out
+
+    .container-fluid
+      = render "pairer/shared/flash"
+
+      = yield

data/app/views/layouts/pairer/application.js.erb

@@ -0,0 +1,5 @@
+$('#flash-container').html("<%= j render partial: 'pairer/shared/flash' %>");
+
+<%= yield %>
+
+window.init();

data/app/views/pairer/boards/_current_groups.html.slim

@@ -0,0 +1,11 @@
+table.table-bordered.table.current-groups
+  thead
+    th.text-center style="width: 130px;"
+      = link_to shuffle_board_path(@board), class: "btn btn-success btn-sm", data: {method: :post} do
+        i.icon-refresh.space-right
+        span Shuffle
+    th style="width: 50%; padding-left: 25px;" People
+    th style="padding-left: 25px;" Roles
+  tbody
+    - @board.current_groups.each do |group|
+      = render "group", group: group

data/app/views/pairer/boards/_group.html.slim

@@ -0,0 +1,17 @@
+tr.group-row data-group-id=group.public_id
+  td.text-center
+    .space-above2
+      = render "group_lock_button", group: group
+
+      = link_to delete_group_board_path(@board, group_id: group), data: {method: :delete}, remote: true, class: 'btn btn-xs space-left2 group-sweep-btn', title: "Sweep" do
+        = render "pairer/shared/svg/broom"
+
+  td.person-list data-group-id=group.public_id data-prev-person-ids=group.person_ids_array style="padding-left: 20px;"
+    - group.person_ids_array.each do |person_public_id|
+      - person = people_by_id[person_public_id]
+      - if person
+        = render 'person', person: person
+
+  td.roles-list data-group-id=group.public_id data-prev-roles=group.roles_array style="padding-left: 20px;"
+    - group.roles_array.each do |role|
+      = render 'role', role: role

data/app/views/pairer/boards/_group_lock_button.html.slim

@@ -0,0 +1,4 @@
+= link_to lock_group_board_path(@board, group_id: group), data: {method: :post}, remote: true, class: "btn btn-xs group-lock-btn #{group.locked? ? 'btn-highlight' : 'btn-default'}", title: "Group #{group.locked? ? "Locked" : "Unlocked"}" do
+  i class=(group.locked? ? 'icon-lock' : 'icon-unlock')
+  - if group.locked?
+    = " Locked"

data/app/views/pairer/boards/_person.html.slim

@@ -0,0 +1,9 @@
+span.person data-person-id=person.public_id
+  = person.name
+
+  = link_to lock_person_board_path(@board, person_id: person), data: {method: :post}, remote: true, class: "btn btn-xs space-left2 #{person.locked? ? 'btn-highlight' : 'btn-default'}", title: "#{person.locked? ? "Locked" : "Unlocked"}" do
+    i class=(person.locked? ? 'icon-lock' : 'icon-unlock')
+
+  span.space-left.delete
+    = link_to delete_person_board_path(@board, person_id: person), data: {method: :delete, confirm: "Are you sure you want to delete person '#{person.name}'?"}, title: "Delete Person", class: 'btn btn-xs btn-danger' do
+      i.icon-trash