leaderboard by user groups

@@ -11,8 +11,13 @@ class ApplicationController < HeimdallEngine::ApplicationController
   private
   private
 
 
   def leaderboard
   def leaderboard
-    Bet.joins(:user).group('users.name').sum(:points).sort_by { |k,v| v }
-      .take(5)
+    Group.for(current_user.id).inject({}) do |h, group|
+      h[group.name] = {
+        pool: group.pool_name,
+        leaderboard: Bet.for_pool(group.pool_id).board.take(5)
+      }
+      h
+    end
   end
   end
 
 
   def check_matches
   def check_matches

@@ -9,6 +9,7 @@ class BetsController < ApplicationController
     if current_user.update_attributes(object_params)
     if current_user.update_attributes(object_params)
       redirect_to bets_path
       redirect_to bets_path
     else
     else
+      load_active_pools
       render :index
       render :index
     end
     end
   end
   end

 #
 #
 class Bet < ApplicationRecord
 class Bet < ApplicationRecord
-  validates :score_local, :score_visit, presence: true
+  validates :visit, :local, :date, presence: true
   belongs_to :user, inverse_of: :bets
   belongs_to :user, inverse_of: :bets
   belongs_to :match, inverse_of: :bets
   belongs_to :match, inverse_of: :bets
+  has_one :group, through: :user, inverse_of: :bets
   enum result: [:visit, :tie, :local]
   enum result: [:visit, :tie, :local]
 
 
   scope :active, -> { joins(match: :pool).where(pools: { active: true }) }
   scope :active, -> { joins(match: :pool).where(pools: { active: true }) }
+  scope :for_pool, -> (pool_id) { joins(:match).where(matches: { pool_id: pool_id } ) }
+  scope :board, (lambda do
+    joins(:user)
+    .group('users.name')
+    .order('sum_points')
+    .sum(:points)
+  end)
+
   before_save :assign_result
   before_save :assign_result
 
 
   def calculate
   def calculate

@@ -5,6 +5,12 @@ class Group < ApplicationRecord
   validates :name, :pool, presence: true
   validates :name, :pool, presence: true
   delegate :name, to: :pool, prefix: true
   delegate :name, to: :pool, prefix: true
 
 
+  scope :active, -> { joins(:pool).where(pools: { active: true}) }
+  scope :for, -> (user_id) {
+    joins(:users).where('users.id = ?', user_id).distinct
+  }
+
+
   def users_count
   def users_count
     users.count
     users.count
   end
   end

 h1 Leaderboard
 h1 Leaderboard
 table.leaderboard
 table.leaderboard
   tbody
   tbody
-    - @leaders.each do |user, points|
+    - @leaders.each do |group_name, data|
       tr
       tr
-        td = user
-        td = points
-    - if @leaders.empty?
-      tr
-        td colspan=2 There are no results yet
+        td colspan=2 = group_name
+      - data[:leaderboard].each do |user_name, points|
+        tr
+          td = user_name
+          td = points
+      - if data[:leaderboard].empty?
+        tr
+          td colspan=2 There are no results yet

+- if current_user.errors.any?
+  div = current_user.errors.full_messages.to_sentence
 table.pools
 table.pools
   - pool.matches.each do |match|
   - pool.matches.each do |match|
     - bet = current_user.bets.find_or_initialize_by(match_id: match.id)
     - bet = current_user.bets.find_or_initialize_by(match_id: match.id)