public void Create(Praticien praticien)
{
if (OpenConnection())
{
command = manager.CreateCommand();
command.CommandText = "INSERT INTO personne " +
"(nom, prenom, email, telephone, id_etablissement) " +
"VALUES (@nom, @prenom, @email, @telephone, @id_etablissement)";
command.Parameters.AddWithValue("@nom", praticien.Nom);
command.Parameters.AddWithValue("@prenom", praticien.Prenom);
command.Parameters.AddWithValue("@email", praticien.Email);
command.Parameters.AddWithValue("@telephone", praticien.Telephone);
command.Parameters.AddWithValue("@id_etablissement", praticien.Etablissement.Id);
command.ExecuteNonQuery();
command.CommandText = "INSERT INTO praticien " +
"(id_praticien, fonction, specialite, date_derniere_entrevue) " +
"VALUES (@id_praticien, @fonction, @specialite, @date_derniere_entrevue)";
command.Parameters.AddWithValue("@id_praticien", command.LastInsertedId);
command.Parameters.AddWithValue("@fonction", praticien.Fonction);
command.Parameters.AddWithValue("@specialite", praticien.Specialite);
command.Parameters.AddWithValue("@date_derniere_entrevue", praticien.Date_derniere_entrevue);
command.ExecuteNonQuery();
CloseConnection();
}
}
public ActionResult Save(Praticien praticien)
{
if (!ModelState.IsValid)
{
var viewModel = new NewPraticienViewModel
{
Praticien = praticien,
Fonctions = _context.Fonctions.ToList(),
Specialisations = _context.Specialisations.ToList()
};
return View("AjoutPraticien", viewModel);
}
if (praticien.Id == 0)
{
_context.Praticiens.Add(praticien);
}
else
{
var praticienInDb = _context.Praticiens.Include(a => a.Adresse).Single(p => p.Id == praticien.Id);
Mapper.Map(praticienInDb, praticien);
}
_context.SaveChanges();
return RedirectToAction("Index", "Praticiens");
}
public Praticien Read(int id)
{
Praticien praticien = new Praticien();
if (OpenConnection())
{
command = manager.CreateCommand();
command.CommandText = "SELECT * " +
"FROM personne INNER JOIN praticien " +
"ON praticien.id_praticien = personne.id_personne " +
"WHERE personne.id_personne = @id";
command.Parameters.AddWithValue("@id", id);
EtablissementDAO etablissementManager = new EtablissementDAO();
// Lecture des résultats
dataReader = command.ExecuteReader();
while (dataReader.Read())
{
praticien = new Praticien((string)dataReader["fonction"],
(string)dataReader["specialite"],
(DateTime)dataReader["date_derniere_entrevue"],
(int)dataReader["id_praticien"],
(string)dataReader["nom"],
(string)dataReader["prenom"],
(string)dataReader["email"],
(string)dataReader["telephone"],
etablissementManager.Read((int)dataReader["id_etablissement"]));
Debug.WriteLine(praticien);
}
dataReader.Close();
CloseConnection();
}
return(praticien);
}
public IActionResult DetailPraticien(int id)
{
ViewBag.BaseUrl = "http://localhost:65078/";
ViewBag.isRdv = _rdvService.IsRdv(id);
return(View(Praticien.GetPraticien(id)));
}
private void modifierPraticien()
{
if (tbxNom.Text == "" || tbxPrenom.Text == "" || tbxEmail.Text == "" || tbxRue.Text == "" || tbxTel.Text == "" || tbxVille.Text == "")
{
MessageBox.Show("Vous devez renseigner les champs Nom, Prenom, Rue, Ville, Telephone et Email !");
}
else
{
// récupération de la spécialité
Specialite uneSpecialite = (Specialite)cbxSpe.SelectedItem;
// récupération du type
TypePraticien unType = (TypePraticien)cbxType.SelectedItem;
// récupération de la ville (pour le code postal)
Ville uneVille = Globale.LesVilles.Find(x => x.Nom == tbxVille.Text);
if (Passerelle.modifierPraticien(lePraticien.Id, tbxNom.Text, tbxPrenom.Text, tbxRue.Text, uneVille.Code, uneVille.Nom, tbxTel.Text, tbxEmail.Text, unType.Id, uneSpecialite, out string message) == true)
{
MessageBox.Show("Praticien modifié");
// Mise a jour de l'interface
afficher();
lePraticien = (Praticien)cbxPraticien.SelectedItem;
remplirPraticien();
}
else
{
MessageBox.Show(message, "Erreur", MessageBoxButtons.OK, MessageBoxIcon.Error);
};
}
}
public ResultOfType <IList <CreneauResultDataModel> > PostNewCreneau(IList <CreneauDataModel> creneaux)
{
if (creneaux == null)
{
return(new Return <IList <CreneauResultDataModel> >().Error().As(EStatusDetail.BadRequest).AddingGenericError(
null, "Les données sont vides.").WithDefaultResult());
}
Logger.LogInfo(string.Format("Post New Creneau : Start --- "));
if (creneaux.Count() > 0)
{
IList <CreneauResultDataModel> data = new List <CreneauResultDataModel>();
foreach (CreneauDataModel creneauToAdd in creneaux)
{
var validationResult = ValidateNewCreneauProperties(creneauToAdd);
if (validationResult != null)
{
Logger.LogInfo(string.Format("Post New Creneau : End --- Status = {0}, Message= {1}",
validationResult.Status, validationResult.Errors[0].Message));
return(validationResult);
}
Praticien praticien = _praticienRepository.GetAll().FirstOrDefault(p => p.Email.Equals(creneauToAdd.PraticienEmail));
if (praticien == null)
{
return(new Return <IList <CreneauResultDataModel> >().Error().As(EStatusDetail.BadRequest).AddingGenericError(
null, "aucun praticien est lié à ce créneau !!!.").WithDefaultResult());
}
CreneauResultDataModel cre = new CreneauResultDataModel();
data.Add(cre);
var creneau = new Creneaux
{
HeureDebut = creneauToAdd.HeureDebut,
HeureFin = creneauToAdd.HeureFin,
Praticien = praticien,
Status = creneauToAdd.Status,
CurrentDate = creneauToAdd.CurrentDate,
Commentaire = creneauToAdd.Commentaire
};
_creneauxRepository.Add(creneau);
}
return
(new Return <IList <CreneauResultDataModel> >().OK()
.WithResult(data));
}
var cren = new List <CreneauResultDataModel>();
return
(new Return <IList <CreneauResultDataModel> >().OK()
.WithResult(cren));
}
private void cbxPraticien_SelectedIndexChanged(object sender, EventArgs e)
{
lePraticien = (Praticien)cbxPraticien.SelectedItem;
if (lePraticien != null)
{
remplirPraticien();
}
}
public Praticien Post([FromForm] Praticien praticien, [FromForm] IFormFile image)
{
praticien.Images.Add(new Image()
{
Url = _upload.Upload(image)
});
praticien.Save();
return(praticien);
}
public IActionResult Index(string search)
{
List <Praticien> praticiens = null;
if (search != null)
{
praticiens = Praticien.Search(search);
}
return(View(praticiens));
}
private void BTNDetails_Click(object sender, EventArgs e)
{
Praticien PraticienSelectionne;
int indiceSelectionne = CBXPraticien.SelectedIndex;
Praticien praticienSelectionne = praticiens[indiceSelectionne];
FPraticien praticienSelect = new FPraticien(praticienSelectionne);
praticienSelect.ShowDialog();
}
public bool RemoveFromRdv(int id)
{
List <Praticien> praticiens = GetRdv();
Praticien praticien = praticiens.Find(p => p.Id == id);
if (praticien != null)
{
praticiens.Remove(praticien);
_httpContext.Session.SetString("praticiens", JsonConvert.SerializeObject(praticiens));
}
return(false);
}
public bool AddRdv(int id)
{
Praticien p = Praticien.GetPraticien(id);
if (p != null)
{
List <Praticien> praticiens = GetRdv();
praticiens.Add(p);
_httpContext.Session.SetString("praticiens", JsonConvert.SerializeObject(praticiens));
return(true);
}
return(false);
}
//Construction d'une instance de rapportvisite à partir d'une ligne du résultat de la requête.
//Rappel : on souhaite que la couche "Présentation" ne soit pas liée à la base de données.
//Elle ne doit travailler qu'avec des objets métiers.
private static Praticien CreerPraticien(DataRow row)
{
Praticien praticien = new Praticien();
praticien.Num = row["PRA_NUM"].ToString();
praticien.Nom = row["PRA_NOM"].ToString();
praticien.Prenom = row["PRA_PRENOM"].ToString();
praticien.Adresse = row["PRA_ADRESSE"].ToString();
praticien.Cp = row["PRA_CP"].ToString();
praticien.Ville = row["PRA_VILLE"].ToString();
praticien.Coefnotoriete = row["PRA_COEFNOTORIETE"].ToString();
return(praticien);
}
public static PraticienResultDataModel ConvertPraticienEntityToDataModel(Praticien praticien)
{
if (praticien == null)
{
return(null);
}
else
{
string latLong = praticien.AdresseGoogle;
string lat = "36.813988";
string longi = "10.154027";
if (!string.IsNullOrEmpty(latLong))
{
var splits = latLong.Split(',');
if (splits.Count() == 2)
{
lat = splits[0];
}
longi = splits[1];
}
return(new PraticienResultDataModel
{
Adresse = praticien.Adresse,
Cin = praticien.Cin,
Conventionne = praticien.Conventionne.ToString(),
Cursus = praticien.Cursus,
Delegation = praticien.Delegation,
Diplomes = praticien.Diplomes,
Email = praticien.Email,
Fax = praticien.Fax,
Formations = praticien.Formations,
Gouvernerat = praticien.Gouvernerat,
InformationsPratique = praticien.InformationsPratique,
LanguesParles = praticien.LanguesParles,
MoyensPaiement = praticien.MoyensPaiement,
NomPrenom = praticien.NomPrenom,
ParcoursHospitalier = praticien.ParcoursHospitalier,
Password = CrossCuttingLayer.Encryption.RijndaelEncryption.Decrypt(praticien.Password),
PresentationCabinet = praticien.PresentationCabinet,
PrixConsultation = praticien.PrixConsultation,
Publication = praticien.Publication,
ReseauxSociaux = praticien.ReseauxSociaux,
Specialite = praticien.Specialite,
Telephone = praticien.Telephone,
AdresseGoogleLag = lat,
AdresseGoogleLong = longi
});
}
}
public Praticien Put(int id, [FromForm] IFormFile image)
{
Praticien praticien = Praticien.GetPraticien(id);
if (praticien != null)
{
praticien.Images.Add(new Image()
{
Url = _upload.Upload(image)
});
praticien.Update();
}
return(praticien);
}
public IActionResult SearchAjax(string search, bool ajax)
{
List <Praticien> praticiens = null;
if (search != null)
{
praticiens = Praticien.Search(search);
}
if (ajax)
{
return(PartialView(praticiens));
}
return(View(praticiens));
}
public static Praticien GetPraticienNomPrenom(string nom, string prenom)
{
Praticien praticien = null;
string selectPraticien = "SELECT PRA_NUM, PRA_NOM, PRA_PRENOM, PRA_ADRESSE, PRA_CP, PRA_VILLE, PRA_COEFNOTORIETE, TYP_CODE FROM PRATICIEN WHERE PRA_NOM='" + nom + "' AND PRA_PRENOM='" + prenom + "'";
DataTable dataTable = DBInterface.Select(selectPraticien);
if (dataTable.Rows.Count != 0)
{
DataRow row = dataTable.Rows[0];
praticien = CreerPraticien(row);
}
return(praticien);
}
public IActionResult SubmitFromPraticien(Praticien praticien, IFormFile[] images)
{
foreach (IFormFile image in Request.Form.Files)
{
praticien.Images.Add(new Image()
{
Url = _uploadSerice.Upload(image)
});
}
praticien.Save();
return(new JsonResult(new { error = false }));
// return RedirectToAction("Index");
}
public void Update(Praticien praticien)
{
if (OpenConnection())
{
command = manager.CreateCommand();
command.CommandText = "UPDATE personne " +
"SET fonction=@fonction, specialite=@specialite, date_dernier_entrevue=@dernier_entrevue " +
"WHERE praticien.id_praticien=@id";
command.Parameters.AddWithValue("@id", praticien.Id);
command.Parameters.AddWithValue("@fonction", praticien.Fonction);
command.Parameters.AddWithValue("@specialite", praticien.Specialite);
command.Parameters.AddWithValue("@derniere_entrevue", praticien.Date_derniere_entrevue);
command.ExecuteNonQuery();
CloseConnection();
}
}
public void AddPraticienToEtablissement(string specialite, string fonction, string nom, string prenom,
string telephone, string email, int id_etablissement)
{
PraticienDAO praticienManager = new PraticienDAO();
EtablissementDAO etablissementManager = new EtablissementDAO();
Praticien praticien = new Praticien();
praticien.Specialite = specialite;
praticien.Fonction = fonction;
praticien.Nom = nom;
praticien.Prenom = prenom;
praticien.Telephone = telephone;
praticien.Email = email;
praticien.Etablissement = etablissementManager.Read(id_etablissement);
praticienManager.Create(praticien);
}
public string Read(string table, int id)
{
string response = "";
if (table.Equals("rendez_vous"))
{
RendezVousDAO rendezVousManager = new RendezVousDAO();
RendezVous rendezVous = rendezVousManager.Read(id, false);
JavaScriptSerializer serializer = new JavaScriptSerializer();
response = serializer.Serialize(rendezVous);
}
else if (table.Equals("etablissement"))
{
PraticienDAO praticienManager = new PraticienDAO();
EtablissementDAO etablissementManager = new EtablissementDAO();
Etablissement etablissement = etablissementManager.Read(id);
Praticien praticien = new Praticien();
praticien.Etablissement = etablissement;
List <Praticien> PraticiensInEtablissement = new List <Praticien>();
PraticiensInEtablissement.Add(praticien);
PraticiensInEtablissement.AddRange(praticienManager.ReadAllPraticiensInEtablissement(id));
JavaScriptSerializer serializer = new JavaScriptSerializer();
response = serializer.Serialize(PraticiensInEtablissement);
}
else if (table.Equals("ligne_frais"))
{
LigneFraisDAO ligneFraisDAO = new LigneFraisDAO();
LigneFrais mesLigneFrais = ligneFraisDAO.Read(id, true);
//Debug.WriteLine("====================================" + mesLigneFrais.Frais);
JavaScriptSerializer serializer = new JavaScriptSerializer();
response = serializer.Serialize(mesLigneFrais);
//Debug.WriteLine("================================================" + response);
}
return(response);
}
// Afficher la visite sélectionnée dans le datagridview
private void afficher()
{
Praticien unPraticien = (Praticien)dgvPraticiens.SelectedRows[0].Cells[0].Value;
List <Visite> lesVisites = Globale.LeVisiteur.getLesVisites(unPraticien);
lblPraticien.Text = unPraticien.NomPrenom;
lblEmail.Text = unPraticien.Email;
lblRue.Text = unPraticien.Rue;
lblTelephone.Text = unPraticien.Telephone;
lblSpecialite.Text = unPraticien.Specialite is null ? null : unPraticien.Specialite.Libelle;
lblType.Text = unPraticien.Type.Libelle;
if (lesVisites.Count() == 0)
{
lblMotif.Text = "Pas de visite pour le moment";
lblBilan.Text = "Pas de visite pour le moment";
}
else
{
lblMotif.Text = lesVisites[0].LeMotif.Libelle;
lblBilan.Text = lesVisites[0].Bilan;
//vider la liste
lstMedicament.Items.Clear();
// alimentation des medicaments présentés
if (lesVisites[0].PremierMedicament != null)
{
lstMedicament.Items.Add(lesVisites[0].PremierMedicament.Nom);
if (lesVisites[0].SecondMedicament != null)
{
lstMedicament.Items.Add(lesVisites[0].SecondMedicament.Nom);
}
}
dgvEchantillons.Rows.Clear();
SortedDictionary <Medicament, int> lesEchantillons = lesVisites[0].getLesEchantillons();
foreach (Medicament unMedicament in lesVisites[0].getLesEchantillons().Keys)
{
dgvEchantillons.Rows.Add(unMedicament.Nom, lesEchantillons[unMedicament]);
}
}
}
public IList <string> PrintHolidays(int intYear, int intMonth, Praticien praticien, DayOfWeek dayOfWeek)
{
var lstSundays = new List <string>();
int intDaysThisMonth = DateTime.DaysInMonth(intYear, intMonth);
var conditionDateTime = new DateTime(intYear, intMonth, intDaysThisMonth);
for (var dt1 = new DateTime(intYear, intMonth, 1); dt1 <= conditionDateTime; dt1 = dt1.AddDays(1))
{
if (dt1.DayOfWeek == dayOfWeek)
{
string day = dt1.ToShortDateString();
lstSundays.Add(day);
}
}
return(lstSundays);
}
public async void ExecuteSearchPraticiensCommand()
{
try
{
Praticiens = new ObservableCollection <Praticien>();
Uri uri = new Uri("https://hugocabaret.onthewifi.com/GSB/APIGSB/requetes/GetPracticien.php?PRA_NOM=" + Recherche);
Console.WriteLine("{0} URI", uri);
HttpResponseMessage response = await _client.GetAsync(uri);
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Test 1");
var answer = await response.Content.ReadAsStringAsync();
Console.WriteLine("{0} Test 2", answer);
Console.WriteLine("Test 3");
dynamic dynJson = JsonConvert.DeserializeObject(answer);
Console.WriteLine("{0} Test 3", dynJson);
foreach (var praticien in dynJson)
{
Console.WriteLine("{0} JSON", praticien.PRA_NOM);
Praticien _praticien = new Praticien();
Console.WriteLine("{0} NOM", praticien.PRA_NOM);
_praticien.Nom = praticien.PRA_NOM;
_praticien.Prenom = praticien.PRA_PRENOM;
_praticien.Id = praticien.PRA_NUM;
Praticiens.Add(_praticien);
}
}
}catch (Exception e)
{
Console.WriteLine("Erreur, la recherche est vide");
}
}
public List <Praticien> ReadAllPraticiensInEtablissement(int id_etablissement)
{
List <Praticien> mesPraticiens = new List <Praticien>();
if (OpenConnection())
{
Praticien praticien;
EtablissementDAO etablissementManager = new EtablissementDAO();
command = manager.CreateCommand();
command.CommandText = "SELECT * " +
"FROM personne INNER JOIN praticien " +
"ON praticien.id_praticien = personne.id_personne " +
"WHERE id_etablissement = @id_etablissement";
command.Parameters.AddWithValue("@id_etablissement", id_etablissement);
// Lecture des résultats
dataReader = command.ExecuteReader();
while (dataReader.Read())
{
praticien = new Praticien();
praticien.Fonction = (string)dataReader["fonction"];
praticien.Specialite = (string)dataReader["specialite"];
praticien.Date_derniere_entrevue = (DateTime)dataReader["date_derniere_entrevue"];
praticien.Id = (int)dataReader["id_praticien"];
praticien.Nom = (string)dataReader["nom"];
praticien.Prenom = (string)dataReader["prenom"];
praticien.Email = (string)dataReader["email"];
praticien.Telephone = (string)dataReader["telephone"];
mesPraticiens.Add(praticien);
}
dataReader.Close();
CloseConnection();
}
return(mesPraticiens);
}
///<summary>
///Fournit la liste de tous les rapportvisites.
///</summary>
///<returns>
///Une collection (list) de rapportvisites
///</returns>
public static List <Praticien> GetPraticien()
{
//Collection de rapportvisite qui sera retournée à la couche présentation.
//Cette dernière ne doit travailler qu'avec des objets métiers.
List <Praticien> praticien = null;
//La requête à exécuter pour sélectionner tous les rapportvisites
string selectPraticien = "SELECT PRA_NUM, PRA_NOM, PRA_PRENOM, PRA_ADRESSE, PRA_CP, PRA_VILLE, PRA_COEFNOTORIETE FROM praticien";
//On appelle la couche persistance pour faire exécuter la requête. On exécute la méthode statique Select de la classe DBInterface
//Rappel : la méthode Select retourne un datatable
DataTable dataTable = DBInterface.Select(selectPraticien);
//Le Datatable retourné est transformé en collection de rapportvisite
if (dataTable != null)
{
praticien = new List <Praticien>();
foreach (DataRow row in dataTable.Rows)
{
Praticien praticiens = CreerPraticien(row);
praticien.Add(praticiens);
}
}
return(praticien);
}
public static PatientResultDataModel ConvertPratientEntityToDataModel(Praticien patient)
{
if (patient == null)
{
return(null);
}
var patientResultDataModel = new PatientResultDataModel();
if (!string.IsNullOrEmpty(patient.Adresse))
{
patientResultDataModel.Adresse = patient.Adresse;
}
if (!string.IsNullOrEmpty(patient.Cin))
{
patientResultDataModel.Cin = patient.Cin;
}
if (!string.IsNullOrEmpty(patient.NomPrenom))
{
patientResultDataModel.NomPrenom = patient.NomPrenom;
}
//if (!string.IsNullOrEmpty(patient.DateNaissance))
// patientResultDataModel.DateNaissance = patient.DateNaissance;
if (patient.Password != null)
{
patientResultDataModel.Password =
CrossCuttingLayer.Encryption.RijndaelEncryption.Decrypt(patient.Password);
}
if (!string.IsNullOrEmpty(patient.Telephone))
{
patientResultDataModel.Telephone = patient.Telephone;
}
//if (!string.IsNullOrEmpty(patient.Sexe))
// patientResultDataModel.Sexe = patient.Sexe;
patientResultDataModel.Email = patient.Email;
return(patientResultDataModel);
}
private void supprimerPraticien()
{
buttons = MessageBoxButtons.YesNo;
DialogResult result = MessageBox.Show("Êtes vous sûr de vouloir supprimer le praticien " + lePraticien.NomPrenom + " ?", "Suppression", buttons);
if (result == DialogResult.Yes)
{
if (Passerelle.supprimerPraticien(lePraticien.Id, out string message) == true)
{
MessageBox.Show("Praticien supprimé");
// Mise a jour de l'interface
Globale.LeVisiteur.supprimerPraticien(lePraticien);
afficher();
cbxPraticien.SelectedIndex = 0;
lePraticien = Globale.LeVisiteur.getLesPraticiens()[0];
remplirPraticien();
}
else
{
MessageBox.Show(message, "Erreur", MessageBoxButtons.OK, MessageBoxIcon.Error);
};
}
}
public IList <JourFerie> PrintHolidays(int intYear, int intMonth, Praticien praticien, DayOfWeek dayOfWeek)
{
var lstSundays = new List <JourFerie>();
int intDaysThisMonth = DateTime.DaysInMonth(intYear, intMonth);
var conditionDateTime = new DateTime(intYear, intMonth, intDaysThisMonth);
for (var dt1 = new DateTime(intYear, intMonth, 1); dt1 <= conditionDateTime; dt1 = dt1.AddDays(1))
{
if (dt1.DayOfWeek == dayOfWeek)
{
string day = dt1.ToShortDateString();
var jourferie = new JourFerie
{
Praticien = praticien,
JourFerieNom = day
};
//vérifier si ce jour existe déjà dans les jours fériés
var ferie =
_jourFerieRepository.GetAll()
.FirstOrDefault(
f =>
f.Praticien.Cin.Equals(praticien.Cin) &&
f.JourFerieNom.Equals(jourferie.JourFerieNom));
if (ferie == null)
{
_jourFerieRepository.Add(jourferie);
lstSundays.Add(jourferie);
}
}
}
return(lstSundays);
}
public ResultOfType <Null> PostCreneauxJour(string from, string to, string cinPraticien, string jour)
{
try
{
if (string.IsNullOrEmpty(from))
{
return(new Return <Null>().Error().As(EStatusDetail.BadRequest).AddingGenericError(
null, "heure de début null.").WithDefaultResult());
}
if (string.IsNullOrEmpty(to))
{
return(new Return <Null>().Error().As(EStatusDetail.BadRequest).AddingGenericError(
null, "heure de fin null.").WithDefaultResult());
}
if (string.IsNullOrEmpty(cinPraticien))
{
return(new Return <Null>().Error().As(EStatusDetail.BadRequest).AddingGenericError(
null, "Cin praticien vide.").WithDefaultResult());
}
if (string.IsNullOrEmpty(jour))
{
return(new Return <Null>().Error().As(EStatusDetail.BadRequest).AddingGenericError(
null, "jour.").WithDefaultResult());
}
Praticien praticien = _praticienRepository.GetAll().FirstOrDefault(p => p.Cin.Equals(cinPraticien));
if (praticien == null)
{
return(new Return <Null>().Error().As(EStatusDetail.BadRequest).AddingGenericError(
null, "praticien est null.").WithDefaultResult());
}
var dayOfWeek = new DayOfWeek();
switch (jour)
{
case "lundi":
dayOfWeek = DayOfWeek.Monday;
break;
case "mardi":
dayOfWeek = DayOfWeek.Tuesday;
break;
case "mercredi":
dayOfWeek = DayOfWeek.Wednesday;
break;
case "jeudi":
dayOfWeek = DayOfWeek.Thursday;
break;
case "vendredi":
dayOfWeek = DayOfWeek.Friday;
break;
case "samedi":
dayOfWeek = DayOfWeek.Saturday;
break;
case "dimanche":
dayOfWeek = DayOfWeek.Sunday;
break;
}
var lstSundays = new List <string>();
int intYear = DateTime.Now.Year;
int intMonth = DateTime.Now.Month;
for (int i = intMonth; i < 13; i++)
{
var list = PrintHolidays(intYear, i, praticien, dayOfWeek).ToList();
lstSundays.AddRange(list);
}
foreach (var lstSunday in lstSundays)
{
PostCreneaux(from, to, cinPraticien, lstSunday);
}
return
(new Return <Null>().OK().WithDefaultResult());
}
catch (Exception ex)
{
throw;
}
}
