public void TestPasserelleGeneral()
{
DateTime date = new DateTime(2017, 02, 02);
DateTime dateAttendu = new DateTime(2017, 02, 02);
BindingList <Medecin> listeDesMedecins = new BindingList <Medecin>();
BindingList <Cabinet> listeDesCabinets = new BindingList <Cabinet>();
BindingList <Visite> listeDesVisites = new BindingList <Visite>();
BindingList <Utilisateur> listeDesVisiteurs = new BindingList <Utilisateur>();
Utilisateur visiteur1 = new Utilisateur("alexis", "testeur", "atesteur", "atesteur", "42 rue victor hugo", "59000", "Lille", date, "2", "*****@*****.**", 5);
Utilisateur visiteur2 = new Utilisateur("louis", "dewavrin", "ldewavrin", "azert", "106 rue nova", "59000", "Lille", date, "2", "*****@*****.**", 8);
Utilisateur visiteur3 = new Utilisateur("admin", "admin", "admin", "admin", "106 rue victor hugo", "59000", "Lille", date, "2", "*****@*****.**", 2);
/*listeDesVisiteurs.Add(visiteur1);
* listeDesVisiteurs.Add(visiteur2);
* listeDesVisiteurs.Add(visiteur3); */
Cabinet cabinet1 = new Cabinet("101 rue nova", "59000", "Lille", 7859.6558, 87287.2782);
Cabinet cabinet2 = new Cabinet("101 rue de la liberté", "59000", "Lille", 4459.658, 87287.2782);
Cabinet cabinet3 = new Cabinet("82 rue nova", "59000", "Lille", 459.6558, 75287.2782);
listeDesCabinets.Add(cabinet1);
listeDesCabinets.Add(cabinet2);
listeDesCabinets.Add(cabinet3);
CollectionAssert.AreEqual(listeDesCabinets, listeDesCabinets);
Medecin medecin1 = new Medecin("paul", "coupé", cabinet1);
//Passerelle.Passerelle.
}
public IActionResult SubmitLoginMedecin(string inputCode14, string inputPassword4)
{
if (inputCode14 != null && inputPassword4 != null)
{
Medecin m = new Medecin();
m.Code_Medecin = inputCode14;
m.Mdp_Medecin = inputPassword4;
if (Medecin.CheckLogin(m.Code_Medecin, m.Mdp_Medecin, m))
{
HttpContext.Session.Clear();
HttpContext.Session.SetString("CodeMedecin", m.Code_Medecin);
return(RedirectToAction("MesInfos", "Medecin", m));
}
else
{
ViewBag.MessageError = "Identifiants incorrects";
return(View("LoginMedecin"));
}
}
else
{
ViewBag.MessageError = "Merci de remplir la totalité des champs";
return(View("LoginMedecin"));
}
}
public async Task <IActionResult> PutMedecin([FromRoute] string id, [FromBody] Medecin medecin)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != medecin.Id_Medecin)
{
return(BadRequest());
}
_context.Entry(medecin).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MedecinExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public static bool AjoutMedecin(Medecin m)
{
int i = 0;
//ajout d'un medecin dans la bdd
string request = "INSERT INTO Medecin (Code_Medecin,Nom_Medecin,Tel_Medecin,SpecialiteMedecin,Mdp_Medecin) VALUES (@Code,@Nom, @Tel,@Spec,@Mdp)";
command = new SqlCommand(request, Database.connection);
command.Parameters.Add(new SqlParameter("@Code", m.Code_Medecin));
command.Parameters.Add(new SqlParameter("@Nom", m.Nom_Medecin));
command.Parameters.Add(new SqlParameter("@Tel", m.Tel_Medecin));
command.Parameters.Add(new SqlParameter("@Spec", m.SpecialiteMedecin));
command.Parameters.Add(new SqlParameter("@Mdp", m.Mdp_Medecin));
Database.connection.Open();
i = command.ExecuteNonQuery();
command.Dispose();
Database.connection.Close();
if (i != 0)
{
return(true);
}
else
{
return(false);
}
}
public static bool ModifierMedecin(Medecin m)
{
int i = 0;
//modification d'un medecin de la bdd correspondant au médecin passé en paramètre
string request = "update Medecin set Nom_Medecin=@nom,tel_Medecin=@tel,SpecialiteMedecin=@spec,Mdp_Medecin=@mdp where (CodeMedecin=@code)";
command = new SqlCommand(request, Database.connection);
command.Parameters.Add(new SqlParameter("@code", m.Code_Medecin));
command.Parameters.Add(new SqlParameter("@nom", m.Nom_Medecin));
command.Parameters.Add(new SqlParameter("@tel", m.Tel_Medecin));
command.Parameters.Add(new SqlParameter("@spec", m.SpecialiteMedecin));
command.Parameters.Add(new SqlParameter("@mdp", m.Mdp_Medecin));
Database.connection.Open();
i = command.ExecuteNonQuery();
command.Dispose();
Database.connection.Close();
if (i != 0)
{
return(true);
}
else
{
return(false);
}
}
public IActionResult Update(int id, [FromBody] Medecin medecin)
{
if (medecin == null || medecin.Id != id)
{
return(BadRequest());
}
var med = _medecinRepository.Find(id);
if (med == null)
{
return(NotFound());
}
med.Id = medecin.Id;
med.Nom = medecin.Nom;
med.Prenom = medecin.Prenom;
med.Telephone = medecin.Telephone;
med.Email = medecin.Email;
med.Adresse = medecin.Adresse;
med.CodePostal = medecin.CodePostal;
med.HoraireVisite = medecin.HoraireVisite;
med.Latitude = medecin.Latitude;
med.Longitude = medecin.Longitude;
med.Ville = medecin.Ville;
med.ImgUrl = medecin.ImgUrl;
_medecinRepository.Update(med);
return(new NoContentResult());
}
public ActionResult Edit([Bind(Include = "idPers,nomPers,prenomPers,adressePers,dateNaissancePers,sexePers,cniPers,situationMatPers,emailPers,telPers,specialteMed")] MedcinViewModel medcinViewModel)
{
if (ModelState.IsValid)
{
//db.Entry(medcinViewModel).State = EntityState.Modified;
//db.SaveChanges();
Personne p = db.personnes.Find(medcinViewModel.idPers);
p.adressePers = medcinViewModel.adressePers;
p.cniPers = medcinViewModel.cniPers;
p.dateNaissancePers = medcinViewModel.dateNaissancePers;
p.emailPers = medcinViewModel.emailPers;
p.nomPers = medcinViewModel.nomPers;
p.prenomPers = medcinViewModel.prenomPers;
p.sexePers = medcinViewModel.sexePers;
p.situationMatPers = medcinViewModel.situationMatPers;
p.telPers = medcinViewModel.telPers;
// db.personnes.Add(p); //pas besoin de faire un add
db.SaveChanges();
Medecin m = db.medecins.Find(medcinViewModel.idPers);
m.specialteMed = medcinViewModel.specialteMed;
//m.personne = p;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(medcinViewModel));
}
public ActionResult Create([Bind(Include = "MedecinID,MedecinNom,MedecinPrenom,UserID,ServiceID")] Medecin medecin)
{
var client = new HttpClient();
client.BaseAddress = new Uri("http://localhost:61585/api");
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
if (ModelState.IsValid)
{
var response = client.PostAsJsonAsync(client.BaseAddress + "/Medecins/", medecin).Result;
if (response.IsSuccessStatusCode)
{
var data = response.Content.ReadAsStringAsync().Result;
var med = new Medecin();
Newtonsoft.Json.JsonConvert.PopulateObject(data.ToString(), med);
if (med == null)
{
return(HttpNotFound());
}
return(RedirectToAction("Index"));
}
else
{
return(HttpNotFound());
}
}
ViewBag.ServiceID = new SelectList(db.Services, "ServiceID", "ServiceNom", medecin.ServiceID);
ViewBag.UserID = new SelectList(db.userAccount, "UserID", "Email", medecin.UserID);
return(View(medecin));
}
private void SelectionRapport(object sender, SelectionChangedEventArgs e)
{
if (ListRapports.SelectedItem == null)
{
return;
}
ListViewMedics.Items.Clear();
int idRapport = (int)ListRapports.SelectedItem;
Rapport rapport = Manager.GetRapport(idRapport);
Visiteur visiteur = Passerelle.GetVisiteur(rapport.IdVisiteur);
Medecin medecin = Passerelle.GetMedecin(rapport.IdMedecin);
NomVisiteur.Text = visiteur.Nom;
PrenomVisiteur.Text = visiteur.Prenom;
MotifVisite.Text = rapport.Motif;
DateVisite.SelectedDate = rapport.Date;
BilanVisite.Text = rapport.Bilan;
NomMedecin.Text = medecin.Nom;
AdresseMedecin.Text = medecin.Adresse;
PrenomMedecin.Text = medecin.Prenom;
List <EchantillonOffert> lesEchantillonOffert = Manager.GetLesEchantillonsOfferts(rapport.Id);
foreach (EchantillonOffert eo in lesEchantillonOffert)
{
var tab1 = new { Medicament = eo.LeMedicament.NomCommercial, Quantite = eo.Quantite };
ListViewMedics.Items.Add(tab1);
}
}
public ActionResult Specialite(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Medecin medecin = db.Medecins.Find(id);
/*ServiceRepository serviceRepository = new ServiceRepository();
* Service service = serviceRepository.FindServiceByMedecinId(id);*/
SpecialiteRepository specialiteRepository = new SpecialiteRepository();
List <Specialite> specialites = new List <Specialite>();
specialiteRepository.FindSpecialiteByServiceId(medecin.ServiceId).ForEach(
sp => specialites.Add(new Specialite {
Id = sp.Id, Libelle = sp.Libelle
}));
ViewBag.specialite = new MultiSelectList(specialites, "Id", "Libelle");
//ViewBag.service = service.Libelle;
if (medecin == null)
{
return(HttpNotFound());
}
return(View(medecin));
}
// GET: Medecins/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var client = new HttpClient();
client.BaseAddress = new Uri("http://localhost:61585/api");
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var response = client.GetAsync(client.BaseAddress + "/Medecins/" + id).Result;
if (response.IsSuccessStatusCode)
{
var data = response.Content.ReadAsStringAsync().Result;
var med = new Medecin();
Newtonsoft.Json.JsonConvert.PopulateObject(data.ToString(), med);
if (med == null)
{
return(HttpNotFound());
}
return(View(med));
}
else
{
return(HttpNotFound());
}
}
/// <summary>
/// Permet de supprimer une visite de la base de données
/// Méthode utilisé seulement dans les tests pour éviter de se retrouver avec des médecins factice
/// </summary>
/// <param name="unMedecin">Un objet Medecin</param>
public static void supprimerMedecin(Medecin unMedecin)
{
try
{
// Ouverture de la connection
MySqlConnection maConnection = new MySqlConnection(connectionString);
maConnection.Open();
// Création de la requête
MySqlCommand maCommande = maConnection.CreateCommand();
// On se sert de l'objet passé en paramètre pour supprimer le bon champs
maCommande.CommandText = "DELETE FROM `medecin` WHERE `id` = @idMedecin;";
maCommande.Parameters.AddWithValue("@idMedecin", unMedecin.getIdMedecin());
// Exécution de la requête
maCommande.ExecuteNonQuery();
// Fermeture de la connection
maConnection.Close();
// On ve se synchroniser avec la base de données
PasserelleSuiviA.initListeCabinet();
PasserelleSuiviA.initListeActeur();
PasserelleSuiviA.initListeMedecin();
}
catch (Exception erreur)
{
// Permet la gestion des erreurs
throw erreur;
}
}
/// <summary>
/// Permet d'insérer un objet Medecin sans visiteur en base de données
/// </summary>
/// <param name="unMedecin">Un objet Medecin</param>
public static void ajoutMedecinSansVisiteur(Medecin unMedecin)
{
try
{
// Ouverture de la connection
MySqlConnection maConnection = new MySqlConnection(connectionString);
maConnection.Open();
// Création de la requête
MySqlCommand maCommande = maConnection.CreateCommand();
maCommande.CommandText = "INSERT INTO `medecin`(`nom`, `prenom`, `idCabinet`) VALUES (@nom, @prenom, @idCabinet);";
// On associe les attributs de l'objet passé en paramètre à ceux de la requête
maCommande.Parameters.AddWithValue("@nom", unMedecin.getNom());
maCommande.Parameters.AddWithValue("@prenom", unMedecin.getPrenom());
maCommande.Parameters.AddWithValue("@idCabinet", unMedecin.getLeCabinet().getIdCabinet());
// Exécution de la requête
maCommande.ExecuteNonQuery();
maCommande.Clone();
// On se synchronise avec la BDD
PasserelleSuiviA.initListeCabinet();
PasserelleSuiviA.initListeActeur();
PasserelleSuiviA.initListeMedecin();
}
catch (Exception erreur)
{
// Permet la gestion des erreurs
throw erreur;
}
}
private void txtRechercheSpeci_TextChanged(object sender, TextChangedEventArgs e)
{
try
{
TextBox t = (TextBox)sender;
string filter = t.Text;
ICollectionView cv = CollectionViewSource.GetDefaultView(MedecinsDataGrid.ItemsSource);
if (filter == "")
{
cv.Filter = null;
}
else
{
cv.Filter = o =>
{
Medecin p = o as Medecin;
if (t.Name == "txtId")
{
return(p.Id == Convert.ToInt32(filter));
}
return(p.SpécialitéMedecin.ToUpper().StartsWith(filter.ToUpper()));
};
}
}
catch (Exception ex)
{
MessageBoxResult resultc10 = Xceed.Wpf.Toolkit.MessageBox.Show(ex.Message, Medicus.Properties.Resources.SiteWeb, MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public IHttpActionResult PutMedecin(int id, Medecin medecin)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != medecin.MedecinID)
{
return(BadRequest());
}
db.Entry(medecin).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!MedecinExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public UtilisateurWeb Conversion(Medecin medecin)
{
if (medecin == null)
{
throw new CompteException("Une erreur est survenu sur le medecin");
}
return(new UtilisateurWeb()
{
IDWeb = medecin.IDMedecin,
Adresse = medecin.Adresse,
CreePar = medecin.CreePar,
DateCreation = medecin.DateCreation,
DernierModif = medecin.DernierModif,
Identifiant = medecin.Identifiant,
MotDePass = "",
Nom = medecin.Nom,
Prenom = medecin.Prenom,
AdresseMail = medecin.AdresseMail,
InfoComplementaire = medecin.InfoComplementaire,
HoraireOuverture = medecin.HoraireOuverture,
Telephone = medecin.Telephone,
Erreur = medecin.Erreur,
MesPatients = RetourListPatient(medecin.MesPatient),
Token = medecin.Token,
Type = true
});
}
public ActionResult CreateUser(FormCollection form)
{
var UserManager = new UserManager <Medecin, int>(new UserStore <Medecin, CustomRole, int, CustomUserLogin, CustomUserRole, CustomUserClaim>(context));
string UserName = form["txtEmail"];
string email = form["txtEmail"];
string pwd = form["txtPassword"];
var user = new Medecin();
user.UserName = UserName;
user.Email = email;
user.Password = pwd;
string pass = pwd;
var chkUser = UserManager.Create(user, pass);
if (chkUser.Succeeded)
{
var result1 = UserManager.AddToRole(user.Id, "medecin")
;
}
return(View());
///////////////////////////////////////////////////
}
public Medecin AttributionPatient(int IDpatient, int IDMedecin)
{
PatientDAO patientDAO = new PatientDAO();
MedecinDAO medecinDAO = new MedecinDAO();
if (!patientDAO.IsPatient(IDpatient))
{
throw new PatientIncorrecteException("Ce compte n'est pas un compte Patient", medecinDAO.VoirMedecin(IDMedecin));
}
if (!medecinDAO.IsMedecin(IDMedecin))
{
throw new MedecinIncorrecteException("Ce compte n'est pas un compte Medecin", medecinDAO.VoirMedecin(IDMedecin));
}
Medecin medecin = medecinDAO.VoirMedecin(IDMedecin);
Patient patient = patientDAO.VoirPatient(IDpatient);
if (patient.MesMedecin.SingleOrDefault(elt => elt.IDMedecin == IDMedecin) != null)
{
medecin.Erreur = "Le patient " + patient.Nom + " " + patient.Prenom + " " + patient.Identifiant + " vous est déjà attribué";
throw new DejaMedecinAttribueException("Il y a déjà un médecin attribué à ce Patient", medecin);
}
patientDAO.AttributionMedecin(patient, medecinDAO.VoirMedecinSimple(IDMedecin));
return(medecinDAO.VoirMedecin(IDMedecin));
}
public IActionResult Create([FromBody] DTOMedecin dtoMedecin)
{
if (dtoMedecin == null)
{
return(BadRequest());
}
Ville currentVille = _villeRepository.FindVilleByName(dtoMedecin.Ville.Nom);
Medecin medecin = new Medecin()
{
Nom = dtoMedecin.Nom,
Prenom = dtoMedecin.Prenom,
Adresse = dtoMedecin.Adresse,
HoraireVisite = dtoMedecin.HoraireVisite,
Email = dtoMedecin.Email,
Telephone = dtoMedecin.Telephone,
CodePostal = dtoMedecin.CodePostal,
ImgUrl = dtoMedecin.ImgUrl,
Latitude = dtoMedecin.Latitude,
Longitude = dtoMedecin.Longitude,
Ville = dtoMedecin.Ville
};
if (currentVille != null)
{
medecin.Ville = currentVille;
}
_medecinRepository.Add(medecin);
return(new CreatedAtRouteResult("GetMedecin", _medecinRepository.GetByName(medecin.Nom, medecin.Prenom)));
}
public Medecin SupprimerPatient(int IDpatient, int IDMedecin)
{
PatientDAO patientDAO = new PatientDAO();
MedecinDAO medecinDAO = new MedecinDAO();
if (!patientDAO.IsPatient(IDpatient))
{
throw new PatientIncorrecteException("Ce compte n'est pas un compte Patient", medecinDAO.VoirMedecin(IDMedecin));
}
if (!medecinDAO.IsMedecin(IDMedecin))
{
throw new MedecinIncorrecteException("Ce compte n'est pas un compte Medcin", medecinDAO.VoirMedecin(IDMedecin));
}
Medecin medecin = medecinDAO.VoirMedecin(IDMedecin);
Patient patient = patientDAO.VoirPatient(IDpatient);
if (patient.MesMedecin.SingleOrDefault(elt => elt.IDMedecin == IDMedecin) == null) //S'il n'y a pas de médecin pour patient
{
medecin.Erreur = "Le patient " + patient.Nom + " " + patient.Prenom + " " + patient.Identifiant + " vous est déjà attribué";
throw new PatientNonPresentException("Impossible de supprimer le patient du Médecin car attribution pas présente", medecin);
}
else
{
patientDAO.SupprMedecinDuPatient(patient, medecin);
}
return(medecinDAO.VoirMedecin(medecin.IDMedecin));
}
//Methodes pour Medecin
public static bool RechercherMedecin(string code, Medecin m)
{
//methode de classe permettant de chercher un medecin via un code choisi
//si on le trouve on modifie l'objet medecin passé en paramètre par référence
string request = "SELECT * FROM Medecin WHERE Code_Medecin=@Code";
command = new SqlCommand(request, Database.connection);
command.Parameters.Add(new SqlParameter("@Code", code));
Database.connection.Open();
SqlDataReader dataReader = command.ExecuteReader();
//on teste d'abord s'il a trouvé un enregistrement
if (dataReader.HasRows)
{
dataReader.Read();
m.Code_Medecin = code;
m.Nom_Medecin = (string)dataReader["NomMedecin"];
m.Tel_Medecin = (string)(dataReader["TelMedecin"]);
m.SpecialiteMedecin = (string)dataReader["SpecialiteMedecin"];
m.Mdp_Medecin = (string)dataReader["Mdp_Medecin"];
dataReader.Close();
Database.connection.Close();
return(true);
}
else
{
dataReader.Close();
Database.connection.Close();
return(false);
}
}
private void btnCreateMedecin_Click(object sender, EventArgs e)
{
String nom = Passerelle.Passerelle.checkValueIsCorrect(textBoxNomMedecin.Text.ToString());
String prenom = Passerelle.Passerelle.checkValueIsCorrect(textBoxPrenomMedecin.Text.ToString());
Utilisateur unUtilisateur = (Utilisateur)comboBoxMedecinVisiteur.SelectedItem;
Cabinet unCabinet = (Cabinet)comboBoxMedecinCabinet.SelectedItem;
Medecin unMedecin = new Medecin(nom, prenom, unCabinet, unUtilisateur);
if (nom != "" && prenom != "")
{
if (unUtilisateur != null)
{
if (unCabinet != null)
{
Passerelle.Passerelle.addMedecin(unMedecin);
textBoxNomMedecin.Text = "";
textBoxPrenomMedecin.Text = "";
comboBoxMedecinVisiteur.SelectedItem = "";
comboBoxMedecinCabinet.SelectedItem = "";
}
else
{
MessageBox.Show("Il faut sélectionner un cabinet");
}
}
else
{
MessageBox.Show("Il faut sélectionner un utilisateur");
}
}
else
{
MessageBox.Show("Les valeurs ne sont pas valides");
}
}
public static bool CheckLoginMedecin(string code, string mdp, Medecin m)
{
string request = "SELECT * FROM Medecin WHERE Code_Medecin=@code AND Mdp_Medecin=@mdp";
command = new SqlCommand(request, Database.connection);
command.Parameters.Add(new SqlParameter("@code", code));
command.Parameters.Add(new SqlParameter("@mdp", mdp));
Database.connection.Open();
SqlDataReader dataReader = command.ExecuteReader();
//on teste d'abord s'il a trouvé un enregistrement
if (dataReader.HasRows)
{
dataReader.Read();
m.Code_Medecin = code;
m.Nom_Medecin = (string)dataReader["Nom_Medecin"];
m.Tel_Medecin = (string)dataReader["Tel_Medecin"];
m.SpecialiteMedecin = (string)dataReader["SpecialiteMedecin"];
m.Mdp_Medecin = mdp;
dataReader.Close();
Database.connection.Close();
return(true);
}
else
{
dataReader.Close();
Database.connection.Close();
return(false);
}
}
public Medecin VoirMedecin(int IDMedecin)
{
AdresseDAO adresseDAO = new AdresseDAO();
HoraireDAO horaireDAO = new HoraireDAO();
using (DataClasses1DataContext entity = new DataClasses1DataContext())
{
var ret = entity.T_MEDECIN.Join(entity.T_COMPTE,
M => M.IdCompte,
C => C.ID,
(M, C) => new { IDMedecin = M.ID, ID = C.ID, Identifiant = C.Identifiant, MotDePass = "", Nom = C.Nom, Prenom = C.Prenom, Telephone = M.TelephoneCabinet, AdresseMail = C.AdressMail, InfoComplementaire = M.InfoComplementaire, DateCreation = C.DateCreation, DernierModif = C.DerniereModif, CreePar = 0, Token = C.Token }).FirstOrDefault(elm => elm.IDMedecin == IDMedecin);
if (ret == null)
{
throw new CompteException("pas de medecin");
}
Medecin medecin = new Medecin()
{
IDMedecin = (int)ret.IDMedecin, ID = (int)ret.ID, Identifiant = ret.Identifiant, MotDePass = ret.MotDePass, Nom = ret.Nom, Prenom = ret.Prenom, Telephone = ret.Telephone, AdresseMail = ret.AdresseMail, InfoComplementaire = ret.InfoComplementaire, DateCreation = ret.DateCreation, DernierModif = ret.DernierModif, CreePar = 0, Token = ret.Token
};
medecin.Adresse = adresseDAO.LectureAdresse(medecin.ID);
medecin.HoraireOuverture = horaireDAO.LectureHoraire(medecin.IDMedecin);
medecin.MesPatient = new PatientDAO().ListPatientDuMedecin(medecin.IDMedecin);
return(medecin);
}
}
public IActionResult SubmitFormMedecin(string inputCode14, string inputName, string inputTel, string inputSpec, string inputPassword4)
{
if (inputCode14 != null && inputName != null && inputTel != null && inputSpec != null && inputPassword4 != null)
{
Medecin m = new Medecin();
m.Code_Medecin = inputCode14;
m.Nom_Medecin = inputName;
m.Tel_Medecin = inputTel;
m.SpecialiteMedecin = inputSpec;
m.Mdp_Medecin = inputPassword4;
if (Medecin.Save(m))
{
return(RedirectToAction("LoginMedecin", "Medecin", new { message = "Medecin Ajouté" }));
}
else
{
ViewBag.MessageError = "Erreur d'insertion dans la base de données";
return(View("InscriptionMedecin"));
}
}
else
{
ViewBag.MessageError = "Merci de remplir la totalité des champs";
return(View("InscriptionMedecin"));
}
}
/// <summary>
/// retour une information vrais ou faux en fonction du login et du mot de passe envoyé
/// </summary>
/// <param name="Login"></param>
/// <param name="Pass"></param>
/// <returns></returns>
public Medecin Login(string Identifiant, string Pass)
{
int IdCompte = new CompteDAO().Autentification(Identifiant, Pass); //teste de l'identifiant et du mot de passe pour rejet si non présent dans la base
//Rafraichir();
Medecin retourMedecin = VoirMedecin(Identifiant);
//Medecin retourMedecin = _ListMedecin.SingleOrDefault(medecin => medecin.ID == IdCompte); //on récupère le médecin a partir de l'id du compte
//try { retourMedecin.Adresse = new AdresseDAO().LectureAdresse(retourMedecin.ID); }//lecture de l'adresse a partir de l'IdCompte
//catch (Exception) { retourMedecin.Adresse = null; }
//try { retourMedecin.HoraireOuverture = new HoraireDAO().LectureHoraire(retourMedecin.IDMedecin); } //on récupère la table des horaires en fonctiond de l'id du médecin
//catch (Exception) { retourMedecin.HoraireOuverture = null; }
//foreach (Medecin Element in _ListMedecin)
//{
// if (Element.Identifiant == Identifiant & Element.MotDePass == Pass)
// {
// Element.Adresse = new AdresseDAO().LectureAdresse(Element);
// return Element;
// }
//}
return(retourMedecin);
}
public ActionResult Create([Bind(Include = "idPers,nomPers,prenomPers,adressePers,dateNaissancePers,sexePers,cniPers,situationMatPers,emailPers,telPers,idMed,specialteMed")] MedecinViewModel medecinViewModel)
{
if (ModelState.IsValid)
{
//db.MedecinViewModels.Add(medecinViewModel);
Personne p = new Personne();
p.adressePers = medecinViewModel.adressePers;
p.cniPers = medecinViewModel.cniPers;
p.dateNaissancePers = medecinViewModel.dateNaissancePers;
p.emailPers = medecinViewModel.emailPers;
p.nomPers = medecinViewModel.nomPers;
p.prenomPers = medecinViewModel.prenomPers;
p.sexePers = medecinViewModel.sexePers;
p.situationMatPers = medecinViewModel.situationMatPers;
p.telPers = medecinViewModel.telPers;
db.personnes.Add(p);
Medecin m = new Medecin();
m.idMed = p.idPers;
m.specialteMed = medecinViewModel.specialteMed;
// m.personne = p;
db.medecins.Add(m);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(medecinViewModel));
}
/// <summary>
/// Modification des informations du Medecin
/// </summary>
/// <param name="IdMedecin"></param>
/// <param name="Age"></param>
/// <returns></returns>
public Medecin Modification(Medecin medecin)
{
using (DataClasses1DataContext entity = new DataClasses1DataContext())
{
//Medecin medecinbdd = _ListMedecin.Where(elt => elt.Identifiant == medecin.Identifiant).SingleOrDefault();
//Medecin medecinbdd = VoirMedecin(medecin.Identifiant);
int retour = entity.ModifMedecin(entity.T_MEDECIN.FirstOrDefault(elt => elt.ID == medecin.IDMedecin).IdCompte, medecin.Nom, medecin.Prenom, ConvertionDate.ConvertionDateTimeVersString(DateTime.UtcNow), medecin.AdresseMail, ServiceSecurite.GenererToken(medecin.Identifiant, new CompteDAO().GetMotDePass(medecin.Identifiant), DateTime.UtcNow.Ticks), (int)medecin.IDMedecin, medecin.Telephone, medecin.InfoComplementaire);
if (retour == -1)
{
throw new CompteModificationException(medecin, "La modification du medecin n'a pus avoir lieu");
}
Medecin RetourMedecin = this.VoirMedecin(retour);
RetourMedecin.Adresse = new AdresseDAO().AjoutAdresse(RetourMedecin.ID, medecin);
RetourMedecin.HoraireOuverture = new HoraireDAO().AjoutHoraire(retour, medecin.HoraireOuverture);
return(RetourMedecin);
//if (AdresseRetour == null) throw new CompteModificationException(medecin, "La modification du medecin n'a pus avoir lieu");
//if (HoraireRetour.Length == 0) throw new CompteModificationException(medecin, "La modification du medecin n'a pus avoir lieu");
//Rafraichir();
//RetourMedecin.HoraireOuverture = new HoraireDAO().AjoutHoraire(retour, medecin.HoraireOuverture);
//RetourMedecin.Adresse = new AdresseDAO().AjoutAdresse(RetourMedecin.ID, medecin);
//Rafraichir();
//return _ListMedecin.Where(Id => Id.IDMedecin == retour).First();
}
}
public async Task <IActionResult> PostMedecin([FromBody] Medecin medecin)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.medecins.Add(medecin);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (MedecinExists(medecin.Id_Medecin))
{
return(new StatusCodeResult(StatusCodes.Status409Conflict));
}
else
{
throw;
}
}
return(CreatedAtAction("GetMedecin", new { id = medecin.Id_Medecin }, medecin));
}
public List <ConsultLabel> Historique()
{
List <ConsultLabel> list = new List <ConsultLabel>();
IQueryable <Consultation> cnslt = (from cns in Globals.DataClass.Consultation
select cns);
foreach (Consultation p in cnslt)
{
IQueryable <MPConsultation> mpconslt = (from mpc in Globals.DataClass.MPConsultation
where mpc.IdConsultation == p.Id
select mpc);
if (mpconslt.Count() != 0)
{
MPConsultation mpcnslt = mpconslt.First <MPConsultation>();
Patient pat = (from patient in Globals.DataClass.Patient
where patient.Id == mpcnslt.IdPatient
select patient).First <Patient>();
Personne pers = (from personne in Globals.DataClass.Personne
where personne.Id == pat.IdPersonne
select personne).First <Personne>();
Medecin patmed = (from medecin in Globals.DataClass.Medecin
where medecin.Id == mpcnslt.IdMedecin
select medecin).First <Medecin>();
Personne persmed = (from personne in Globals.DataClass.Personne
where personne.Id == patmed.IdPersonne
select personne).First <Personne>();
ConsultLabel q = new ConsultLabel((DateTime)p.date, p.label, p.Id, pers.nom, pers.prenom, persmed.nom, persmed.prenom);
list.Add(q);
}
}
return(list);
}
