/**
  * Create new TeamNameControl
  * @param Team $team
  * @param string $container_element
  */
 public function __construct(Team $team, $container_element)
 {
     parent::XhtmlElement($container_element);
     $name = $team->GetName();
     $type = is_null($team->GetPlayerType()) ? '' : PlayerType::Text($team->GetPlayerType());
     if ($type and strpos(strtolower(str_replace("'", '', $name)), strtolower(str_replace("'", '', $type))) !== false) {
         $type = "";
     }
     $town = (is_null($team->GetGround()) or is_null($team->GetGround()->GetAddress())) ? "" : $team->GetGround()->GetAddress()->GetTown();
     if ($town and strpos(strtolower($name), strtolower($town)) !== false) {
         $town = "";
     }
     if ($type or $town) {
         $html = '<span property="schema:name">' . htmlentities($name, ENT_QUOTES, "UTF-8", false) . '</span>';
         if ($town) {
             $html .= htmlentities(", {$town}", ENT_QUOTES, "UTF-8", false);
         }
         if ($type) {
             $html .= htmlentities(" ({$type})", ENT_QUOTES, "UTF-8", false);
         }
         $this->AddControl($html);
     } else {
         $this->AddAttribute("property", "schema:name");
         $this->AddControl(htmlentities($name, ENT_QUOTES, "UTF-8", false));
     }
 }
 public function __construct(Team $team)
 {
     $this->team = $team;
     $this->searchable = new SearchItem();
     $this->searchable->SearchItemId("team" . $team->GetId());
     $this->searchable->SearchItemType("team");
     $this->searchable->Url($team->GetNavigateUrl());
     $this->searchable->Title($team->GetNameAndType());
     $this->searchable->Description($this->GetSearchDescription());
     $this->searchable->WeightOfType(1000);
     $keywords = array($team->GetName(), $team->GetGround()->GetAddress()->GetLocality(), $team->GetGround()->GetAddress()->GetTown());
     $this->searchable->Keywords(implode(" ", $keywords));
     $content = array($team->GetGround()->GetAddress()->GetAdministrativeArea(), $team->GetIntro(), $team->GetPlayingTimes(), $team->GetCost(), $team->GetContact());
     $this->searchable->FullText(implode(" ", $content));
     $this->searchable->RelatedLinksHtml('<ul>' . '<li><a href="' . $team->GetStatsNavigateUrl() . '">Statistics</a></li>' . '<li><a href="' . $team->GetPlayersNavigateUrl() . '">Players</a></li>' . '<li><a href="' . $team->GetCalendarNavigateUrl() . '">Match calendar</a></li>' . '</ul>');
 }
 /**
  * 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 .= ' &#8211; 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 &raquo;');
     }
 }
 /**
  * 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);
 }
 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);
     }
 }
 /**
  * Populates the collection of business objects from raw data
  *
  * @return bool
  * @param MySqlRawData $o_result
  */
 protected function BuildItems(MySqlRawData $o_result)
 {
     /* @var $o_competition Competition */
     # use CollectionBuilder to handle duplicates
     $o_comp_builder = new CollectionBuilder();
     $o_season_builder = new CollectionBuilder();
     $o_team_builder = new CollectionBuilder();
     $o_points_builder = new CollectionBuilder();
     $o_matchtype_builder = new CollectionBuilder();
     $o_competition = null;
     $o_season = null;
     while ($o_row = $o_result->fetch()) {
         # check whether this is a new competition
         if (!$o_comp_builder->IsDone($o_row->competition_id)) {
             # store any exisiting competition and reset
             if ($o_competition != null) {
                 if ($o_season != null) {
                     $o_competition->AddSeason($o_season, true);
                 }
                 $o_season = null;
                 $o_matchtype_builder->Reset();
                 $this->Add($o_competition);
                 $o_season_builder->Reset();
             }
             # create the new competition
             $o_competition = new Competition($this->o_settings);
             $o_competition->SetId($o_row->competition_id);
             $o_competition->SetName($o_row->competition_name);
             if (isset($o_row->intro)) {
                 $o_competition->SetIntro($o_row->intro);
             }
             if (isset($o_row->contact)) {
                 $o_competition->SetContact($o_row->contact);
             }
             if (isset($o_row->notification_email)) {
                 $o_competition->SetNotificationEmail($o_row->notification_email);
             }
             if (isset($o_row->website)) {
                 $o_competition->SetWebsiteUrl($o_row->website);
             }
             if (isset($o_row->short_url)) {
                 $o_competition->SetShortUrl($o_row->short_url);
             }
             if (isset($o_row->active)) {
                 $o_competition->SetIsActive($o_row->active);
             }
             if (isset($o_row->players_per_team)) {
                 $o_competition->SetMaximumPlayersPerTeam($o_row->players_per_team);
             }
             if (isset($o_row->overs)) {
                 $o_competition->SetOvers($o_row->overs);
             }
             $o_competition->SetPlayerType($o_row->player_type_id);
             if (isset($o_row->update_search) and $o_row->update_search == 1) {
                 $o_competition->SetSearchUpdateRequired();
             }
             if (isset($o_row->category_id) && !is_null($o_row->category_id)) {
                 $cat = new Category();
                 $cat->SetId($o_row->category_id);
                 if (isset($o_row->category_name)) {
                     $cat->SetName($o_row->category_name);
                 }
                 if (isset($o_row->code)) {
                     $cat->SetUrl($o_row->code);
                 }
                 $o_competition->SetCategory($cat);
             }
         }
         # Seasons are the first cause of multiple rows (first in sort order after competition)
         if (isset($o_row->season_id)) {
             if (!$o_season_builder->IsDone($o_row->season_id)) {
                 if ($o_season != null) {
                     $o_competition->AddSeason($o_season, true);
                 }
                 $o_season = new Season($this->o_settings);
                 $o_season->SetId($o_row->season_id);
                 $o_season->SetName($o_row->season_name);
                 $o_season->SetIsLatest($o_row->is_latest);
                 $o_season->SetStartYear($o_row->start_year);
                 $o_season->SetEndYear($o_row->end_year);
                 if (isset($o_row->season_intro)) {
                     $o_season->SetIntro($o_row->season_intro);
                 }
                 if (isset($o_row->results)) {
                     $o_season->SetResults($o_row->results);
                 }
                 if (isset($o_row->show_table)) {
                     $o_season->SetShowTable($o_row->show_table);
                 }
                 if (isset($o_row->show_runs_scored)) {
                     $o_season->SetShowTableRunsScored($o_row->show_runs_scored);
                 }
                 if (isset($o_row->show_runs_conceded)) {
                     $o_season->SetShowTableRunsConceded($o_row->show_runs_conceded);
                 }
                 if (isset($o_row->season_short_url)) {
                     $o_season->SetShortUrl($o_row->season_short_url);
                 }
             }
             # Team only present if there is a season
             if (isset($o_row->team_id)) {
                 if (!$o_team_builder->IsDone($o_row->team_id)) {
                     if (isset($o_team)) {
                         unset($o_team);
                     }
                     $o_team = new Team($this->GetSettings());
                     $o_team->SetId($o_row->team_id);
                     $o_team->SetName($o_row->team_name);
                     $o_team->GetGround()->SetId($o_row->ground_id);
                     if (isset($o_row->team_short_url)) {
                         $o_team->SetShortUrl($o_row->team_short_url);
                     }
                     $o_season->AddTeam($o_team);
                     if (isset($o_row->withdrawn_league) and (bool) $o_row->withdrawn_league) {
                         $o_season->TeamsWithdrawnFromLeague()->Add($o_team);
                     }
                 }
                 # Points adjustments - should come with team and in order of team
                 if (isset($o_row->point_id) and !$o_points_builder->IsDone($o_row->point_id)) {
                     $o_point = new PointsAdjustment($o_row->point_id, $o_row->points, $o_team, $o_row->reason, $o_row->points_date);
                     $o_season->PointsAdjustments()->Add($o_point);
                 }
             }
             # Match types come with a season
             if (isset($o_row->match_type) and !$o_matchtype_builder->IsDone($o_row->match_type)) {
                 $o_season->MatchTypes()->Add((int) $o_row->match_type);
             }
         }
     }
     # store final competition
     if ($o_competition != null) {
         if ($o_season != null) {
             $o_competition->AddSeason($o_season, true);
         }
         $this->Add($o_competition);
     }
 }