public void DissosToSite(Horaire horaire, Site site)
{
_dbal.Delete("site_horaire",
"site = " + site.Id + " AND " +
"horaire = " + horaire.Id
);
}
public async Task <ActionResult <Horaire> > PostHoraire(Horaire horaire)
{
_context.Horaires.Add(horaire);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetHoraire", new { id = horaire.Id }, horaire));
}
/// <summary>
/// Teste de similarité de la liste des horaires. Si elles sont identique on retour vrais
/// </summary>
/// <param name="IdMedecin"></param>
/// <param name="ListAjoutHoraires"></param>
/// <returns></returns>
private bool SiHoraireIdentique(int IdMedecin, Horaire[] ListAjoutHoraires)
{
Horaire[] HorairePresent = LectureHoraire(IdMedecin);
if (HorairePresent.Length == 7)
{
for (int i = 0; i < ListAjoutHoraires.Length; i++)
{
Horaire UnHorairePresent = HorairePresent[i];
Horaire UnHoraireAchanger = ListAjoutHoraires[i];
if (UnHorairePresent.Matin != UnHoraireAchanger.Matin)
{
return(false);
}
if (UnHorairePresent.Soir != UnHoraireAchanger.Soir)
{
return(false);
}
}
}
else
{
return(false);
}
return(true);
}
public async Task <BaseResponseDto <HoraireDto> > UpdateHoraire(Guid Id, Horaire horaire)
{
BaseResponseDto <HoraireDto> getResponse = new BaseResponseDto <HoraireDto>();
try
{
if (Id != null)
{
Horaire oldHoraire = await _horaireRepository.GetAsync(Id);
if (oldHoraire != null)
{
oldHoraire.MyUserId = horaire.MyUserId;
oldHoraire.DateDuJourHor = horaire.DateDuJourHor;
oldHoraire.HeureArriveHor = horaire.HeureArriveHor;
oldHoraire.HeureDepartHor = horaire.HeureDepartHor;
await _horaireRepository.UpdateAsync(oldHoraire);
}
}
else
{
return(null);
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
getResponse.Errors.Add(ex.Message);
}
return(getResponse);
}
public async Task <BaseResponseDto <HoraireDto> > GetHoraireById(Guid Id)
{
BaseResponseDto <HoraireDto> getResponse = new BaseResponseDto <HoraireDto>();
try
{
Horaire horaire = await _horaireRepository.GetAsync(Id);
if (horaire != null)
{
getResponse.Data = new HoraireDto
{
Id = horaire.Id,
MyUserId = horaire.MyUserId,
DateDuJourHor = horaire.DateDuJourHor,
HeureArriveHor = horaire.HeureArriveHor,
HeureDepartHor = horaire.HeureDepartHor
};
}
else
{
getResponse.Errors.Add("Horaire can't be ");
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
getResponse.Errors.Add(ex.Message);
}
return(getResponse);
}
public async Task <IActionResult> PutHoraire(Guid id, Horaire horaire)
{
if (id != horaire.Id)
{
return(BadRequest());
}
_context.Entry(horaire).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!HoraireExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Edit(int id, [Bind("HoraireId,Date,HeureDebut,HeureFin,CalendrierId,Visible,EmployeId")] Horaire horaire)
{
if (id != horaire.HoraireId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(horaire);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!HoraireExists(horaire.HoraireId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["CalendrierId"] = new SelectList(_context.Calendriers, "CalendrierId", "CalendrierId", horaire.CalendrierId);
return(View(horaire));
}
public void AssigneToSite(Horaire horaire, Site site)
{
Dictionary <string, dynamic> dic = new Dictionary <string, dynamic>();
dic.Add("site", site.Id);
dic.Add("horaire", horaire.Id);
_dbal.Insert("site_horaire", dic);
}
public async Task <IActionResult> Create([Bind("HoraireId,Date,HeureDebut,HeureFin,CalendrierId,Visible,EmployeId")] Horaire horaire)
{
if (ModelState.IsValid)
{
_context.Add(horaire);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["CalendrierId"] = new SelectList(_context.Calendriers, "CalendrierId", "CalendrierId", horaire.CalendrierId);
return(View(horaire));
}
public void Update(Horaire horaire)
{
Horaire h = DalGenerique <Horaire> .GetInstance().GetById(horaire.Id);
h.HeureDebut = horaire.HeureDebut;
h.HeureFin = horaire.HeureFin;
h.JourDebut = horaire.JourDebut;
h.JourFin = horaire.JourFin;
h.ListeTarifs = horaire.ListeTarifs;
db.SaveChanges();
}
public async Task <BaseResponseDto <HoraireDto> > CreateHoraire(Horaire horaire)
{
BaseResponseDto <HoraireDto> getResponse = new BaseResponseDto <HoraireDto>();
try
{
await _horaireRepository.CreateAsync(horaire);
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
getResponse.Errors.Add(ex.Message);
}
return(getResponse);
}
public async Task <Horaire> CreateHoraireAsync(Horaire horaire, string idToken)
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", idToken);
var content = JsonConvert.SerializeObject(horaire);
var httpResponse = await client.PostAsync(baseUrl, new StringContent(content, Encoding.Default, "application/json"));
if (!httpResponse.IsSuccessStatusCode)
{
throw new Exception("Impossible de créer l'horaire");
}
var createdTask = JsonConvert.DeserializeObject <Horaire>(await httpResponse.Content.ReadAsStringAsync());
return(createdTask);
}
/*public List<Partie> GetPartiesDuJour(Salle salle, DateTime date)
* {
* DataTable tab = _dbal.Select("Partie",
* "date > '" + date.ToString("yyyy-MM-dd H:m:s") + "' AND " +
* "date < '" + date.AddDays(1).ToString("yyyy-MM-dd") + "' AND " +
* "salle = " + salle.Id
* );
* List<Partie> lstP = new List<Partie>();
* foreach (DataRow row in tab.Rows)
* {
* lstP.Add(new Partie(row, _daoSalle.GetSalle((int)row["salle"])));
* }
* return lstP;
* }*/
/// <summary>
/// Attention, la date doit déja être attribué
/// </summary>
/*public void Create(Partie p)
* {
* _dbal.Insert("partie", p.ToArray());
* DataRow dbP = _dbal.Select("partie","date = '" + p.Date.ToString("yyyy-MM-dd") + "'").Rows[0];
* p.Id = (int)dbP["id"];
* foreach (Joueur j in p.LstJoueur)
* {
* _daoJoueur.AddJoueurToPartie(j, p);
* }
* for (int i = 0; i < p.LstObstacle.Count; i++)
* {
* _daoObstacle.AddObstacleToPartie(p.LstObstacle[i], p, i);
* }
* }
* public void Edit(Partie p)
* {
*
* }*/
// public Partie GetPartie(int id)
// {
// DataRow rowP = _dbal.SelectById("partie", id);
// Partie partie = new Partie(rowP, _daoSalle.GetSalle((int)rowP["salle"]));
// partie.LstJoueur = _daoJoueur.GetJoueurToPartie(partie);
// return partie;
// }
public Partie GetPartieForHoraire(Horaire horaire, DateTime jour, Salle salle)
{
try
{
return(new Partie(_dbal.Select("partie",
"salle = " + salle.Id +
" and date = '" + jour.ToString("yyyy-M-d") + "' and " +
"horaire = " + horaire.Id
).Rows[0],
horaire));
}
catch (Exception e)
{
return(new Partie(salle, horaire, jour));
}
}
public async Task <ActionResult <BaseResponseDto <HoraireDto> > > AddHoraire(Horaire horaire)
{
BaseResponseDto <HoraireDto> getResponse = await _horaireService.CreateHoraire(horaire);
if (!getResponse.HasError || getResponse.Data != null)
{
return(Ok(getResponse.Data));
}
else if (!getResponse.HasError || getResponse.Data == null)
{
return(NotFound());
}
else
{
return(BadRequest(getResponse.Errors));
}
}
public ViewModelGestion(DaoSite daoSite, DaoSalle daoSalle, DaoHoraire daoHoraire, DaoTheme daoTheme)
{
// DAO
_daoSite = daoSite;
_daoSalle = daoSalle;
_daoHoraire = daoHoraire;
_daoTheme = daoTheme;
// LISTES
_listSalles = new ObservableCollection <Salle>();
_listThemes = new ObservableCollection <Theme>(_daoTheme.GetAllTheme());
ListSites = new ObservableCollection <Site>(_daoSite.GetAllSite());
_listHoraires = new ObservableCollection <Horaire>(_daoHoraire.GetAllHoraires());
// SELECTIONS
_selectedSite = _listSites.First();
_selectedSalle = _listSalles.First();
_selectedHoraire = new Horaire();
_selectedHoraireSite = new Horaire();
_dateNewDate = new DateTime();
_nameNewTheme = "";
}
public async Task <int> estOuvert(Guid etablissementId)
{
try
{
int nbMinAvantFermeture = 0;
List <Horaire> lHoraire = await horaireService.GetAllHorairesAsync();
if (lHoraire.Any(x => x.EtablissementId == etablissementId))
{
lHoraire = lHoraire.Where(x => x.EtablissementId == etablissementId).ToList();
CultureInfo culture = CultureInfo.CurrentCulture;
string jour = culture.DateTimeFormat.GetDayName(DateTime.Now.Date.DayOfWeek).ToString().ToLower();
TimeSpan heure = DateTime.Now.TimeOfDay;
Horaire horaireJour = lHoraire.FirstOrDefault(h => h.Jour.ToLower().Equals(jour) && h.HeureOuverture <= heure && h.HeureFermeture >= heure);
if (horaireJour != null)
{
nbMinAvantFermeture = (int)(horaireJour.HeureFermeture.TotalMinutes - heure.TotalMinutes) / 1;
if (horaireJour.HeureFermeture == new TimeSpan(23, 59, 00) || horaireJour.HeureFermeture == new TimeSpan(00, 00, 00))
{
string demain = culture.DateTimeFormat.GetDayName(DateTime.Now.Date.AddDays(1).DayOfWeek).ToString().ToLower();
Horaire horaireDemain = lHoraire.FirstOrDefault(h => h.Jour.ToLower().Equals(demain) && h.HeureOuverture == new TimeSpan(00, 00, 00));
if (horaireDemain != null)
{
nbMinAvantFermeture = (int)(horaireDemain.HeureFermeture.Add(new TimeSpan(1, 0, 0, 0)).TotalMinutes - heure.TotalMinutes) / 1;
}
}
}
}
return(nbMinAvantFermeture);
}
catch (Exception ex)
{
throw ex;
}
}
public Horaire[] LectureHoraire(int IdMedecin)
{
using (DataClasses1DataContext entity = new DataClasses1DataContext())
{
var ret = entity.T_HORAIRE.Join(entity.T_PLAGEHORAIRE,
H => H.IDPlageHoraire,
PH => PH.ID,
(H, PH) => new { IDMedecin = H.IDMedecin, IdJour = H.IDJour, Matin = PH.HeureDebut, Soir = PH.HeureFin })
.Where(Id => Id.IDMedecin == IdMedecin).OrderBy(x => x.IdJour).ToArray();
Horaire[] retour = new Horaire[ret.Length];
for (int i = 0; i < ret.Length; i++)
{
retour[i] = new Horaire()
{
IDMedecin = ret[i].IDMedecin, IdJour = ret[i].IdJour, Matin = ret[i].Matin, Soir = ret[i].Soir
};
}
return(retour);
}
}
public async Task <BaseResponseDto <HoraireDto> > DeleteHoraire(Guid Id)
{
BaseResponseDto <HoraireDto> getResponse = new BaseResponseDto <HoraireDto>();
try
{
if (Id != null)
{
Horaire horaire = await _horaireRepository.GetAsync(Id);
await _horaireRepository.DeleteAsync(horaire);
}
else
{
getResponse.Errors.Add("Horaire can't be delete.");
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
getResponse.Errors.Add(ex.Message);
}
return(getResponse);
}
public async Task <ActionResult <string> > UpdateHoraire([FromRoute] string id, Horaire horaire)
{
Guid _id = Guid.Parse(id);
await _horaireService.UpdateHoraire(_id, horaire);
return(Ok("Horaire was updated sucessfull"));
}
public void New(ref Horaire horaire)
{
_dbal.Insert("horaire", horaire.ToArray());
horaire.Id = (int)_dbal.Select("horaire", "heure = '" + horaire.Heure + "'").Rows[0]["id"];
}
public static List <Parking> GetAll()
{
List <Parking> listeParkings = new List <Parking>();
var client = new WebClient();
client.Encoding = Encoding.UTF8;
var adresse = @"http://data.citedia.com/r1/parks/?crs=EPSG:4326";
var json = client.DownloadString(adresse);
RootObject rootObject = JsonConvert.DeserializeObject <RootObject>(json);
//Donnees des parking
foreach (var park in rootObject.parks)
{
if (park != null && park.parkInformation != null && park.parkInformation.free >= 10)
{
listeParkings.Add(new Parking
{
Identifiant = park.id,
Nom = park.parkInformation.name,
Statut = park.parkInformation.status,
PlacesMax = park.parkInformation.max,
PlacesLibres = park.parkInformation.free
});
}
}
//Coordonnees des parkings
foreach (var feature in rootObject.features.features)
{
var parkingSelected = listeParkings.FirstOrDefault(f => f.Identifiant == feature.id);
if (parkingSelected != null)
{
parkingSelected.Coordonnees = FormatCoordonnees(feature.geometry.coordinates);
}
}
//TexteTarifs et adresses des parkings
List <ParkingPrice> listeTarifs = SplitCSV(@"http://data.citedia.com/r1/parks/timetable-and-prices");
foreach (var tarif in listeTarifs)
{
Parking p = listeParkings.FirstOrDefault(f => f.Identifiant == tarif.Id);
if (p != null)
{
p.TexteHoraires = tarif.Horaires;
p.Adresse = tarif.Adresse;
p.TexteTarifs = tarif.Tarifs;
}
}
foreach (var parking in listeParkings)
{
parking.Adresse = DalGoogleMaps.GetAddressFromLatLng(parking.Coordonnees);
parking.LastUpdate = DateTime.Now;
}
//TODO Creer objets horaires et tarifs
//Horaires
Horaire h = new Horaire();
//Tarifs
Tarif t = new Tarif();
SaveParkings(listeParkings);
return(listeParkings);
}
