function OnLoadPageData()
{
# Set up to get stats for current season
$four_months = 60 * 60 * 24 * 30 * 4;
$season_dates = Season::SeasonDates();
require_once 'stoolball/statistics/statistics-manager.class.php';
$statistics_manager = new StatisticsManager($this->GetSettings(), $this->GetDataConnection());
$statistics_manager->FilterMaxResults(1);
do {
# get stats
$statistics_manager->FilterAfterDate($season_dates[0]);
$this->best_batting = $statistics_manager->ReadBestBattingPerformance();
$this->best_bowling = $statistics_manager->ReadBestBowlingPerformance();
$this->most_runs = $statistics_manager->ReadBestPlayerAggregate("runs_scored");
$this->most_wickets = $statistics_manager->ReadBestPlayerAggregate("wickets");
$this->most_catches = $statistics_manager->ReadBestPlayerAggregate("catches");
# See what stats we've got
$this->best_batting_count = count($this->best_batting);
$this->best_bowling_count = count($this->best_bowling);
$this->most_runs_count = count($this->most_runs);
$this->most_wickets_count = count($this->most_wickets);
$this->most_catches_count = count($this->most_catches);
$has_player_stats = ($this->best_batting_count or $this->best_bowling_count or $this->most_runs_count or $this->most_wickets_count or $this->most_catches_count);
if ($has_player_stats) {
$start_year = gmdate("Y", $season_dates[0]);
$end_year = gmdate("Y", $season_dates[1]);
$this->highlight_label = ($start_year == $end_year ? $start_year : $start_year . "/" . substr($end_year, 2)) . " season";
}
# If there aren't any for this season (if it's the start of the season), go back 4 months and try again to get previous season
$season_dates = Season::SeasonDates($season_dates[0] - $four_months);
} while (!$has_player_stats);
unset($statistics_manager);
}
/**
* If the to or from parameters are in the query string apply date filter and return dates
* @param StatisticsManager $statistics_manager
*/
public static function SupportDateFilter(StatisticsManager $statistics_manager)
{
$filter_data = array(null, null, "");
$filter_data[0] = "";
if (isset($_GET['from'])) {
# Replace slashes with hyphens in submitted date because then it's treated as a British date, not American
$date = is_numeric($_GET['from']) ? (int) $_GET['from'] : strtotime(str_replace("/", "-", $_GET['from']));
if ($date !== false) {
$filter_data[0] = $date;
}
}
$to = "";
if (isset($_GET['to'])) {
# Replace slashes with hyphens in submitted date because then it's treated as a British date, not American
$date = is_numeric($_GET['to']) ? (int) $_GET['to'] : strtotime(str_replace("/", "-", $_GET['to']));
if ($date !== false) {
$filter_data[1] = $date;
}
}
if ($filter_data[0]) {
$statistics_manager->FilterAfterDate($filter_data[0]);
}
if ($filter_data[1]) {
$statistics_manager->FilterBeforeDate($filter_data[1]);
}
if ($filter_data[0] and $filter_data[1]) {
# Test whether this is a season
$three_months_later = intval($filter_data[0]) + 60 * 60 * 24 * 30 * 3;
$season_dates = Season::SeasonDates($three_months_later);
if ($filter_data[0] == $season_dates[0] and $filter_data[1] == $season_dates[1]) {
$start_year = gmdate("Y", $filter_data[0]);
$end_year = gmdate("Y", $filter_data[1]);
if ($start_year == $end_year) {
$filter_data[2] = "in the {$start_year} season ";
} else {
$filter_data[2] = "in the {$start_year}/" . substr($end_year, 2, 2) . " season ";
}
} else {
$filter_data[2] = "between " . Date::BritishDate($filter_data[0], false, true, false) . " and " . Date::BritishDate($filter_data[1], false, true, false) . " ";
}
} else {
if ($filter_data[0]) {
$filter_data[2] = "since " . Date::BritishDate($filter_data[0], false, true, false) . " ";
} else {
if ($filter_data[1]) {
$filter_data[2] = "before " . Date::BritishDate($filter_data[1], false, true, false) . " ";
}
}
}
return $filter_data;
}
function OnLoadPageData()
{
/* @var Team $team */
# check parameter
if (!isset($_GET['item']) or !is_numeric($_GET['item'])) {
$this->Redirect();
}
# get team
$team_manager = new TeamManager($this->GetSettings(), $this->GetDataConnection());
$team_manager->FilterByTeamType(array());
$team_manager->ReadById(array($_GET['item']));
$this->team = $team_manager->GetFirst();
unset($team_manager);
# must have found a team
if (!$this->team instanceof Team) {
$this->Redirect('/teams/');
}
# get match stats
require_once 'stoolball/statistics/statistics-manager.class.php';
$statistics_manager = new StatisticsManager($this->GetSettings(), $this->GetDataConnection());
$statistics_manager->FilterByTeam(array($this->team->GetId()));
$statistics_manager->ReadMatchStatistics();
$this->stats = $statistics_manager->GetItems();
# Get some stats on the best players
$this->statistics_query = "?team=" . $this->team->GetId();
if ($this->season) {
# use midpoint of season to get season dates for filter
$start_year = substr($this->season, 0, 4);
$end_year = strlen($this->season) == 7 ? $start_year + 1 : $start_year;
if ($start_year == $end_year) {
$season_dates = Season::SeasonDates(mktime(0, 0, 0, 7, 1, $start_year));
} else {
$season_dates = Season::SeasonDates(mktime(0, 0, 0, 12, 31, $start_year));
}
$statistics_manager->FilterAfterDate($season_dates[0]);
$statistics_manager->FilterBeforeDate($season_dates[1]);
$this->statistics_query .= "&from=" . $season_dates[0] . "&to=" . $season_dates[1];
}
$statistics_manager->FilterMaxResults(10);
$this->most_runs = $statistics_manager->ReadBestPlayerAggregate("runs_scored");
$this->most_wickets = $statistics_manager->ReadBestPlayerAggregate("wickets");
$this->most_catches = $statistics_manager->ReadBestPlayerAggregate("catches");
$this->most_run_outs = $statistics_manager->ReadBestPlayerAggregate("run_outs");
$this->most_player_of_match = $statistics_manager->ReadBestPlayerAggregate("player_of_match");
unset($statistics_manager);
}
function OnLoadPageData()
{
/* @var Ground $ground */
# check parameter
if (!isset($_GET['item']) or !is_numeric($_GET['item'])) {
$this->Redirect();
}
# get ground
$ground_manager = new GroundManager($this->GetSettings(), $this->GetDataConnection());
$ground_manager->ReadById(array($_GET['item']));
$this->ground = $ground_manager->GetFirst();
unset($ground_manager);
# must have found a ground
if (!$this->ground instanceof Ground) {
$this->Redirect('/play/');
}
# Get some stats on the best players
require_once 'stoolball/statistics/statistics-manager.class.php';
$statistics_manager = new StatisticsManager($this->GetSettings(), $this->GetDataConnection());
$statistics_manager->FilterByGround(array($this->ground->GetId()));
$this->seasons_with_statistics = $statistics_manager->ReadSeasonsWithPlayerStatistics();
$this->statistics["querystring"] = "?ground=" . $this->ground->GetId();
if ($this->season) {
# use midpoint of season to get season dates for filter
$start_year = substr($this->season, 0, 4);
$end_year = strlen($this->season) == 7 ? $start_year + 1 : $start_year;
if ($start_year == $end_year) {
$season_dates = Season::SeasonDates(mktime(0, 0, 0, 7, 1, $start_year));
} else {
$season_dates = Season::SeasonDates(mktime(0, 0, 0, 12, 31, $start_year));
}
$statistics_manager->FilterAfterDate($season_dates[0]);
$statistics_manager->FilterBeforeDate($season_dates[1]);
$this->statistics["querystring"] .= "&from=" . $season_dates[0] . "&to=" . $season_dates[1];
}
require_once "_summary-data-query.php";
unset($statistics_manager);
}
/**
* Creates the controls when the editor is in its fixture view
*
*/
private function CreateFixtureControls(Match $match, XhtmlElement $match_box)
{
$css_class = 'TournamentEdit';
if ($this->GetCssClass()) {
$css_class .= ' ' . $this->GetCssClass();
}
$match_outer_1 = new XhtmlElement('div');
$match_outer_1->SetCssClass($css_class);
$this->SetCssClass('');
$match_outer_1->SetXhtmlId($this->GetNamingPrefix());
$match_outer_2 = new XhtmlElement('div');
$this->AddControl($match_outer_1);
$match_outer_1->AddControl($match_outer_2);
$match_outer_2->AddControl($match_box);
if ($match->GetId()) {
$heading = "Edit tournament";
} else {
$heading = "Add your tournament";
}
if ($this->show_step_number) {
$heading .= ' – step 1 of 3';
}
$o_title_inner_1 = new XhtmlElement('span', $heading);
$o_title_inner_2 = new XhtmlElement('span', $o_title_inner_1);
$o_title_inner_3 = new XhtmlElement('span', $o_title_inner_2);
$match_box->AddControl(new XhtmlElement('h2', $o_title_inner_3, "large"));
# Tournament title
$suggested_title = $match->GetTitle();
if (isset($this->context_season)) {
$suggested_title = $this->GetContextSeason()->GetCompetition()->GetName();
if (strpos(strtolower($suggested_title), 'tournament') === false) {
$suggested_title .= ' tournament';
}
} else {
if (isset($this->context_team)) {
$suggested_title = $this->GetContextTeam()->GetName();
if (strpos(strtolower($suggested_title), 'tournament') === false) {
$suggested_title .= ' tournament';
}
}
}
if ($suggested_title == "To be confirmed tournament") {
$suggested_title = "";
}
if ($suggested_title == "To be confirmed v To be confirmed") {
$suggested_title = "";
}
$title = new TextBox($this->GetNamingPrefix() . 'Title', $suggested_title, $this->IsValidSubmit());
$title->SetMaxLength(200);
$match_box->AddControl(new FormPart('Tournament name', $title));
# Open or invite?
require_once 'xhtml/forms/radio-button.class.php';
$qualify_set = new XhtmlElement('fieldset');
$qualify_set->SetCssClass('formPart radioButtonList');
$qualify_set->AddControl(new XhtmlElement('legend', 'Who can play?', 'formLabel'));
$qualify_radios = new XhtmlElement('div', null, 'formControl');
$qualify_set->AddControl($qualify_radios);
$qualify_radios->AddControl(new RadioButton($this->GetNamingPrefix() . 'Open', $this->GetNamingPrefix() . 'Qualify', 'any team may enter', MatchQualification::OPEN_TOURNAMENT, $match->GetQualificationType() === MatchQualification::OPEN_TOURNAMENT or !$match->GetId(), $this->IsValidSubmit()));
$qualify_radios->AddControl(new RadioButton($this->GetNamingPrefix() . 'Qualify', $this->GetNamingPrefix() . 'Qualify', 'only invited or qualifying teams can enter', MatchQualification::CLOSED_TOURNAMENT, $match->GetQualificationType() === MatchQualification::CLOSED_TOURNAMENT, $this->IsValidSubmit()));
$match_box->AddControl($qualify_set);
# Player type
$suggested_type = 2;
if (isset($this->context_season)) {
$suggested_type = $this->context_season->GetCompetition()->GetPlayerType();
} elseif (isset($this->context_team)) {
$suggested_type = $this->context_team->GetPlayerType();
}
if (!is_null($match->GetPlayerType())) {
$suggested_type = $match->GetPlayerType();
}
# Saved value overrides suggestion
$player_set = new XhtmlElement('fieldset');
$player_set->SetCssClass('formPart radioButtonList');
$player_set->AddControl(new XhtmlElement('legend', 'Type of teams', 'formLabel'));
$player_radios = new XhtmlElement('div', null, 'formControl');
$player_set->AddControl($player_radios);
$player_radios_1 = new XhtmlElement('div', null, 'column');
$player_radios_2 = new XhtmlElement('div', null, 'column');
$player_radios->AddControl($player_radios_1);
$player_radios->AddControl($player_radios_2);
$player_radios_1->AddControl(new RadioButton($this->GetNamingPrefix() . 'Ladies', $this->GetNamingPrefix() . 'PlayerType', 'Ladies', 2, $suggested_type === 2, $this->IsValidSubmit()));
$player_radios_1->AddControl(new RadioButton($this->GetNamingPrefix() . 'Mixed', $this->GetNamingPrefix() . 'PlayerType', 'Mixed', 1, $suggested_type === 1, $this->IsValidSubmit()));
$player_radios_2->AddControl(new RadioButton($this->GetNamingPrefix() . 'Girls', $this->GetNamingPrefix() . 'PlayerType', 'Junior girls', 5, $suggested_type === 5, $this->IsValidSubmit()));
$player_radios_2->AddControl(new RadioButton($this->GetNamingPrefix() . 'Children', $this->GetNamingPrefix() . 'PlayerType', 'Junior mixed', 4, $suggested_type === 6, $this->IsValidSubmit()));
$match_box->AddControl($player_set);
# How many?
$per_side_box = new XhtmlSelect($this->GetNamingPrefix() . "Players", null, $this->IsValid());
$per_side_box->SetBlankFirst(true);
for ($i = 6; $i <= 16; $i++) {
$per_side_box->AddControl(new XhtmlOption($i));
}
if ($match->GetIsMaximumPlayersPerTeamKnown()) {
$per_side_box->SelectOption($match->GetMaximumPlayersPerTeam());
} else {
if (!$match->GetId()) {
# Use eight as sensible default for new tournaments
$per_side_box->SelectOption(8);
}
}
$players_per_team = new XhtmlElement("label", $per_side_box);
$players_per_team->AddAttribute("for", $this->GetNamingPrefix() . "Players");
$players_per_team->AddControl(" players per team");
$players_part = new FormPart("How many players?", $players_per_team);
$players_part->AddCssClass("playersPerTeam");
$match_box->AddControl($players_part);
# Overs
$overs_box = new XhtmlSelect($this->GetNamingPrefix() . "Overs", null, $this->IsValid());
$overs_box->SetBlankFirst(true);
for ($i = 2; $i <= 8; $i++) {
$overs_box->AddControl(new XhtmlOption($i));
}
if ($match->GetIsOversKnown()) {
$overs_box->SelectOption($match->GetOvers());
}
$overs_label = new XhtmlElement("label", "Overs per innings");
$overs_label->AddAttribute("for", $overs_box->GetXhtmlId());
$overs_part = new FormPart($overs_label, new XhtmlElement("div", $overs_box));
$overs_part->AddCssClass("overs");
$match_box->AddControl($overs_part);
# Start date and time
if (!$match->GetStartTime()) {
# if no date set, use specified default
if ($this->i_default_time) {
$match->SetStartTime($this->i_default_time);
} else {
# if no date set and no default, default to today at 10.30am BST
# NOTE that if this is a new tournament in an old season, this date won't be selected because the available
# dates will be limited below and won't include today. It'll be the same day in the relevant year though.
$i_now = gmdate('U');
$match->SetStartTime(gmmktime(9, 30, 00, (int) gmdate('n', $i_now), (int) gmdate('d', $i_now), (int) gmdate('Y', $i_now)));
$match->SetIsStartTimeKnown(true);
}
}
$o_date = new DateControl($this->GetNamingPrefix() . 'Start', $match->GetStartTime(), $match->GetIsStartTimeKnown(), $this->IsValidSubmit());
$o_date->SetShowTime(true);
$o_date->SetRequireTime(false);
$o_date->SetMinuteInterval(5);
# if only one season to choose from, limit available dates to the length of that season
if ($this->context_season instanceof Season) {
if ($this->context_season->GetStartYear() == $this->context_season->GetEndYear()) {
$i_mid_season = gmmktime(0, 0, 0, 6, 30, $this->context_season->GetStartYear());
} else {
$i_mid_season = gmmktime(0, 0, 0, 12, 31, $this->context_season->GetStartYear());
}
$season_dates = Season::SeasonDates($i_mid_season);
$season_start_month = gmdate('n', $season_dates[0]);
$season_end_month = gmdate('n', $season_dates[1]);
if ($season_start_month) {
$o_date->SetMonthStart($season_start_month);
}
if ($season_end_month) {
$o_date->SetMonthEnd($season_end_month);
}
$season_start_year = $this->context_season->GetStartYear();
$season_end_year = $this->context_season->GetEndYear();
if ($season_start_year) {
$o_date->SetYearStart($season_start_year);
}
if ($season_end_year) {
$o_date->SetYearEnd($season_end_year);
}
}
$o_date_part = new FormPart('When?', $o_date);
$o_date_part->SetIsFieldset(true);
$match_box->AddControl($o_date_part);
# Where?
$o_ground_list = new XhtmlSelect($this->GetNamingPrefix() . 'Ground');
$o_ground_list->AddControl(new XhtmlOption("Don't know", -1));
$o_ground_list->AddControl(new XhtmlOption('Not listed (type the address in the notes field)', -2));
# Promote the most likely grounds to the top of the list
$likely_ground_ids = array();
if ($match->GetGroundId()) {
$likely_ground_ids[] = $match->GetGroundId();
}
foreach ($this->probable_teams as $o_team) {
$likely_ground_ids[] = $o_team->GetGround()->GetId();
}
if (isset($this->context_season)) {
foreach ($this->context_season->GetTeams() as $o_team) {
$likely_ground_ids[] = $o_team->GetGround()->GetId();
}
}
if (isset($this->context_team) and is_object($this->context_team->GetGround())) {
$likely_ground_ids[] = $this->context_team->GetGround()->GetId();
}
$likely_grounds = array();
$a_other_grounds = array();
/* @var $o_ground Ground */
foreach ($this->grounds->GetItems() as $o_ground) {
if (array_search($o_ground->GetId(), $likely_ground_ids) > -1) {
$likely_grounds[] = $o_ground;
} else {
$a_other_grounds[] = $o_ground;
}
}
# Add home grounds
foreach ($likely_grounds as $o_ground) {
$option = new XhtmlOption($o_ground->GetNameAndTown(), $o_ground->GetId());
$option->SetGroupName('Likely grounds');
$o_ground_list->AddControl($option);
}
# Add away grounds
foreach ($a_other_grounds as $o_ground) {
$option = new XhtmlOption($o_ground->GetNameAndTown(), $o_ground->GetId());
$option->SetGroupName('Other grounds');
$o_ground_list->AddControl($option);
}
# Select ground
if ($match->GetGroundId()) {
$o_ground_list->SelectOption($match->GetGroundId());
} elseif (isset($this->context_team)) {
$o_ground_list->SelectOption($this->context_team->GetGround()->GetId());
}
$o_ground_part = new FormPart('Where?', $o_ground_list);
$match_box->AddControl($o_ground_part);
# Notes
$o_notes = new TextBox($this->GetNamingPrefix() . 'Notes', $match->GetNotes());
$o_notes->SetMode(TextBoxMode::MultiLine());
$o_notes_part = new FormPart('Notes<br />(remember to include contact details)', $o_notes);
$match_box->AddControl($o_notes_part);
# Remember short URL
$o_short_url = new TextBox($this->GetNamingPrefix() . 'ShortUrl', $match->GetShortUrl());
$o_short_url->SetMode(TextBoxMode::Hidden());
$match_box->AddControl($o_short_url);
# Note the context team to be added to the tournament by default
if (isset($this->context_team)) {
$context_team_box = new TextBox($this->GetNamingPrefix() . 'ContextTeam', $this->context_team->GetId());
$context_team_box->SetMode(TextBoxMode::Hidden());
$match_box->AddControl($context_team_box);
}
# Change Save button to "Next" button
if ($this->show_step_number) {
$this->SetButtonText('Next »');
}
}
function OnLoadPageData()
{
/* @var $match_manager MatchManager */
/* @var $editor TournamentEditControl */
# get id of Match
$i_id = $this->match_manager->GetItemId();
if (!$i_id) {
return;
}
# no need to read if redisplaying invalid form
if ($this->IsValid()) {
$this->match_manager->ReadByMatchId(array($i_id));
$this->tournament = $this->match_manager->GetFirst();
if ($this->tournament instanceof Match) {
$this->b_user_is_match_owner = AuthenticationManager::GetUser()->GetId() == $this->tournament->GetAddedBy()->GetId();
$this->b_is_tournament = $this->tournament->GetMatchType() == MatchType::TOURNAMENT;
} else {
return;
}
}
if ($this->b_user_is_match_admin or $this->b_user_is_match_owner) {
# Get all seasons
# Don't filter by match type at this point because we want to know what other types of match the seasons support.
# If it's tournaments only, they'll be treated differently.
require_once 'stoolball/season-manager.class.php';
$season_manager = new SeasonManager($this->GetSettings(), $this->GetDataConnection());
$season_dates = Season::SeasonDates($this->tournament->GetStartTime());
$season_manager->FilterByDateStart($season_dates[0]);
$season_manager->FilterByDateEnd($season_dates[1]);
$season_manager->ReadSeasonSummaries(array($this->tournament->GetPlayerType()));
$this->editor->Seasons()->SetItems($season_manager->GetItems());
unset($season_manager);
}
}
/**
* Analyses supplied match data and makes relevant statistics available
*
* @param Match[] $data
* @param Team $context_team
*/
public function AnalyseMatchData($data, Team $context_team)
{
foreach ($data as $match) {
/* @var $match Match */
$season_dates = Season::SeasonDates($match->GetStartTime());
$season_key = date('Y', $season_dates[0]);
if ($season_key == date('Y', $season_dates[1])) {
# For summer stats, use the ground the match is played at rather than the team
# role to decide whether it's a home match.
# In this case we're interested in home advantage, which applies whether you're
# the team paying for the pitch or not.
$at_home = $context_team->GetGround()->GetId() == $match->GetGroundId();
$swap_home_away_role = ($context_team->GetId() == $match->GetHomeTeamId()) != $at_home;
} else {
# Winter seasons span two years, so add second year to key
$season_key .= "/" . date('y', $season_dates[1]);
# For winter it's simpler - just use the team role. Teams are rarely down to play
# at their home ground because they all
# play "away" at a leisure centre. Using the rules above ends up with teams
# getting the stats which belong to their opponents.
$at_home = $context_team->GetId() == $match->GetHomeTeamId();
$swap_home_away_role = false;
}
//$at_home = ($context_team->GetId() == $match->GetHomeTeamId());
//$swap_home_away_role = false;
if (!in_array($season_key, $this->seasons)) {
$this->seasons[] = $season_key;
}
if ($match->Result()->GetIsHomeWin() and !$swap_home_away_role or $match->Result()->GetIsAwayWin() and $swap_home_away_role) {
if ($at_home) {
if (!array_key_exists($season_key, $this->home_wins)) {
$this->home_wins[$season_key] = array();
}
$this->home_wins[$season_key][] = $match;
# Note the opponents played, and the results achieved against them
$opponent = $swap_home_away_role ? $match->GetHomeTeam() : $match->GetAwayTeam();
$this->EnsureTeamArray($season_key, $opponent);
$this->opponents[$season_key][$opponent->GetId()]['matches']++;
$this->opponents[$season_key][$opponent->GetId()]['wins']++;
} else {
if (!array_key_exists($season_key, $this->away_losses)) {
$this->away_losses[$season_key] = array();
}
$this->away_losses[$season_key][] = $match;
# Note the opponents played, and the results achieved against them
$opponent = $swap_home_away_role ? $match->GetAwayTeam() : $match->GetHomeTeam();
$this->EnsureTeamArray($season_key, $opponent);
$this->opponents[$season_key][$opponent->GetId()]['matches']++;
$this->opponents[$season_key][$opponent->GetId()]['losses']++;
}
} else {
if ($match->Result()->GetIsAwayWin() and !$swap_home_away_role or $match->Result()->GetIsHomeWin() and $swap_home_away_role) {
if ($at_home) {
if (!array_key_exists($season_key, $this->home_losses)) {
$this->home_losses[$season_key] = array();
}
$this->home_losses[$season_key][] = $match;
# Note the opponents played, and the results achieved against them
$opponent = $swap_home_away_role ? $match->GetHomeTeam() : $match->GetAwayTeam();
$this->EnsureTeamArray($season_key, $opponent);
$this->opponents[$season_key][$opponent->GetId()]['matches']++;
$this->opponents[$season_key][$opponent->GetId()]['losses']++;
} else {
if (!array_key_exists($season_key, $this->away_wins)) {
$this->away_wins[$season_key] = array();
}
$this->away_wins[$season_key][] = $match;
# Note the opponents played, and the results achieved against them
$opponent = $swap_home_away_role ? $match->GetAwayTeam() : $match->GetHomeTeam();
$this->EnsureTeamArray($season_key, $opponent);
$this->opponents[$season_key][$opponent->GetId()]['matches']++;
$this->opponents[$season_key][$opponent->GetId()]['wins']++;
}
} else {
if ($match->Result()->GetIsEqualResult()) {
if ($at_home) {
if (!array_key_exists($season_key, $this->home_equal_results)) {
$this->home_equal_results[$season_key] = array();
}
$this->home_equal_results[$season_key][] = $match;
# Note the opponents played, and the results achieved against them
$opponent = $swap_home_away_role ? $match->GetHomeTeam() : $match->GetAwayTeam();
$this->EnsureTeamArray($season_key, $opponent);
$this->opponents[$season_key][$opponent->GetId()]['matches']++;
$this->opponents[$season_key][$opponent->GetId()]['equal']++;
} else {
if (!array_key_exists($season_key, $this->away_equal_results)) {
$this->away_equal_results[$season_key] = array();
}
$this->away_equal_results[$season_key][] = $match;
# Note the opponents played, and the results achieved against them
$opponent = $swap_home_away_role ? $match->GetAwayTeam() : $match->GetHomeTeam();
$this->EnsureTeamArray($season_key, $opponent);
$this->opponents[$season_key][$opponent->GetId()]['matches']++;
$this->opponents[$season_key][$opponent->GetId()]['equal']++;
}
} else {
if ($match->Result()->GetIsNoResult() and !$match->Result()->GetResultType() == MatchResult::POSTPONED) {
if ($at_home) {
if (!array_key_exists($season_key, $this->home_no_results)) {
$this->home_no_results[$season_key] = array();
}
$this->home_no_results[$season_key][] = $match;
# Note the opponents played, and the results achieved against them
$opponent = $swap_home_away_role ? $match->GetHomeTeam() : $match->GetAwayTeam();
$this->EnsureTeamArray($season_key, $opponent);
$this->opponents[$season_key][$opponent->GetId()]['matches']++;
$this->opponents[$season_key][$opponent->GetId()]['cancelled']++;
} else {
if (!array_key_exists($season_key, $this->away_no_results)) {
$this->away_no_results[$season_key] = array();
}
$this->away_no_results[$season_key][] = $match;
# Note the opponents played, and the results achieved against them
$opponent = $swap_home_away_role ? $match->GetAwayTeam() : $match->GetHomeTeam();
$this->EnsureTeamArray($season_key, $opponent);
$this->opponents[$season_key][$opponent->GetId()]['matches']++;
$this->opponents[$season_key][$opponent->GetId()]['cancelled']++;
}
}
}
}
}
# Now gather runs scored and conceded
$run_data_for_match = false;
if ($at_home) {
if (!array_key_exists($season_key, $this->home_runs_scored)) {
$this->home_runs_scored[$season_key] = array();
}
if (!array_key_exists($season_key, $this->home_runs_conceded)) {
$this->home_runs_conceded[$season_key] = array();
}
$context_team_runs = $swap_home_away_role ? $match->Result()->GetAwayRuns() : $match->Result()->GetHomeRuns();
$opposition_runs = $swap_home_away_role ? $match->Result()->GetHomeRuns() : $match->Result()->GetAwayRuns();
if ($context_team_runs) {
$this->home_runs_scored[$season_key][] = $context_team_runs;
$run_data_for_match = true;
}
if ($opposition_runs) {
$this->home_runs_conceded[$season_key][] = $opposition_runs;
$run_data_for_match = true;
}
} else {
if (!array_key_exists($season_key, $this->away_runs_scored)) {
$this->away_runs_scored[$season_key] = array();
}
if (!array_key_exists($season_key, $this->away_runs_conceded)) {
$this->away_runs_conceded[$season_key] = array();
}
$context_team_runs = $swap_home_away_role ? $match->Result()->GetHomeRuns() : $match->Result()->GetAwayRuns();
$opposition_runs = $swap_home_away_role ? $match->Result()->GetAwayRuns() : $match->Result()->GetHomeRuns();
if ($context_team_runs) {
$this->away_runs_scored[$season_key][] = $context_team_runs;
$run_data_for_match = true;
}
if ($opposition_runs) {
$this->away_runs_conceded[$season_key][] = $opposition_runs;
$run_data_for_match = true;
}
}
if ($run_data_for_match) {
if (!array_key_exists($season_key, $this->matches_with_run_data)) {
$this->matches_with_run_data[$season_key] = 0;
}
$this->matches_with_run_data[$season_key]++;
}
}
rsort($this->seasons);
}
/**
* Adds controls to edit a team score
*
* @param XhtmlElement $o_container
* @param string $s_id_prefix
* @param Match $o_match
* @param Team $o_team
* @param int $i_runs
* @param int $i_wickets
*/
private function CreateTeamScoreControls($o_container, $s_team_role, Match $o_match, Team $o_team = null, $i_runs, $i_wickets)
{
$o_box = new XhtmlElement('div');
$o_runs = new TextBox($this->GetNamingPrefix() . $s_team_role . 'Runs', $i_runs);
$o_runs->SetCssClass("numeric");
if ($i_runs == null) {
$o_runs->PopulateData();
}
$s_runs_label = (is_null($o_team) ? $s_team_role : $o_team->GetName()) . ' score';
$o_part = new FormPart($s_runs_label, $o_box);
$o_box->AddControl($o_runs);
$o_part->GetLabel()->AddAttribute('for', $o_runs->GetXhtmlId());
$o_wickets = new XhtmlSelect($this->GetNamingPrefix() . $s_team_role . 'Wickets', ' for ');
$o_wickets->SetBlankFirst(true);
$max_wickets = $o_match->GetMaximumPlayersPerTeam() - 2;
$season_dates = Season::SeasonDates($o_match->GetStartTime());
# working with GMT
if (Date::Year($season_dates[0]) != Date::Year($season_dates[1])) {
# outdoor needs maximum-2, but indoor needs maximum-1 cos last batter can play on.
# if there's any chance it's indoor use maximum-1
$max_wickets = $o_match->GetMaximumPlayersPerTeam() - 1;
}
for ($i = 0; $i <= $max_wickets; $i++) {
$o_wickets->AddControl(new XhtmlOption($i));
}
$o_wickets->AddControl(new XhtmlOption('all out', -1));
$o_wickets->SelectOption($i_wickets);
$o_box->AddControl($o_wickets);
$o_container->AddControl($o_part);
}
protected function CreateControls()
{
$o_match = $this->GetDataObject();
if (is_null($o_match)) {
$o_match = new Match($this->GetSettings());
}
/* @var $o_match Match */
/* @var $o_team Team */
$b_got_home = !is_null($o_match->GetHomeTeam());
$b_got_away = !is_null($o_match->GetAwayTeam());
$b_is_new_match = !(bool) $o_match->GetId();
$b_is_tournament_match = false;
if ($this->i_match_type == MatchType::TOURNAMENT_MATCH) {
$b_is_tournament_match = $this->tournament instanceof Match;
} else {
if ($o_match->GetMatchType() == MatchType::TOURNAMENT_MATCH and $o_match->GetTournament() instanceof Match) {
$this->SetTournament($o_match->GetTournament());
$this->SetMatchType($o_match->GetMatchType());
$b_is_tournament_match = true;
}
}
$o_match_outer_1 = new XhtmlElement('div');
$o_match_outer_1->SetCssClass('MatchFixtureEdit');
$o_match_outer_1->AddCssClass($this->GetCssClass());
$this->SetCssClass('');
$o_match_outer_1->SetXhtmlId($this->GetNamingPrefix());
$o_match_outer_2 = new XhtmlElement('div');
$o_match_box = new XhtmlElement('div');
$this->AddControl($o_match_outer_1);
$o_match_outer_1->AddControl($o_match_outer_2);
$o_match_outer_2->AddControl($o_match_box);
if ($this->GetShowHeading()) {
$s_heading = str_replace('{0}', MatchType::Text($this->i_match_type), $this->GetHeading());
# Add match type if required
$o_title_inner_1 = new XhtmlElement('span', htmlentities($s_heading, ENT_QUOTES, "UTF-8", false));
$o_title_inner_2 = new XhtmlElement('span', $o_title_inner_1);
$o_title_inner_3 = new XhtmlElement('span', $o_title_inner_2);
$o_match_box->AddControl(new XhtmlElement('h2', $o_title_inner_3, "medium large"));
}
# Offer choice of season if appropriate
$season_count = $this->seasons->GetCount();
if ($season_count == 1 and $this->i_match_type != MatchType::PRACTICE) {
$o_season_id = new TextBox($this->GetNamingPrefix() . 'Season', $this->seasons->GetFirst()->GetId());
$o_season_id->SetMode(TextBoxMode::Hidden());
$o_match_box->AddControl($o_season_id);
} elseif ($season_count > 1 and $this->i_match_type != MatchType::PRACTICE) {
$o_season_id = new XhtmlSelect($this->GetNamingPrefix() . 'Season', '', $this->IsValidSubmit());
foreach ($this->Seasons()->GetItems() as $season) {
$o_season_id->AddControl(new XhtmlOption($season->GetCompetitionName(), $season->GetId()));
}
$o_match_box->AddControl(new FormPart('Competition', $o_season_id));
}
# Start date and time
$match_time_known = (bool) $o_match->GetStartTime();
if (!$match_time_known) {
# if no date set, use specified default
if ($this->i_default_time) {
$o_match->SetStartTime($this->i_default_time);
if ($b_is_tournament_match) {
$o_match->SetIsStartTimeKnown(false);
}
} else {
# if no date set and no default, default to today at 6.30pm BST
$i_now = gmdate('U');
$o_match->SetStartTime(gmmktime(17, 30, 00, (int) gmdate('n', $i_now), (int) gmdate('d', $i_now), (int) gmdate('Y', $i_now)));
}
}
$o_date = new DateControl($this->GetNamingPrefix() . 'Start', $o_match->GetStartTime(), $o_match->GetIsStartTimeKnown(), $this->IsValidSubmit());
$o_date->SetShowTime(true);
$o_date->SetRequireTime(false);
$o_date->SetMinuteInterval(5);
# if no date set and only one season to choose from, limit available dates to the length of that season
if (!$match_time_known and $season_count == 1) {
if ($this->Seasons()->GetFirst()->GetStartYear() == $this->Seasons()->GetFirst()->GetEndYear()) {
$i_mid_season = gmmktime(0, 0, 0, 6, 30, $this->Seasons()->GetFirst()->GetStartYear());
} else {
$i_mid_season = gmmktime(0, 0, 0, 12, 31, $this->Seasons()->GetFirst()->GetStartYear());
}
$season_dates = Season::SeasonDates($i_mid_season);
$season_start_month = gmdate('n', $season_dates[0]);
$season_end_month = gmdate('n', $season_dates[1]);
if ($season_start_month) {
$o_date->SetMonthStart($season_start_month);
}
if ($season_end_month) {
$o_date->SetMonthEnd($season_end_month + 1);
}
// TODO: need a better way to handle this, allowing overlap. Shirley has indoor matches until early April.
$season_start_year = $this->Seasons()->GetFirst()->GetStartYear();
$season_end_year = $this->Seasons()->GetFirst()->GetEndYear();
if ($season_start_year) {
$o_date->SetYearStart($season_start_year);
}
if ($season_end_year) {
$o_date->SetYearEnd($season_end_year);
}
}
if ($b_is_tournament_match) {
$o_date->SetShowDate(false);
$o_date->SetShowTime(false);
$o_match_box->AddControl($o_date);
} else {
$o_date_part = new FormPart('When?', $o_date);
$o_date_part->SetIsFieldset(true);
$o_match_box->AddControl($o_date_part);
}
# Who's playing?
if ($this->i_match_type == MatchType::PRACTICE and isset($this->context_team)) {
$home_id = new TextBox($this->GetNamingPrefix() . 'Home', $this->context_team->GetId());
$home_id->SetMode(TextBoxMode::Hidden());
$away_id = new TextBox($this->GetNamingPrefix() . 'Away', $this->context_team->GetId());
$away_id->SetMode(TextBoxMode::Hidden());
$o_match_box->AddControl($home_id);
$o_match_box->AddControl($away_id);
} else {
$o_home_list = new XhtmlSelect($this->GetNamingPrefix() . 'Home');
$o_away_list = new XhtmlSelect($this->GetNamingPrefix() . 'Away');
$first_real_team_index = 0;
if ($this->b_user_is_admin) {
# Option of not specifying teams is currently admin-only
# Value of 0 is important because PHP sees it as boolean negative, but it can be used as the indexer of an array in JavaScript
$o_home_list->AddControl(new XhtmlOption("Don't know yet", '0'));
$o_away_list->AddControl(new XhtmlOption("Don't know yet", '0'));
$first_real_team_index = 1;
}
foreach ($this->a_teams as $group_name => $teams) {
foreach ($teams as $o_team) {
$home_option = new XhtmlOption($o_team->GetName(), $o_team->GetId());
if (is_string($group_name) and $group_name) {
$home_option->SetGroupName($group_name);
}
$o_home_list->AddControl($home_option);
$away_option = new XhtmlOption($o_team->GetName(), $o_team->GetId());
if (is_string($group_name) and $group_name) {
$away_option->SetGroupName($group_name);
}
$o_away_list->AddControl($away_option);
}
}
$o_home_part = new FormPart('Home team', $o_home_list);
$o_away_part = new FormPart('Away team', $o_away_list);
$o_match_box->AddControl($o_home_part);
$o_match_box->AddControl($o_away_part);
if ($b_got_home) {
$o_home_list->SelectOption($o_match->GetHomeTeamId());
}
if (!$b_got_home and $b_is_new_match) {
// if no home team data, select the first team by default
// unless editing a match, in which case it may be correct to have no teams (eg cup final)
$o_home_list->SelectIndex($first_real_team_index);
}
if (!$b_got_away and $b_is_new_match) {
// if no away team data, select the second team as the away team so that it's not the same as the first
// unless editing a match, in which case it may be correct to have no teams (eg cup final).
$o_away_list->SelectIndex($first_real_team_index + 1);
// if there was a home team but not an away team, make sure we don't select the home team against itself
if ($b_got_home and $o_away_list->GetSelectedValue() == (string) $o_match->GetHomeTeamId()) {
$o_away_list->SelectIndex($first_real_team_index);
}
} else {
if ($b_got_away) {
$o_away_list->SelectOption($o_match->GetAwayTeamId());
}
if (!$b_is_new_match) {
# Note which away team was previously saved, even if it's "not known" - this is for JavaScript to know it shouldn't auto-change the away team
$away_saved = new TextBox($this->GetNamingPrefix() . 'SavedAway', $o_match->GetAwayTeamId());
$away_saved->SetMode(TextBoxMode::Hidden());
$o_match_box->AddControl($away_saved);
unset($away_saved);
}
}
}
# Where?
# If tournament match, assume same ground as tournament. Otherwise ask the user for ground.
if ($b_is_tournament_match) {
$ground = new TextBox($this->GetNamingPrefix() . 'Ground', $this->tournament->GetGroundId() ? $this->tournament->GetGroundId() : $o_match->GetGroundId());
$ground->SetMode(TextBoxMode::Hidden());
$o_match_box->AddControl($ground);
} else {
$o_ground_list = new XhtmlSelect($this->GetNamingPrefix() . 'Ground');
$o_ground_list->AddControl(new XhtmlOption("Don't know", -1));
$o_ground_list->AddControl(new XhtmlOption('Not listed (type the address in the notes field)', -2));
# Promote home grounds for this season to the top of the list
$a_home_ground_ids = array();
foreach ($this->a_teams as $teams) {
foreach ($teams as $o_team) {
$a_home_ground_ids[$o_team->GetId()] = $o_team->GetGround()->GetId();
}
}
$a_home_grounds = array();
$a_other_grounds = array();
/* @var $o_ground Ground */
foreach ($this->a_grounds as $o_ground) {
if (array_search($o_ground->GetId(), $a_home_ground_ids) > -1) {
$a_home_grounds[] = $o_ground;
} else {
$a_other_grounds[] = $o_ground;
}
}
# Add home grounds
foreach ($a_home_grounds as $o_ground) {
$option = new XhtmlOption($o_ground->GetNameAndTown(), $o_ground->GetId());
$option->SetGroupName('Home grounds');
$o_ground_list->AddControl($option);
}
# Add away grounds
foreach ($a_other_grounds as $o_ground) {
$option = new XhtmlOption($o_ground->GetNameAndTown(), $o_ground->GetId());
$option->SetGroupName('Away grounds');
$o_ground_list->AddControl($option);
}
# Select ground
if ($o_match->GetGroundId()) {
$o_ground_list->SelectOption($o_match->GetGroundId());
} elseif ($this->i_match_type == MatchType::PRACTICE and isset($this->context_team)) {
$o_ground_list->SelectOption($this->context_team->GetGround()->GetId());
}
$o_ground_part = new FormPart('Where?', $o_ground_list);
$o_match_box->AddControl($o_ground_part);
# Note which grounds belong to which teams, for use by match-fixture-edit-control.js to select a ground when the home team is changed
# Format is 1,2;2,3;4,5
# where ; separates each team, and for each team the first number identifies the team and the second is the ground
$s_team_ground = '';
foreach ($a_home_ground_ids as $i_team => $i_ground) {
if ($s_team_ground) {
$s_team_ground .= ';';
}
$s_team_ground .= $i_team . ',' . $i_ground;
}
$o_hidden = new TextBox($this->GetNamingPrefix() . 'TeamGround', $s_team_ground);
$o_hidden->SetMode(TextBoxMode::Hidden());
$o_match_box->AddControl($o_hidden);
unset($o_hidden);
# Note which ground was previously saved - this is for JavaScript to know it shouldn't auto-change the ground
if (!$b_is_new_match) {
$o_hidden = new TextBox($this->GetNamingPrefix() . 'SavedGround', $o_match->GetGroundId());
$o_hidden->SetMode(TextBoxMode::Hidden());
$o_match_box->AddControl($o_hidden);
unset($o_hidden);
}
}
# Notes
$o_notes = new TextBox($this->GetNamingPrefix() . 'Notes', $o_match->GetNotes());
$o_notes->SetMode(TextBoxMode::MultiLine());
$o_notes_part = new FormPart('Notes', $o_notes);
$o_match_box->AddControl($o_notes_part);
# Remember match type, tournament and short URL
$o_type = new TextBox($this->GetNamingPrefix() . 'MatchType', $this->GetMatchType());
$o_type->SetMode(TextBoxMode::Hidden());
$o_match_box->AddControl($o_type);
if ($b_is_tournament_match) {
$tourn_box = new TextBox($this->GetNamingPrefix() . 'Tournament', $this->tournament->GetId());
$tourn_box->SetMode(TextBoxMode::Hidden());
$o_match_box->AddControl($tourn_box);
}
$o_short_url = new TextBox($this->GetNamingPrefix() . 'ShortUrl', $o_match->GetShortUrl());
$o_short_url->SetMode(TextBoxMode::Hidden());
$o_match_box->AddControl($o_short_url);
# Note the context team - to be picked up by JavaScript to enable auto-changing of away team if
# context team is not selected as home team
if (isset($this->context_team)) {
$context_team_box = new TextBox($this->GetNamingPrefix() . 'ContextTeam', $this->context_team->GetId());
$context_team_box->SetMode(TextBoxMode::Hidden());
$o_match_box->AddControl($context_team_box);
}
}
function OnLoadPageData()
{
/* @var Team $team */
# check parameter
if (!isset($_GET['item']) or !is_numeric($_GET['item'])) {
$this->Redirect();
}
# new data manager
$team_manager = new TeamManager($this->GetSettings(), $this->GetDataConnection());
$match_manager = new MatchManager($this->GetSettings(), $this->GetDataConnection());
# get teams
$team_manager->FilterByTeamType(array());
$team_manager->ReadById(array($_GET['item']));
$this->team = $team_manager->GetFirst();
# must have found a team
if (!$this->team instanceof Team) {
$this->Redirect('/teams/');
}
# Update search engine
if ($this->team->GetSearchUpdateRequired()) {
require_once "search/team-search-adapter.class.php";
$this->SearchIndexer()->DeleteFromIndexById("team" . $this->team->GetId());
$adapter = new TeamSearchAdapter($this->team);
$this->SearchIndexer()->Index($adapter->GetSearchableItem());
$this->SearchIndexer()->CommitChanges();
$team_manager->SearchUpdated($this->team->GetId());
}
unset($team_manager);
$this->is_one_time_team = $this->team->GetTeamType() == Team::ONCE;
# get matches and match stats
if (!$this->is_one_time_team) {
$a_season_dates = Season::SeasonDates();
$this->season_key = date('Y', $a_season_dates[0]);
if ($this->season_key != date('Y', $a_season_dates[1])) {
$this->season_key .= "/" . date('y', $a_season_dates[1]);
}
$match_manager->FilterByDateStart($a_season_dates[0]);
}
$match_manager->FilterByTeam(array($this->team->GetId()));
$match_manager->ReadMatchSummaries();
$this->a_matches = $match_manager->GetItems();
unset($match_manager);
$club = $this->team->GetClub();
$this->has_facebook_group_url = ($club->GetFacebookUrl() and strpos($club->GetFacebookUrl(), '/groups/') !== false);
$this->has_facebook_page_url = ($club->GetFacebookUrl() and !$this->has_facebook_group_url);
if (!$this->has_facebook_page_url) {
require_once 'stoolball/statistics/statistics-manager.class.php';
$statistics_manager = new StatisticsManager($this->GetSettings(), $this->GetDataConnection());
$statistics_manager->FilterByTeam(array($this->team->GetId()));
$statistics_manager->FilterMaxResults(1);
$this->best_batting = $statistics_manager->ReadBestBattingPerformance();
$this->best_bowling = $statistics_manager->ReadBestBowlingPerformance();
$this->most_runs = $statistics_manager->ReadBestPlayerAggregate("runs_scored");
$this->most_wickets = $statistics_manager->ReadBestPlayerAggregate("wickets");
$this->most_catches = $statistics_manager->ReadBestPlayerAggregate("catches");
# See what stats we've got available
$best_batting_count = count($this->best_batting);
$best_bowling_count = count($this->best_bowling);
$best_batters = count($this->most_runs);
$best_bowlers = count($this->most_wickets);
$best_catchers = count($this->most_catches);
$this->has_player_stats = ($best_batting_count or $best_batters or $best_bowling_count or $best_bowlers or $best_catchers);
if (!$this->has_player_stats) {
$player_of_match = $statistics_manager->ReadBestPlayerAggregate("player_of_match");
$this->has_player_stats = (bool) count($player_of_match);
}
unset($statistics_manager);
}
# Get whether to show add league/cup links
$season_manager = new SeasonManager($this->GetSettings(), $this->GetDataConnection());
$season_manager->ReadCurrentSeasonsByTeamId(array($this->team->GetId()), array(MatchType::CUP, MatchType::LEAGUE));
$this->seasons = $season_manager->GetItems();
unset($season_manager);
}
/**
* Reads the seasons which have player statistics fitting the current filters
*/
public function ReadSeasonsWithPlayerStatistics()
{
require_once "stoolball/season.class.php";
# First, prepare all the filters that must apply to each query
$players = $this->GetSettings()->GetTable("Player");
$statistics = $this->GetSettings()->GetTable("PlayerMatch");
$sm = $this->GetSettings()->GetTable('SeasonMatch');
$seasons = $this->GetSettings()->GetTable("Season");
$from = $this->FromFilteredPlayerStatistics();
$where = "";
$where = $this->ApplyFilters($where);
if ($where) {
$where = "WHERE " . substr($where, 3, strlen($where) - 3);
}
# Create an array to collect the seasons
$has_statistics = array();
$mid_season = null;
$today = gmdate("U");
$three_months = 60 * 60 * 24 * 30 * 3;
$six_months = 60 * 60 * 24 * 30 * 6;
# First, get the oldest player record and work out which season it's in
$sql = "SELECT MIN(match_time) AS match_time {$from} {$where} ";
$result = $this->GetDataConnection()->query($sql);
$row = $result->fetch();
if ($row) {
$season_dates = Season::SeasonDates($row->match_time);
$season = new Season($this->GetSettings());
$season->SetStartYear(gmdate("Y", $season_dates[0]));
$season->SetEndYear(gmdate("Y", $season_dates[1]));
$has_statistics[] = $season;
$mid_season = $season_dates[0] + $three_months;
}
# If we found the oldest season, check each season up to the current day for
# statistics
do {
# Add six months to move to the next season
$mid_season += $six_months;
$season_dates = Season::SeasonDates($mid_season);
# Now see if there are any statistics for this season
$where_season = $where;
$where_season .= $where_season ? "AND " : "WHERE ";
$where_season .= "{$statistics}.match_time >= " . $season_dates[0] . " AND {$statistics}.match_time <= " . $season_dates[1] . " ";
$sql = "SELECT COUNT(match_time) AS total {$from} {$where_season} ;";
$result = $this->GetDataConnection()->query($sql);
$row = $result->fetch();
if ($row->total) {
$season = new Season($this->GetSettings());
$season->SetStartYear(gmdate("Y", $season_dates[0]));
$season->SetEndYear(gmdate("Y", $season_dates[1]));
$has_statistics[] = $season;
}
} while ($mid_season < $today);
return array_reverse($has_statistics);
}
private function CreateWicketsRow(Match $match, $wickets_taken)
{
$wickets_header = new XhtmlCell(true, "Wickets");
$wickets_header->SetColumnSpan(4);
$wickets = new XhtmlSelect("batWickets", null, $this->IsValidSubmit());
$wickets->SetBlankFirst(true);
$max_wickets = $match->GetMaximumPlayersPerTeam() - 2;
$season_dates = Season::SeasonDates($match->GetStartTime());
# working with GMT
if (Date::Year($season_dates[0]) != Date::Year($season_dates[1])) {
# outdoor needs maximum-2, but indoor needs maximum-1 cos last batter can play on.
# if there's any chance it's indoor use maximum-1
$max_wickets = $match->GetMaximumPlayersPerTeam() - 1;
}
for ($i = 0; $i <= $max_wickets; $i++) {
$wickets->AddControl(new XhtmlOption($i));
}
$wickets->AddControl(new XhtmlOption('all out', -1));
if ($this->IsValidSubmit() and !is_null($wickets_taken)) {
$wickets->SelectOption($wickets_taken);
}
$balls_column = new XhtmlCell(false, null);
$wickets_row = new XhtmlRow(array($wickets_header, $wickets, $balls_column));
$wickets_row->SetCssClass("totals");
return $wickets_row;
}
function OnLoadPageData()
{
/* @var $o_last_match Match */
/* @var $season Season */
/* @var $team Team */
# new data manager
$o_match_manager = new MatchManager($this->GetSettings(), $this->GetDataConnection());
# Collect season to add this match to, starting with the URL
# get season and teams (was at this stage because editor needed teams to build its
# posted data object, but that's no longer the case so probably could be later if needed)
if (isset($this->i_season_id)) {
$season_manager = new SeasonManager($this->GetSettings(), $this->GetDataConnection());
$season_manager->ReadById(array($this->i_season_id));
$this->season = $season_manager->GetFirst();
unset($season_manager);
$this->edit->Seasons()->Add($this->season);
# If there are at least 2 teams in the season, show only those teams, otherwise show all teams of the relevant player type
if (count($this->season->GetTeams()) > 1) {
$this->edit->SetTeams(array($this->season->GetTeams()));
} else {
require_once 'stoolball/team-manager.class.php';
$team_manager = new TeamManager($this->GetSettings(), $this->GetDataConnection());
$team_manager->FilterByPlayerType(array($this->season->GetCompetition()->GetPlayerType()));
$team_manager->ReadTeamSummaries();
$this->edit->SetTeams(array($team_manager->GetItems()));
unset($team_manager);
}
}
# Not elseif, because when you've added a match there's a season, but we still need this to run to populate
# the choices for the next match to be added
if ($this->team instanceof Team) {
# Otherwise it should be a team.
# Get more information about the team itself
require_once 'stoolball/team-manager.class.php';
$team_manager = new TeamManager($this->GetSettings(), $this->GetDataConnection());
$team_manager->ReadById(array($this->team->GetId()));
$this->team = $team_manager->GetFirst();
if (!is_null($this->team)) {
$this->edit->SetContextTeam($this->team);
$season_ids = array();
$team_groups = array();
$a_exclude_team_ids = array();
$team_manager->FilterByActive(true);
# Add the home team first
$team_groups[] = array($this->team);
$a_exclude_team_ids[] = $this->team->GetId();
# Get the seasons this team is in...
$season_manager = new SeasonManager($this->GetSettings(), $this->GetDataConnection());
if ($this->i_match_type == MatchType::FRIENDLY) {
# For a friendly, any group of teams they play with is fine
$season_manager->ReadCurrentSeasonsByTeamId(array($this->team->GetId()));
} else {
# For anything else, get the seasons *for this type of match*
$season_manager->ReadCurrentSeasonsByTeamId(array($this->team->GetId()), array($this->i_match_type));
}
$seasons = $season_manager->GetItems();
unset($season_manager);
$this->edit->Seasons()->Clear();
# on postback, the season just added is already there, so clear to prevent a duplicate
foreach ($seasons as $season) {
$this->edit->Seasons()->Add($season);
$season_ids[] = $season->GetId();
}
#... and their opponent teams in those seasons
if (count($season_ids)) {
$team_manager->FilterExceptTeams($a_exclude_team_ids);
$team_manager->ReadBySeasonId($season_ids);
$season_teams = $team_manager->GetItems();
if (count($season_teams)) {
$team_groups['This season\'s teams'] = $season_teams;
}
foreach ($season_teams as $team) {
$a_exclude_team_ids[] = $team->GetId();
}
}
# ...and if this is a friendly it could be any other team
if ($this->i_match_type == MatchType::FRIENDLY) {
# get any other teams they played in the last 2 years, and combine with existing results
$team_manager->FilterExceptTeams($a_exclude_team_ids);
$team_manager->ReadRecentOpponents(array($this->team->GetId()), 24);
$recent_opponents = $team_manager->GetItems();
if (count($recent_opponents)) {
$team_groups['Recent opponents'] = $recent_opponents;
}
foreach ($recent_opponents as $team) {
$a_exclude_team_ids[] = $team->GetId();
}
# get any other teams they might play, and combine with existing results
$team_manager->FilterExceptTeams($a_exclude_team_ids);
$team_manager->ReadAll();
$team_groups['Other teams'] = $team_manager->GetItems();
}
# What if there are still no opponents to choose from? In that case select all teams.
if (count($team_groups) == 1) {
$team_manager->FilterExceptTeams($a_exclude_team_ids);
$team_manager->ReadAll();
$team_groups[] = $team_manager->GetItems();
}
# Offer those teams to select from
if ($total_groups = count($team_groups)) {
# If only two groups (home team + 1 group), don't group teams. Remove the only key from the array.
if ($total_groups == 2) {
$keys = array_keys($team_groups);
$team_groups = array($team_groups[$keys[0]], $team_groups[$keys[1]]);
}
$this->edit->SetTeams($team_groups);
}
}
unset($team_manager);
}
# Save match
if ($this->IsPostback() and $this->IsValid()) {
# Get posted match
$this->match = $this->edit->GetDataObject();
if (!$this->IsRefresh()) {
# Save match
$o_match_manager->SaveFixture($this->match);
$o_match_manager->SaveSeasons($this->match, true);
$o_match_manager->NotifyMatchModerator($this->match->GetId());
# Update 'next 5 matches'
$o_match_manager->ReadNext();
$this->a_next_matches = $o_match_manager->GetItems();
}
# Reset control for new match
$this->edit->SetDataObject(new Match($this->GetSettings()));
}
$o_match_manager->FilterByMatchType(array($this->i_match_type));
if (isset($this->i_season_id)) {
# If we're adding a match to a season, get last game in season for its date
$o_match_manager->ReadLastInSeason($this->season->GetId());
} else {
if ($this->team instanceof Team) {
# Get the last game already scheduled for the team to use its date
$o_match_manager->ReadLastForTeam($this->team->GetId());
}
}
$o_last_match = $o_match_manager->GetFirst();
if (is_object($o_last_match)) {
$current_season = Season::SeasonDates();
if (gmdate('Y', $o_last_match->GetStartTime()) < gmdate('Y', $current_season[0])) {
# If the last match this team played was last season, use the time but not the date
$this->edit->SetDefaultTime(gmmktime(gmdate('H', $o_last_match->GetStartTime()), gmdate('i', $o_last_match->GetStartTime()), 0, gmdate('m'), gmdate('d'), gmdate('Y')));
} else {
# If the last match was this season and has a time, use it
if ($o_last_match->GetIsStartTimeKnown()) {
$this->edit->SetDefaultTime($o_last_match->GetStartTime());
} else {
# If the last match has no time, use 6.30pm BST
$this->edit->SetDefaultTime(gmmktime(17, 30, 0, gmdate('m', $o_last_match->GetStartTime()), gmdate('d', $o_last_match->GetStartTime()), gmdate('Y', $o_last_match->GetStartTime())));
}
}
}
unset($o_match_manager);
# Get grounds
$o_ground_manager = new GroundManager($this->GetSettings(), $this->GetDataConnection());
$o_ground_manager->ReadAll();
$a_grounds = $o_ground_manager->GetItems();
$this->edit->SetGrounds($a_grounds);
unset($o_ground_manager);
}
function OnLoadPageData()
{
/* @var $o_match Match */
/* @var $o_team Team */
# new data manager
$match_manager = new MatchManager($this->GetSettings(), $this->GetDataConnection());
# create repeater control, and save any posted data
$this->repeater = new DataEditRepeater($this, 'CreateEditControl');
$this->repeater->SetCssClass('matchResults');
$this->repeater->SetPersistedParameters(array('team', 'season', "tournament"));
$this->repeater->SetButtonText('Save all results');
$this->repeater->SetShowButtonsAtTop(true);
if ($this->IsPostback() and !$this->IsRefresh() and $this->IsValid()) {
require_once 'forums/topic-manager.class.php';
require_once 'forums/review-item.class.php';
require_once 'forums/subscription-manager.class.php';
$topic_manager = new TopicManager($this->GetSettings(), $this->GetDataConnection());
foreach ($this->repeater->GetDataObjects() as $o_current_match) {
/* @var $o_current_match Match */
$match_manager->SaveResult($o_current_match);
$match_manager->ExpandMatchUrl($o_current_match);
$match_manager->NotifyMatchModerator($o_current_match->GetId());
if (trim($o_current_match->GetNewComment())) {
$item_to_comment_on = new ReviewItem($this->GetSettings());
$item_to_comment_on->SetType(ContentType::STOOLBALL_MATCH);
$item_to_comment_on->SetId($o_current_match->GetId());
$item_to_comment_on->SetNavigateUrl("https://" . $this->GetSettings()->GetDomain() . $o_current_match->GetNavigateUrl());
$message = $topic_manager->SaveComment($item_to_comment_on, $o_current_match->GetNewComment());
# send subscription emails - new object each time to reset list of who's already recieved an email
$subs_manager = new SubscriptionManager($this->GetSettings(), $this->GetDataConnection());
$subs_manager->SendCommentsSubscriptions($item_to_comment_on, $message);
unset($subs_manager);
}
}
$this->b_saved = true;
}
# get matches
if (!is_null($this->i_team_id)) {
$a_season_times = Season::SeasonDates();
$match_manager->FilterByTeam(array($this->i_team_id));
$match_manager->FilterByDateStart($a_season_times[0]);
$match_manager->FilterByDateEnd($a_season_times[1]);
$match_manager->ReadMatchSummaries();
} else {
if (!is_null($this->i_season_id)) {
$match_manager->ReadBySeasonId(array($this->i_season_id), true);
} else {
if (!is_null($this->tournament_id)) {
$match_manager->FilterByTournament($this->tournament_id);
$this->a_matches = $match_manager->ReadMatchSummaries();
}
}
}
$this->a_matches = $match_manager->GetItems();
# Make sure we have some matches
if (count($this->a_matches)) {
# If it's matches for a team, get the team
if (!is_null($this->i_team_id)) {
# Should only need to look at the first match, because the team must be a
# part of that match in order for the match to be in this list
$o_match =& $this->a_matches[0];
$o_team = $o_match->GetHomeTeam();
if ($o_team instanceof Team and $o_team->GetId() == $this->i_team_id) {
$this->team = $o_team;
} else {
foreach ($o_match->GetAwayTeams() as $o_team) {
if ($o_team->GetId() == $this->i_team_id) {
$this->team = $o_team;
break;
}
}
}
if (!is_object($this->team)) {
$this->Redirect();
}
# Now that we have short URL data, if data has just been saved for team, redirect back to team
if ($this->b_saved) {
$this->Redirect($this->team->GetNavigateUrl());
}
} else {
if (!is_null($this->i_season_id)) {
# get details of the season
require_once 'stoolball/competition-manager.class.php';
$o_comp_manager = new CompetitionManager($this->GetSettings(), $this->GetDataConnection());
$o_comp_manager->ReadById(null, array($this->i_season_id));
$o_competition = $o_comp_manager->GetFirst();
unset($o_comp_manager);
if ($o_competition instanceof Competition) {
$this->season = $o_competition->GetWorkingSeason();
}
if (!$this->season instanceof Season) {
$this->Redirect();
}
# Now that we have short URL data, if data has just been saved for season, redirect back to season
if ($this->b_saved) {
$this->Redirect($this->season->GetNavigateUrl());
}
} else {
if (!is_null($this->tournament_id)) {
$match_manager->ReadByMatchId(array($this->tournament_id));
$this->tournament = $match_manager->GetFirst();
if (!is_null($this->tournament)) {
# If the tournament has just been saved, now we have its URL so redirect to the thanks page
if ($this->b_saved) {
$this->Redirect($this->tournament->GetNavigateUrl());
}
}
}
}
}
} else {
$this->Redirect();
}
unset($match_manager);
}
