152 lines
5.0 KiB
Ruby
152 lines
5.0 KiB
Ruby
# frozen_string_literal: true
|
|
module PositionLabelFlag
|
|
POSITION_ONLY = 'PO'
|
|
DESIGNATED_RUNNER_FOR = 'DRd'
|
|
|
|
# Reverse lookup function
|
|
def self.find_key_by_value(value)
|
|
constants.find { |const| const_get(const) == value.to_s }
|
|
end
|
|
end
|
|
|
|
module PositionCapabilityFlag
|
|
INFIELD = "IF"
|
|
OUTFIELD = "OF"
|
|
CATCHER = "C"
|
|
PITCHER = "P"
|
|
|
|
# Reverse lookup function
|
|
def self.find_key_by_value(value)
|
|
constants.find { |const| const_get(const) == value.to_s }
|
|
end
|
|
end
|
|
|
|
module Availability
|
|
YES = 1
|
|
NO = 0
|
|
MAYBE = 2
|
|
UNKNOWN = nil
|
|
|
|
def self.sort_order
|
|
[
|
|
UNKNOWN,
|
|
NO,
|
|
MAYBE,
|
|
YES
|
|
].reverse
|
|
end
|
|
|
|
def self.sort_by(a)
|
|
sort_order.index(a.status_code)
|
|
end
|
|
|
|
# availabilities.sort_by do |a|
|
|
# [a.status_code || -2, members.find do |m|
|
|
# m.id == a.member_id
|
|
# end.last_name]
|
|
# end,
|
|
|
|
end
|
|
|
|
def padleft(a, n, x)
|
|
Array.new([0, n-a.length].max, x)+a
|
|
end
|
|
def padright(a, n, x)
|
|
a.dup.fill(x, a.length...n)
|
|
end
|
|
|
|
module EventHelper
|
|
|
|
def event_context_with_timeline(team_id, event_id, timeline_width)
|
|
current_event = TeamSnap::Event.find(@teamsnap_client, event_id)
|
|
upcoming_events = TeamSnap::Event.search(@teamsnap_client, {
|
|
team_id: team_id, started_after: current_event.start_date, page_size: timeline_width + 1
|
|
})
|
|
future_events = upcoming_events.slice(1,upcoming_events.length)
|
|
past_events = TeamSnap::Event.search(@teamsnap_client, {
|
|
team_id: team_id, started_before: current_event.start_date, page_size: timeline_width, sort_start_date: "desc"
|
|
})
|
|
|
|
past_events.fill(nil, past_events.length...timeline_width)
|
|
future_events.fill(nil, future_events.length...timeline_width)
|
|
event_timeline = past_events.reverse.concat([current_event]).concat(future_events)
|
|
items = TeamSnap.bulk_load(@teamsnap_client,
|
|
{ :team_id => team_id,
|
|
:types => 'team,member,availability_summary,event,event_lineup_entry,opponent,location',
|
|
:event__id => event_timeline.reject(&:nil?).map(&:id).join(","),
|
|
:scope_to => "event"
|
|
})
|
|
|
|
availabilities = TeamSnap::Availability.search(@teamsnap_client, { event_id: event_timeline.reject(&:nil?).map(&:id).join(',') })
|
|
event_lineups = TeamSnap::EventLineup.search(@teamsnap_client, { event_id: event_timeline.reject(&:nil?).map(&:id).join(',') })
|
|
items.concat(availabilities).concat(event_lineups)
|
|
team = items.find { |item| item.type == 'team' and item.id == team_id }
|
|
members = items.select { |item| item.type == 'member' }
|
|
|
|
context = { "team": team, "members": members }
|
|
|
|
timeline = {}
|
|
|
|
event_timeline.each_with_index do |event, i|
|
|
timepoint = Hash[]
|
|
timepoint[:comparison_to_selected] = i - timeline_width
|
|
if event.nil?
|
|
timepoint[:event].nil?
|
|
%w[availability_summary event_lineup event_lineup_entry opponent location].each do |t|
|
|
timepoint[t.to_sym].nil?
|
|
end
|
|
else
|
|
timepoint[:event] = event
|
|
timepoint[:event_lineup] = event_lineups.find{|l| l.event_id == event.id}
|
|
timepoint[:event_lineup_entry] = items.select{ |item| item.type == "event_lineup_entry" and item.event_lineup_id == timepoint[:event_lineup].id }
|
|
%w[availability_summary].each do |t|
|
|
timepoint[t.to_sym] = items.find { |item| item.type == t and item.event_id == event.id }
|
|
end
|
|
%w[].each do |t|
|
|
timepoint[t.to_sym] = items.select { |item| item.type == t and item.event_id == event.id }
|
|
end
|
|
%w[opponent location].each do |t|
|
|
timepoint[t.to_sym] = items.find { |item| item.type == t and item.id == event["#{t}_id"] }
|
|
end
|
|
timepoint[:by_member] = {}
|
|
members.each do |member|
|
|
timepoint[:by_member][member] = {}
|
|
%w[event_lineup_entry availability].each do |t|
|
|
timepoint[:by_member][member][t.to_sym] = items.find do |item|
|
|
item.type == t and item.event_id == event.id and item.member_id == member.id
|
|
end
|
|
end
|
|
end
|
|
timepoint[:by_member] = Hash[timepoint[:by_member].sort_by{|member, d| [ Availability::sort_by(d[:availability]), member.last_name]}]
|
|
end
|
|
timeline[event] = timepoint
|
|
|
|
end
|
|
context[:timeline] = timeline.map { |k, v| v }
|
|
context[:timeline][timeline_width].each { |k, v| context[k] = v }
|
|
context
|
|
end
|
|
|
|
def extract_flags(event_lineup_entry)
|
|
if matches = event_lineup_entry[:label].match(/(?<label>[A-z0-9]+)\s*\[(?<flags>[A-z,\s]+)\]/)
|
|
label = matches[:label]
|
|
flags = matches[:flags].split(",").map{|f| f.strip}
|
|
return [label, flags]
|
|
else
|
|
return [event_lineup_entry[:label], []]
|
|
end
|
|
end
|
|
|
|
def join_flags(event_lineup_entry, flags)
|
|
unless !event_lineup_entry
|
|
s = event_lineup_entry.label
|
|
if flags and flags.length > 0
|
|
s = "#{s} [#{flags.join(', ')}]"
|
|
end
|
|
else
|
|
""
|
|
end
|
|
end
|
|
|
|
end
|