public PageProfilUtilisateur()
{
InitializeComponent();
IsCurrentUser = true;
BindingContext = repo.User;
UtilisateurModel utilisateur = repo.User;
}
/// <summary>
/// Asynchrone. Méthode pour chargé les données de la liste.
/// </summary>
/// <param name="utilisateur">Paramètre optionnel. Utilisateur en consultation ou null.</param>
/// <returns></returns>
private async Task Load(UtilisateurModel utilisateur = null)
{
//Si utilisateur en consultation n'est pas renseigné, utilisateur de l'application.
if (utilisateur == null)
{
user = repo.User;
}
//Sinon, utilisateur en consultation.
else
{
user = utilisateur as UtilisateurModel;
}
//Liste chargé avec un appel api.
var listeACharger = await repo.RecupererGroupesUser(user.IdUtilisateur.ToString());
liste.ItemsSource = listeACharger;
repo.User.GroupesUtilisateur = listeACharger;
if (listeACharger == null)
{
await DisplayAlert("Information", "Aucune inscription à un groupe", "OK");
}
if (repo.MessageErreur != null)
{
await DisplayAlert("Problème", repo.MessageErreur, "OK");
}
}
private void ToolbarItem_Activated(object sender, EventArgs e)
{
var repo = App.Current.BindingContext as UtilisateurModel;
repo = new UtilisateurModel();
//Detail = new Connexion();
Navigation.PopModalAsync();
}
public TabbedPageUtilisateurAutre(UtilisateurModel user)
{
InitializeComponent();
BindingContext = user;
this.Children.Add(new PageProfilUtilisateur(user));
this.Children.Add(new PageGroupesDeLUtilisateur(user));
this.Children.Add(new PageEvenementsPerso(user));
}
internal ObservableCollection <GroupeModel> RecupererGroupesUtilisateur(UtilisateurModel user)
{
var listeARetourner = new ObservableCollection <GroupeModel>();
foreach (var idgroupe in user.GroupesUtilisateur)
{
var groupe = ListeFauxGroupes.FirstOrDefault(g => g.IdGroupe == idgroupe.IdGroupe);
listeARetourner.Add(groupe);
}
return(listeARetourner);
}
public PageProfilUtilisateur(UtilisateurModel user)
{
InitializeComponent();
IsCurrentUser = false;
if (string.IsNullOrWhiteSpace(user.AdresseUtilisateur))
{
user.AdresseUtilisateur = "N/C";
}
BindingContext = user;
UtilisateurModel utilisateur = user;
}
/// <summary>
///
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static UtilisateurProxy ConvertirUtilisateurModelEnProxy(UtilisateurModel model)
{
return(new UtilisateurProxy()
{
usr_city = model.AdresseUtilisateur,
//usr_driver = (model.Vehicule==true) ? 1 : 0,
usr_firstname = model.PrenomUtilisateur,
usr_lastname = model.NomUtilisateur,
usr_mail = model.EMailUtilisateur,
usr_password = model.MotDePasseUtilisateur,
usr_phonenumber = model.TelephoneUtilisateur
});
}
//#region Exemple pour utiliser les api
///*
// *
// * EXEMPLE POUR CONSOMMER UNE API
// *
// *
// *
// * //public async void MaMethodeBidon()
// * //{
// * // var url = "https://ceciestuneapibidon/recupdedonnes";
// * // var retourApi = await _client.GetStringAsync(url);
// * // var result = JsonConvert.DeserializeObject<ObjetDRresultat>(retourApi);
// *
// *
// * //}
// *
// *
// * SI c'est une liste
// * //public async void MaMethodeBidon()
// * //{
// * // var url = "https://ceciestuneapibidon/recupdedonnes";
// * // var retourApi = await _client.GetStringAsync(url);
// * // var result = JsonConvert.DeserializeObject<List<ObjetDRresultat>>(retourApi);
// *
// * var _result = new ObservableCollection<ObjetDResultat>(result);
// * //}
// *
// *
// */
///*
// *
// *EXEMPLE POUR ENVOYER DANS L'API
// *
// *
// *
// * public async void MaMethodePostBidon()
// * {
// * var url = "https://ceciestuneapibidon/recupdedonnes";
// * var ObjetAEnvoyer = **MON OBJET RECUPERE OU CREEE **
// *
// * var content = JsonConvert.SerilizeObject(ObjetAEnvoyer);
// * await _client.PostAsync(url, new StringContent(content));
// *
// * //ENREGISTRER L'OBJET DANS L'APPLI
// * }
// *
// *
// */
///*
// *
// *EXEMPLE POUR FAIRE UNE MAJ DE DONNEES DE LA BDD
// *
// *
// *
// * public async void MaMethodePostBidon()
// * {
// * var url = "https://ceciestuneapibidon/recupdedonnes";
// * var ObjetAMaj = **MON OBJET RECUPERE OU ACTUEL **
// *
// * var content = JsonConvert.SerilizeObject(ObjetAMaj);
// * await _client.PutAsync(url + "/" + ObjetAMaj.id, new StringContent(content));
// *
// * //METTRE A JOUR L'OBJET DANS L'APPLI
// * }
// *
// *
// */
///*
//*
//*EXEMPLE POUR FAIRE LA SUPPRESSION
//*
//*
//*
//* public async void MaMethodePostBidon()
//* {
//* var url = "https://ceciestuneapibidon/recupdedonnes";
//* var ObjetASupp = **MON OBJET RECUPERE OU ACTUEL **
//*
//* await _client.DeleteAsync(url + "/" + ObjetAMaj.id);
//*
//* //REMOVE L'OBJET DANS L'APPLI
//* }
//*
//*
//*/
//#endregion
//#region Méthodes pour récupérer les id
///// <summary>
///// Méthode pour lister les id des évènements.
///// </summary>
///// <returns></returns>
//public async Task<List<int>> ListerTousLesIdEvenement()
//{
// try
// {
// var Url = "http://mooguer.fr/SelectIdEvent.php";
// var json = await _client.GetStringAsync(Url);
// var resultatApi = JsonConvert.DeserializeObject<List<EvenementProxy>>(json);
// //ListeId = idUser;
// var idEvent = new List<int>();
// foreach (var evenement in resultatApi)
// {
// idEvent.Add(Convert.ToInt32(evenement.es_Id));
// }
// return idEvent;
// }
// catch (Exception)
// {
// MessageErreur = "Problème lors de la récupération des données.";
// return null;
// }
//}
///// <summary>
///// Méthode pour lister les id des groupes.
///// </summary>
///// <returns></returns>
//public async Task<ObservableCollection<int>> ListerTousLesIdGroupe()
//{
// try
// {
// var Url = "http://mooguer.fr/SelectIdGroupeSport.php";
// var json = await _client.GetStringAsync(Url);
// var resultatApi = JsonConvert.DeserializeObject<List<GroupeProxy>>(json);
// var listeIdGroupeSport = new ObservableCollection<int>();
// foreach (var id in resultatApi)
// {
// listeIdGroupeSport.Add(id.gs_Id);
// }
// return listeIdGroupeSport;
// }
// catch (Exception)
// {
// MessageErreur = "Problème lors de la récupération des données.";
// return null;
// }
//}
///// <summary>
///// Méthode pour lister les id des utilisateurs.
///// </summary>
///// <returns></returns>
//public async Task<ObservableCollection<int>> ListerTousLesIdUtilisateur()
//{
// try
// {
// var Url = "http://mooguer.fr/SelectIdUser.php";
// var json = await _client.GetStringAsync(Url);
// var resultatApi = JsonConvert.DeserializeObject<List<UtilisateurProxy>>(json);
// //ListeId = idUser;
// var idUsers = new ObservableCollection<int>();
// foreach (var user in resultatApi)
// {
// idUsers.Add(Convert.ToInt32(user.usr_Id));
// }
// return idUsers;
// }
// catch (Exception)
// {
// MessageErreur = "Problème lors de la récupération des données.";
// return null;
// }
//}
/////// <summary>
/////// Méthode pour récupérer les id des utilisateurs d'un groupe.
/////// </summary>
/////// <param name="groupe"></param>
/////// <returns></returns>
////public async Task<ObservableCollection<int>> ListerIdUtilisateursGroupe(GroupeModel groupe)
////{
//// throw new NotImplementedException();
////}
/////// <summary>
/////// Méthode pour récupérer les id des évènements d'un groupe.
/////// </summary>
/////// <param name="groupe"></param>
/////// <returns></returns>
////public async Task<ObservableCollection<int>> ListerIdEvenementGroupe(GroupeModel groupe)
////{
//// throw new NotImplementedException();
////}
///// <summary>
///// Méthode pour récupérer les id des groupes d'un utilisateur.
///// </summary>
///// <param name="user"></param>
///// <returns></returns>
//public async Task<ObservableCollection<ListeGroupeUtilisateurProxy>> ListerIdGroupesUtilisateur(UtilisateurModel user)
//{
// try
// {
// var Url = "http://mooguer.fr/SelectGroupeUser.php?";
// var json = await _client.GetStringAsync(Url + "id=" + user.IdUtilisateur);
// var resultatApi = JsonConvert.DeserializeObject<List<ListeGroupeUtilisateurProxy>>(json);
// //ListeId = idUser;
// var GroupeUser = new ObservableCollection<ListeGroupeUtilisateurProxy>();
// if (resultatApi.Count > 0)
// {
// foreach (var groupe in resultatApi)
// {
// GroupeUser.Add(groupe);
// }
// return GroupeUser;
// }
// else
// {
// MessageErreur = "Vous n'avez pas de groupe.";
// return null;
// }
// }
// catch (Exception)
// {
// MessageErreur = "Problème lors de la récupération des données.";
// return null;
// }
//}
///// <summary>
///// Méthode pour récupérer les id des évènements d'un utilisateur.
///// </summary>
///// <param name="user"></param>
///// <returns></returns>
//public async Task<ObservableCollection<int>> ListerIdEvenementUtilisateur(UtilisateurModel user)
//{
// throw new NotImplementedException();
//}
//#endregion
//#region Méthodes pour convertir les id en Objets
///// <summary>
///// Méthode pour récupérer les infos d'un user.
///// </summary>
///// <param name="id">Id du user</param>
///// <returns>Utilisateur model</returns>
//public async Task<UtilisateurModel> RecupererUniqueUtilisateur(int id)
//{
// UtilisateurProxy utilisateurEnBase = await RechercheUtilisateurParId(id);
// return Convertisseur.ConvertirUtilisateurProxyEnModel(utilisateurEnBase);
//}
///// <summary>
///// Méthode pour récupérer les infos du groupe.
///// </summary>
///// <param name="id">Id du groupe</param>
///// <returns></returns>
//public async Task<GroupeModel> RecupererUniqueGroupe(int id)
//{
// GroupeProxy groupeEnBase = await RechercheGroupeParId(id);
// return Convertisseur.ConvertirGroupeProxyEnModel(groupeEnBase);
//}
///// <summary>
///// Méthode pour récupérer les infos d'un évènement.
///// </summary>
///// <param name="id">Id de l'évènement</param>
///// <returns></returns>
//public async Task<EvenementsModel> RecupererUniqueEnvement(int id)
//{
// EvenementProxy evenementEnBase = await RechercheEvenementParId(id);
// return Convertisseur.ConvertirEvenementProxyEnModel(evenementEnBase);
//}
//#endregion
//#region Méthodes pour retourner des listes d'objets
///// <summary>
///// Méthode pour récupérer les groupes de l'utilisateur
///// </summary>
///// <param name="user">Utilisateur</param>
///// <returns>Liste en observablecollection de groupes models</returns>
//public async Task<ObservableCollection<GroupeModel>> RecupererGroupesUtilisateur(UtilisateurModel user)
//{
// try
// {
// var Url = "http://mooguer.fr/SelectGroupeUser.php?";
// var json = await _client.GetStringAsync(Url + "id=" + user.IdUtilisateur);
// var resultatApi = JsonConvert.DeserializeObject<List<ListeGroupeUtilisateurProxy>>(json);
// //ListeId = idUser;
// var GroupeUser = new ObservableCollection<GroupeModel>();
// if (resultatApi.Count > 0)
// {
// foreach (var idgroupe in resultatApi)
// {
// var groupe = RecupererUniqueGroupe(idgroupe.igs_gs_id);
// var model = Convertisseur.ConvertirGroupeProxyEnModel(groupe);
// model.UtilisateursDuGroupe = await RecupererUtilisateursGroupe(model);
// GroupeUser.Add(model);
// }
// return GroupeUser;
// }
// else
// {
// MessageErreur = "Vous n'avez pas de groupe.";
// return null;
// }
// }
// catch (Exception)
// {
// MessageErreur = "Problème lors de la récupération des données.";
// return null;
// }
//}
///// <summary>
///// Méthode pour récupérer tous les groupes à afficher (on ne gèrera pas la limitation pour le moment)
///// </summary>
///// <returns>Liste en observablecollection de groupemodel</returns>
//public async Task<ObservableCollection<GroupeModel>> RecupererTousLesGroupes()
//{
// // Instanciation de la liste à retourner.
// var listeARetourner = new ObservableCollection<GroupeModel>();
// //Récupération de tous les id.
// var listeId = await ListerTousLesIdGroupe();
// //Pour chacun des id de la liste, rechercher l'objet en base, et le reformater en Model.
// foreach (var id in listeId)
// {
// //Ajouter à la liste à retourner.
// listeARetourner.Add(await RecupererUniqueGroupe(id));
// }
// return listeARetourner;
//}
///// <summary>
///// Méthode pour récupérer tout les utilisateurs en base.
///// </summary>
///// <returns></returns>
//public ObservableCollection<UtilisateurModel> RecupererTousLesUtilisateurs()
//{
// throw new NotImplementedException();
//}
///// <summary>
///// Méthode pour récupérer tous les chauffeurs inscrits.
///// </summary>
///// <returns>Liste en observablecollection de chauffeurmodel.</returns>
//public ObservableCollection<ChauffeurModel> RecupererTousChauffeurs()
//{
// throw new NotImplementedException();
//}
///// <summary>
///// Méthode pour récupérer tous les évènements à afficher (on ne gèrera pas la limitation pour le moment).
///// </summary>
///// <returns>Liste en observablecollection d'evenementmodel.</returns>
//public ObservableCollection<EvenementsModel> RecupererTousLesEvents()
//{
// throw new NotImplementedException();
//}
///// <summary>
///// Méthode pour récupérer tous les évènements d'un utilisateur (on ne gèrera pas la limitation pour le moment).
///// </summary>
///// <param name="user">Utilisateur</param>
///// <returns>Liste en observablecollection d'evenementmodel. A ranger si possible du plus récent au plus ancien.</returns>
//public ObservableCollection<EvenementsModel> RecupererEvenementUtilisateur(UtilisateurModel user)
//{
// throw new NotImplementedException();
//}
///// <summary>
///// Méthode pour récupérer tous les évènements d'un groupe (on ne gèrera pas la limitation pour le moment).
///// </summary>
///// <param name="groupe">Groupe dont on veut récupérer les évènements.</param>
///// <returns>Liste en observablecollection d'evenementmodel. A ranger si possible du plus récent au plus ancien.</returns>
//public ObservableCollection<EvenementsModel> RecupererEvenementGroupe(GroupeModel groupe)
//{
// throw new NotImplementedException();
//}
///// <summary>
///// Méthode pour récupérer tous les utilisateurs d'un groupe.
///// </summary>
///// <param name="groupe">Groupe dont on veut récupérer les utilisateurs.</param>
///// <returns>Liste en observablecollection d'utilisateurmodel.</returns>
//public async Task<ObservableCollection<UtilisateurModel>> RecupererUtilisateursGroupe(GroupeModel groupe)
//{
// var result = new ObservableCollection<UtilisateurModel>();
// try
// {
// var Url = "A modifier";
// var json = await _client.GetStringAsync(Url + "id=" + groupe.IdGroupe);
// var resultatApi = JsonConvert.DeserializeObject<ObservableCollection<UtilisateurProxy>>(json);
// if (resultatApi.Count >0)
// {
// foreach (var user in resultatApi)
// {
// var model = Convertisseur.ConvertirUtilisateurProxyEnModel(user);
// //var model = new UtilisateurModel();
// result.Add(model);
// }
// }
// else
// {
// MessageErreur = "Aucun utilisateur";
// result.Add(new UtilisateurModel());
// }
// }
// catch (Exception)
// {
// MessageErreur = "Problème lors de la récupération des données Utilisateur.";
// result.Add(new UtilisateurModel());
// }
// return result;
//}
//#endregion
//#region Rechercher un objet par id
///// <summary>
///// Méthode pour rechercher un groupe via son id.
///// </summary>
///// <param name="id"></param>
///// <returns></returns>
//public async Task<GroupeProxy> RechercheGroupeParId(int id)
//{
// throw new NotImplementedException();
//}
///// <summary>
///// Méthode pour rechercher un évènement via son id
///// </summary>
///// <param name="id"></param>
///// <returns></returns>
//public async Task<EvenementProxy> RechercheEvenementParId(int id)
//{
// throw new NotImplementedException();
//}
///// <summary>
///// Méthode pour rechercher un utilisateur via son id.
///// </summary>
///// <param name="id"></param>
///// <returns></returns>
//public async Task<UtilisateurProxy> RechercheUtilisateurParId(int id)
//{
// try
// {
// var Url = "http://mooguer.fr/SelectUserUnique.php?";
// var json = await _client.GetStringAsync(Url + "id=" + id);
// var resultatApi = JsonConvert.DeserializeObject<List<UtilisateurProxy>>(json);
// var user = new UtilisateurProxy();
// user = resultatApi.First();
// return user;
// //if (resultatApi != null)
// //{
// // user = resultatApi;
// // return GroupeUser;
// //}
// //else
// //{
// // MessageErreur = "Vous n'avez pas de groupe.";
// // return null;
// //}
// }
// catch (Exception)
// {
// MessageErreur = "Problème lors de la récupération des données.";
// return null;
// }
//}
//#endregion
//#region Méthodes de création
////public async void CreationGroupe()
////{
////}
////public async void CreationEvenement()
////{
////}
//#endregion
#endregion
/// <summary>
/// Méthode pour connecter l'utilisateur et faire démarrer l'application.
/// </summary>
/// <param name="email">Email renseigné dans la page de connexion.</param>
/// <param name="motDePasse">Mot de passe renseigner dans la page de connexion.</param>
/// <returns>Tache asynchrone récupérant un Utilisateur Model, qui représente l'utlisateur de l'application.</returns>
public async Task <UtilisateurModel> ConnexionApplication(string email, string motDePasse)
{
try
{
var _utilisateur = new UtilisateurModel();
string UrlControle = "http://mooguer.fr/VerifUserUnique.php?";
var controle = await _client.GetStringAsync(UrlControle + "mail=" + '"' + email + '"');
var user = JsonConvert.DeserializeObject <ObservableCollection <UtilisateurModel> >(controle);
if (user.Count > 0)
{
_utilisateur = user.FirstOrDefault();
}
if (_utilisateur != null)
{
if (motDePasse == _utilisateur.MotDePasseUtilisateur)
{
this.User.NomUtilisateur = _utilisateur.NomUtilisateur;
this.User.PrenomUtilisateur = _utilisateur.PrenomUtilisateur;
this.User.EMailUtilisateur = _utilisateur.EMailUtilisateur;
this.User.TelephoneUtilisateur = _utilisateur.TelephoneUtilisateur;
this.User.AdresseUtilisateur = _utilisateur.AdresseUtilisateur;
this.User.Vehicule = _utilisateur.Vehicule;
this.User.IdUtilisateur = _utilisateur.IdUtilisateur;
MessageErreur = null;
return(this.User);
}
else
{
MessageErreur = "Le mot de passe est incorrect.";
return(null);
}
}
else
{
MessageErreur = "L'email est incorrect.";
return(null);
}
}
catch (Exception)
{
MessageErreur = "Problème lors de la récupération des données.";
return(null);
}
}
public async Task Load(GroupeModel groupe, UtilisateurModel utilisateur)
{
var LeGroupe = BindingContext as GroupeModel;
LeGroupe.UtilisateurGroupe = await repo.RecupererUtilisateursDunGroupe(LeGroupe.IdGroupe);
//groupe.UtilisateurGroupe = await repo.RecupererUtilisateursDunGroupe(groupe.IdGroupe);
if (repo.MessageErreur != null)
{
await DisplayAlert("Participants", repo.MessageErreur, "OK");
}
listeUtilisateurGroupe.ItemsSource = LeGroupe.UtilisateurGroupe;
if (!groupe.UtilisateurGroupe.Any())
{
BoutonInscription.IsVisible = true;
BoutonDesinscription.IsVisible = false;
}
else
{
foreach (var user in groupe.UtilisateurGroupe)
{
if (user.IdUtilisateur == utilisateur.IdUtilisateur)
{
BoutonInscription.IsVisible = false;
BoutonDesinscription.IsVisible = true;
break;
}
else
{
BoutonInscription.IsVisible = true;
BoutonDesinscription.IsVisible = false;
}
}
}
if (groupe.ParticipantsActuelsGroupe == groupe.ParticipantsMaxGroupe)
{
BoutonInscription.IsVisible = false;
}
}
public async Task Load(EvenementsModel evenement, UtilisateurModel utilisateur)
{
var LEvenement = BindingContext as EvenementsModel;
LEvenement.Participants = await repo.RecupererUtilisateursDunEvenement(LEvenement.IdEvenement);
if (repo.MessageErreur != null)
{
await DisplayAlert("Participants", repo.MessageErreur, "OK");
}
listeUtilisateurEvenement.ItemsSource = LEvenement.Participants;
if (!evenement.Participants.Any())
{
BoutonInscription.IsVisible = true;
BoutonDesinscription.IsVisible = false;
}
else
{
foreach (var user in evenement.Participants)
{
if (user.IdUtilisateur == utilisateur.IdUtilisateur)
{
BoutonInscription.IsVisible = false;
BoutonDesinscription.IsVisible = true;
break;
}
else
{
BoutonInscription.IsVisible = true;
BoutonDesinscription.IsVisible = false;
}
}
}
if (evenement.NombreParticipants == evenement.NombreParticipantsMax)
{
BoutonInscription.IsVisible = false;
}
}
/// <summary>
/// Méthode pour modifier le profil de l'utilisateur en base.
/// </summary>
/// <param name="utilisateurModifie">Objet utilisateur modifié.</param>
/// <returns></returns>
public async Task ModifierProfilUtilisateur(UtilisateurModel utilisateurModifie)
{
try
{
//int drive = (Convert.ToBoolean(utilisateurModifie.Vehicule)) ? 1 : 0;
var UrlUpdate = "http://mooguer.fr/UpdateUser.php?";
string insert = UrlUpdate + "Id=" + utilisateurModifie.IdUtilisateur
+ "&Nom=" + '"' + utilisateurModifie.NomUtilisateur + '"'
+ "&Prenom=" + '"' + utilisateurModifie.PrenomUtilisateur + '"'
+ "&Tel=" + '"' + utilisateurModifie.TelephoneUtilisateur + '"'
+ "&Adresse=" + '"' + utilisateurModifie.AdresseUtilisateur + '"'
+ "&Vehi=" + utilisateurModifie.Vehicule
+ "&Nbplace=" + utilisateurModifie.NombrePlaceVoiture;
var json = await _client.GetStringAsync(insert);
//string retour = JsonConvert.DeserializeObject<string>(json);
MessageErreur = null;
}
catch (Exception)
{
MessageErreur = "Problème lors de la mise à jour des données.";
}
}
private async void Button_Inscription(object sender, EventArgs e)
{
ChampIncorrect = VerificationDesChamps();
if (ChampIncorrect)
{
await DisplayAlert("Attention", ChampsEnErreur, "OK");
}
else
{
UtilisateurModel nouvelUser = new UtilisateurModel()
{
EMailUtilisateur = EMailUtilisateur.Text.Trim(),
MotDePasseUtilisateur = MdpUser.Text.Trim(),
NomUtilisateur = NomUtilisateur.Text.Trim(),
PrenomUtilisateur = PrenomUtilisateur.Text.Trim(),
TelephoneUtilisateur = TelephoneUtilisateur.Text.Trim(),
Vehicule = Conducteur.IsToggled.ToString().Trim()
};
//UtilisateurProxy nouvelUser = new UtilisateurProxy
//{
// usr_lastname = NomUtilisateur.Text,
// usr_firstname = PrenomUtilisateur.Text,
// usr_mail = EMailUtilisateur.Text,
// usr_password = MdpUser.Text,
// usr_phonenumber = TelephoneUtilisateur.Text,
// usr_driver = Conducteur.IsToggled ? 1 : 0
//};
var controle = await _client.GetStringAsync(UrlControle + "mail=" + '"' + EMailUtilisateur.Text + '"');
var user = JsonConvert.DeserializeObject <ObservableCollection <UtilisateurModel> >(controle);
//_utilisateur = new ObservableCollection<UtilisateurModel>(user);
if (MdpUser.Text != MdpUser1.Text)
{
await DisplayAlert("Problème", "Mot de passe différent", "OK");
NomUtilisateur.Text = nouvelUser.NomUtilisateur;
PrenomUtilisateur.Text = nouvelUser.PrenomUtilisateur;
TelephoneUtilisateur.Text = nouvelUser.TelephoneUtilisateur;
EMailUtilisateur.Text = nouvelUser.EMailUtilisateur;
}
else
{
if (user.Count > 0)
{
await DisplayAlert("Problème", "Email déjà utilisé", "OK");
NomUtilisateur.Text = nouvelUser.NomUtilisateur;
PrenomUtilisateur.Text = nouvelUser.PrenomUtilisateur;
TelephoneUtilisateur.Text = nouvelUser.TelephoneUtilisateur;
}
else
{
try
{
int drive = (Convert.ToBoolean(nouvelUser.Vehicule)) ? 1 : 0;
string content = JsonConvert.SerializeObject(nouvelUser);
string insert = UrlInsert + "prenom=" + nouvelUser.PrenomUtilisateur
+ "&nom=" + nouvelUser.NomUtilisateur
+ "&mail=" + nouvelUser.EMailUtilisateur
+ "&mdp=" + nouvelUser.MotDePasseUtilisateur
+ "&NumeroTelephone=" + nouvelUser.TelephoneUtilisateur
+ "&Vehicule=" + drive;
var json = await _client.GetStringAsync(insert);
//string retour = JsonConvert.DeserializeObject<string>(json);
await DisplayAlert("Création d'un profil", string.Format("Le profil de {0} {1} a bien été crée", nouvelUser.PrenomUtilisateur, nouvelUser.NomUtilisateur), "OK");
await Navigation.PopAsync();
}
catch (Exception err)
{
Log.Warning("download", err.ToString());
await DisplayAlert("Problème", "Problème de connexion au serveur", "OK");
//throw;
}
}
#region Code commenté
//int age;
//var result = int.TryParse(AgeUser.Text, out age);
//if (result == false)
//{
// age = 0;
//}
//UtilisateurModel nouvelUtilisateur = new UtilisateurModel()
//{
// NomUtilisateur = NomUtilisateur.Text,
// PrenomUtilisateur = PrenomUtilisateur.Text,
// EMailUtilisateur = EMailUtilisateur.Text,
// TelephoneUtilisateur = TelephoneUtilisateur.Text,
// AgeUtilisateur = age,
// MotDePasseUtilisateur = MdpUser.Text,
// Vehicule = Conducteur.IsToggled
//};
//var repo = App.Current.BindingContext as FakeRepository;
//repo.UtilisateursEnregistres.Add(nouvelUtilisateur);
//repo.User = nouvelUtilisateur;
//A ne pas faire. Il ne faut pas utiliser PushAsync, mais PopAsync. Ici, c'était uniquement pour le test.
#endregion
}
}
}
public PageEvenementsPerso(UtilisateurModel user)
{
InitializeComponent();
_utilisateur = user;
}
public PageEvenementsPerso()
{
InitializeComponent();
_utilisateur = repo.User;
//Load();
}
/// <summary>
/// Constructeur de base. Appellé lors de la l'affichage pour les groupes de l'utilisateur actuel.
/// </summary>
public PageGroupesDeLUtilisateur()
{
InitializeComponent();
user = repo.User;
}
/// <summary>
/// Constructeur particulier. Appellé lors de l'affichage pour les groupes d'un utilisateur selectionné (pour simple consultation).
/// </summary>
/// <param name="utilisateur">Utilisateur selectionné en consultation.</param>
public PageGroupesDeLUtilisateur(UtilisateurModel utilisateur)
{
InitializeComponent();
user = utilisateur;
}
public FakeUtilisateurs()
{
var batman = new UtilisateurModel()
{
NomUtilisateur = "Wayne",
PrenomUtilisateur = "Bruce",
//AgeUtilisateur = 30,
EMailUtilisateur = @"*****@*****.**",
MotDePasseUtilisateur = "123bat",
//GroupesUtilisateur = new List<int> { 1, 4}
};
Utilisateurs.Add(batman);
var superman = new UtilisateurModel()
{
NomUtilisateur = "Kent",
PrenomUtilisateur = "Clark",
//AgeUtilisateur = 28,
EMailUtilisateur = @"*****@*****.**",
MotDePasseUtilisateur = "123sm",
//GroupesUtilisateur = new List<int> { 2 }
};
Utilisateurs.Add(superman);
var benj = new UtilisateurModel()
{
NomUtilisateur = "Rengard",
//AgeUtilisateur = 25,
PrenomUtilisateur = "Benjamin",
EMailUtilisateur = @"*****@*****.**",
MotDePasseUtilisateur = "123benj",
//GroupesUtilisateur = new List<int> { 1, 4 }
};
Utilisateurs.Add(benj);
var cive = new UtilisateurModel()
{
NomUtilisateur = "Cive",
//AgeUtilisateur = 25,
PrenomUtilisateur = "Jean",
EMailUtilisateur = @"*****@*****.**",
MotDePasseUtilisateur = "123cive",
//GroupesUtilisateur = new List<int> { 1, 2 }
};
Utilisateurs.Add(cive);
var jerome = new UtilisateurModel()
{
NomUtilisateur = "Laquay",
//AgeUtilisateur = 25,
PrenomUtilisateur = "Jérôme",
EMailUtilisateur = @"*****@*****.**",
MotDePasseUtilisateur = "123jer",
//GroupesUtilisateur = new List<int> { 3 }
};
Utilisateurs.Add(jerome);
var alex = new UtilisateurModel()
{
NomUtilisateur = "Moorels",
//AgeUtilisateur = 25,
PrenomUtilisateur = "Alexis",
EMailUtilisateur = @"*****@*****.**",
MotDePasseUtilisateur = "123alex",
//GroupesUtilisateur = new List<int> { 1 }
};
Utilisateurs.Add(alex);
var aurel = new UtilisateurModel()
{
NomUtilisateur = "Ducloy",
//AgeUtilisateur = 21,
PrenomUtilisateur = "Aurélien",
EMailUtilisateur = @"*****@*****.**",
MotDePasseUtilisateur = "123aurel",
//GroupesUtilisateur = new List<int> { 3 }
};
Utilisateurs.Add(aurel);
var thibaut = new UtilisateurModel()
{
NomUtilisateur = "Chauchoy",
//AgeUtilisateur = 20,
PrenomUtilisateur = "Thibaut",
EMailUtilisateur = @"*****@*****.**",
MotDePasseUtilisateur = "123thib",
//GroupesUtilisateur = new List<int> { 3, 4 }
};
Utilisateurs.Add(thibaut);
}
public ObservableCollection <EvenementsModel> RecupererEvenementUtilisateur(UtilisateurModel user)
{
return(ListeFauxEvent);
//throw new NotImplementedException();
}
