public async Task InitTournament()
{
TournamentsServices tournamentsServices = new TournamentsServices();
try
{
SelectedTournament = await tournamentsServices.GetTournament(SelectedTournament.Id);
if (SelectedTournament.Matches == null || SelectedTournament.Matches.Count() <= 0)
{
SelectedTournament.Matches = new List <MatchsPhase>()
{
new MatchsPhase()
{
NumPhase = 1,
Matchs = new List <Match>()
}
};
}
SelectedPhase = MatchsPhases.Where(m => m.NumPhase == 1).DefaultIfEmpty(null).First();
MatchsPhases = new ObservableCollection <MatchsPhase>(SelectedTournament.Matches);
}
catch (Exception e)
{
SetGeneralErrorMessage(e);
}
}
private async void EnregistrerMatch()
{
TournamentsServices tournamentsServices = new TournamentsServices();
Match.Arbitre = SelectedArbitre;
Match.Emplacement = LieuMatch;
Match.Player1 = SelectedJoueur1;
Match.Player2 = SelectedJoueur2;
Match.Time = HeurePrevue;
if (Match.Id > 0)
{
bool isUpdate = await tournamentsServices.UpdateMatch(Tournament, Match, NumPhase.GetValueOrDefault());
}
else
{
try
{
bool response = await tournamentsServices.AddMatch(Tournament, Match, NumPhase.GetValueOrDefault());
if (response)
{
_navigationService.NavigateTo("Tournaments");
}
}
catch (Exception e)
{
SetGeneralErrorMessage(e);
}
}
}
public async void MessageReceiver(NotificationMessage message)
{
switch (message.VariableType)
{
case NotificationMessageType.Tournament:
SelectedTournament = (Tournament)message.Variable;
TournamentsServices tournamentsServices = new TournamentsServices();
try
{
SelectedTournament = await tournamentsServices.GetTournament(SelectedTournament.Id);
if (SelectedTournament.Matches == null || SelectedTournament.Matches.Count() <= 0)
{
SelectedTournament.Matches = new List <MatchsPhase>()
{
new MatchsPhase()
{
NumPhase = 1,
Matchs = new List <Match>()
}
};
}
SelectedPhase = MatchsPhases.Where(m => m.NumPhase == 1).First();
}
catch (Exception e)
{
SetGeneralErrorMessage(e);
}
break;
}
}
public async void AddTournament()
{
InitError();
Tournament tournament = OTournament;
tournament.Admins = null;
//tournament.Club = null;
TournamentsServices tournamentsServices = new TournamentsServices();
try
{
bool response = await tournamentsServices.AddTournamentAsync(tournament);
if (response)
{
MessengerInstance.Send(new NotificationMessage(NotificationMessageType.ListTournament));
_navigationService.NavigateTo("Tournaments");
}
}
catch (BadRequestException e)
{
foreach (Error error in e.Errors.ToList() as List <Error> )
{
SwitchError(error);
}
}
catch (Exception e)
{
SetGeneralErrorMessage(e);
}
}
public async void MessageReceiver(NotificationMessage message)
{
switch (message.VariableType)
{
case NotificationMessageType.Tournament:
SelectedTournament = (Tournament)message.Variable;
TournamentsServices tournamentsServices = new TournamentsServices();
var response = await tournamentsServices.GetTournament(SelectedTournament.Id);
if (response.Success)
{
SelectedTournament = (Tournament)response.Content;
if (SelectedTournament.Matches == null || SelectedTournament.Matches.Count() <= 0)
{
SelectedTournament.Matches = new List <MatchsPhase>()
{
new MatchsPhase()
{
NumPhase = 1,
Matchs = new List <Match>()
}
};
}
SelectedPhase = MatchsPhases.Where(m => m.NumPhase == 1).First();
}
break;
}
}
private async void DelPoint()
{
TournamentsServices tournamentsServices = new TournamentsServices();
Point point = new Point()
{
Joueur = EJoueurs.Joueur1
};
await tournamentsServices.DelPointMatch(Match.Id, point);
}
private async void SetTournaments()
{
var service = new TournamentsServices();
ResponseObject response = await service.GetTournaments();
if (response.Success)
{
var tournament = ((List <Object>)response.Content).Cast <Tournament>().ToList();
Tournaments = new ObservableCollection <Tournament>(tournament);
}
}
private async void RegisterTournamentAsync()
{
TournamentsServices tournamentsServices = new TournamentsServices();
try
{
await tournamentsServices.UpdateAsync(SelectedTournament);
}
catch (Exception e)
{
SetGeneralErrorMessage(e);
}
}
private async Task SetTournaments()
{
var service = new TournamentsServices();
try
{
List <Tournament> tournament = await service.GetTournaments();
Tournaments = new ObservableCollection <Tournament>(tournament);
}
catch (Exception e)
{
SetGeneralErrorMessage(e);
}
}
public async void ChargeVar()
{
UsersServices usersServices = new UsersServices();
TournamentsServices tournamentsServices = new TournamentsServices();
long idTounrnament = Tournament.Id;
var responseUser = await tournamentsServices.GetParticipants(idTounrnament);
var responseArbitre = await usersServices.GetUsersWithAccount();
bool allRequestSuccess = true;
if (responseUser.Success)
{
List <User> users = ((List <Object>)responseUser.Content).Cast <User>().ToList();
AllUsers = new ObservableCollection <User>(users);
}
else
{
allRequestSuccess = false;
}
if (responseArbitre.Success)
{
List <User> arbitres = ((List <object>)responseArbitre.Content).Cast <User>().ToList();
AllArbitre = new ObservableCollection <User>(arbitres);
}
else
{
allRequestSuccess = false;
}
if (allRequestSuccess)
{
//if(Match.Arbitre != null)
// SelectedArbitre = AllArbitre.Where(a => a.Id == Match.Arbitre.Id);
if (Match.Player1 != null)
{
SelectedJoueur1 = AllUsers.Where(u => u.Id == Match.Player1.Id).First();
}
if (Match.Player2 != null)
{
SelectedJoueur2 = AllUsers.Where(u => u.Id == Match.Player2.Id).First();
}
HeurePrevue = Match.Time;
LieuMatch = Match.Emplacement;
}
}
private async void DeleteMatchAsync(Match m)
{
TournamentsServices tournamentsServices = new TournamentsServices();
try
{
if (await tournamentsServices.DeletaMatchAsync(SelectedTournament.Id, m))
{
await InitTournament();
}
}
catch (Exception e)
{
SetGeneralErrorMessage(e);
}
}
private async void DelPoint()
{
TournamentsServices tournamentsServices = new TournamentsServices();
Point point = new Point()
{
Joueur = EJoueurs.Joueur1
};
try
{
await tournamentsServices.DelPointMatch(Match.Id, point);
}
catch (Exception e)
{
SetGeneralErrorMessage(e);
}
}
public async Task ChargeVar()
{
UsersServices usersServices = new UsersServices();
TournamentsServices tournamentsServices = new TournamentsServices();
long idTounrnament = Tournament.Id;
bool allRequestSuccess = true;
try
{
List <User> users = await tournamentsServices.GetParticipants(idTounrnament);
AllUsers = new ObservableCollection <User>(users);
List <User> arbitres = await usersServices.GetUsersWithAccount();
AllArbitre = new ObservableCollection <User>(arbitres);
}
catch (Exception e)
{
allRequestSuccess = false;
SetGeneralErrorMessage(e);
}
if (allRequestSuccess)
{
if (Match.Arbitre != null)
{
SelectedArbitre = AllArbitre.Where(a => a.Id == Match.Arbitre.Id).DefaultIfEmpty(null).First();
}
if (Match.Player1 != null)
{
SelectedJoueur1 = AllUsers.Where(u => u.Id == Match.Player1.Id).First();
}
if (Match.Player2 != null)
{
SelectedJoueur2 = AllUsers.Where(u => u.Id == Match.Player2.Id).First();
}
HeurePrevue = Match.Time;
LieuMatch = Match.Emplacement;
}
}
public async void AddTournament()
{
InitError();
Tournament tournament = OTournament;
tournament.Admins = null;
//tournament.Club = null;
TournamentsServices tournamentsServices = new TournamentsServices();
ResponseObject response = await tournamentsServices.AddTournamentAsync(tournament);
if (response.Success)
{
MessengerInstance.Send(new NotificationMessage(NotificationMessageType.ListTournament));
}
else
{
foreach (Error error in response.Content as List <Error> )
{
SwitchError(error);
}
}
}
private async void RegisterTournamentAsync()
{
TournamentsServices tournamentsServices = new TournamentsServices();
ResponseObject response = await tournamentsServices.UpdateAsync(SelectedTournament);
}
