// POST: BackOffice/DossierReservations/
public ActionResult Accept(int?id)
{
DossierReservation dossierReservation = db.DossiersReservations.Find(id);
if (dossierReservation == null)
{
return(HttpNotFound());
}
if (dossierReservation.EtatDossier != EtatDossierReservation.EnCours)
{
Display("L'état du Dossier ne permet pas d'accepter");
return(RedirectToAction("Index"));
}
var voyage = db.Voyages.Find(dossierReservation.VoyageId);
if (dossierReservation.Participants.Count < voyage.MaxCapacity)
{
dossierReservation.EtatDossier = EtatDossierReservation.Accepte;
voyage.MaxCapacity -= dossierReservation.Participants.Count;
db.Entry(voyage).State = EntityState.Modified;
Display("La réservation a été acceptée");
}
else
{
dossierReservation.EtatDossier = EtatDossierReservation.Refusee;
dossierReservation.RaisonAnnulationDossier = RaisonAnnulationDossier.PlacesInsuffisantes;
Display("La réservation a été refusée pour cause places non disponibles");
}
db.Entry(dossierReservation).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
private void NouveauDossier()
{
ConsoleHelper.AfficherEntete("Nouveau Dossier");
OutilsConsole.CentrerTexte("LISTE DES VOYAGES DISPONIBLES");
OutilsConsole.Commentaire("---------- ( Le Prix/Pers est le Prix Agence indicatif) -------\n ");
ConsoleHelper.AfficherListe(new VoyageData().GetList(), VoyagesMenu.strategieAffichageVoyages);
Console.WriteLine();
OutilsConsole.CentrerTexte("LISTE DES CLIENTS");
ConsoleHelper.AfficherListe(new ClientData().GetList(), ClientsMenu.strategieAffichageClients);
var dossierReservation = new DossierReservation
{
VoyageId = ConsoleSaisie.SaisirEntierObligatoire("Entrez l' Id du Voyage :"),
NumeroUnique = ConsoleSaisie.SaisirEntierObligatoire("Entrez le Numero Unique (10..) :"),
ClientId = ConsoleSaisie.SaisirEntierObligatoire("Entrez l' Id Client :"),
PrixParPersonne = ConsoleSaisie.SaisirDecimalObligatoire("Prix par Personne BoVoyage :"),
NumeroCarteBancaire = ConsoleSaisie.SaisirChaineObligatoire("Numero CB :")
};
var dossierReservationService = new DossierReservationService();
dossierReservationService.Ajout(dossierReservation);
if (dossierReservation.Id != 0)
{
Console.WriteLine("Le Dossier a été créé avec l'Id :" + dossierReservation.Id);
}
else
{
Console.WriteLine("Impossible de créer le dossier");
}
}
// POST: BackOffice/DossierReservations/
public ActionResult Cancel(int?id)
{
DossierReservation dossierReservation = db.DossiersReservations.Find(id);
if (dossierReservation == null)
{
return(HttpNotFound());
}
if (dossierReservation.EtatDossier == EtatDossierReservation.Clos ||
dossierReservation.EtatDossier == EtatDossierReservation.Annule)
{
Display("L'état du Dossier ne permet pas de l'Annuler", MessageType.ERROR);
return(RedirectToAction("Index"));
}
if (dossierReservation.EtatDossier != EtatDossierReservation.Refusee)
{
if (dossierReservation.EtatDossier == EtatDossierReservation.Accepte)
{
if (dossierReservation.Assurances.Where(x => x.TypeAssurance == TypeAssurance.Annulation).Count() > 0)
{
var rembourser = new CarteBancaireService().Rembourser(dossierReservation.CreditCardNumber,
dossierReservation.TotalPrice);
Display("Vous serez remboursé grâce à votre Assurance Annulation", MessageType.SUCCES);
}
dossierReservation.RaisonAnnulationDossier = RaisonAnnulationDossier.Client;
}
dossierReservation.EtatDossier = EtatDossierReservation.Annule;
db.Entry(dossierReservation).State = EntityState.Modified;
db.SaveChanges();
Display("La réservation a été annulée", MessageType.SUCCES);
}
return(RedirectToAction("Index"));
}
// GET: Reservations/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
DossierReservation dossierReservation = db.DossiersReservations.Include(d => d.Client)
.Include(d => d.Voyage).Include(d => d.Voyage.Destination)
.Include(d => d.Participants)
.Include(d => d.Assurances).SingleOrDefault(d => d.Id == id);
if (dossierReservation == null)
{
return(HttpNotFound());
}
var clientId = GetCurrentClientId();
if (dossierReservation.ClientId != clientId)
{
Display("Vous n'avez pas accès à cette réservation", MessageType.ERROR);
return(RedirectToAction("Index"));
}
if (dossierReservation.EtatDossier == EtatDossierReservation.Refusee ||
dossierReservation.EtatDossier == EtatDossierReservation.Annule)
{
Display("Votre réservation avait déjà été réfusée ou annulée", MessageType.ERROR);
return(RedirectToAction("Index"));
}
return(View(dossierReservation));
}
public ActionResult Book([Bind(Exclude = "Id")] DossierReservation dossierReservation, int[] AssuranceIds)
{
if (ModelState.IsValid)
{
if (AssuranceIds != null && AssuranceIds.Count() > 0)
{
dossierReservation.Assurances = db.Assurances.Where(x => AssuranceIds.Contains(x.ID)).ToList();
}
double cardNumber = 0;
if (double.TryParse(dossierReservation.CreditCardNumber, out cardNumber) && cardNumber > 0)
{
dossierReservation.UnitPrice = db.Voyages.Find(dossierReservation.VoyageId).UnitPublicPrice;
db.DossiersReservations.Add(dossierReservation);
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("CreditCardNumber", "Le numéro CB doit comporter 20 chiffres maximimum");
}
}
var voyage = db.Voyages.Include(v => v.Destination).SingleOrDefault(x => x.Id == dossierReservation.VoyageId);
dossierReservation.Voyage = voyage;
MultiSelectList assuranceValues = new MultiSelectList(db.Assurances, "ID", "TypeAssurance", db.Assurances.Select(x => x.ID));
ViewBag.Assurances = assuranceValues;
return(View(dossierReservation));
}
public DossierReservation Ajout(DossierReservation dossierReservation)
{
var dossierData = new DossierData();
dossierData.Ajouter(dossierReservation);
return(dossierReservation);
}
public ActionResult DeleteConfirmed(int id)
{
DossierReservation dossierReservation = db.DossiersReservations.Include(d => d.Client)
.Include(d => d.Voyage).Include(d => d.Voyage.Destination)
.Include(d => d.Participants)
.Include(d => d.Assurances).SingleOrDefault(d => d.Id == id);
if (ModelState.IsValid)
{
if (dossierReservation.EtatDossier == EtatDossierReservation.Accepte)
{
if (dossierReservation.Assurances.Where(x => x.TypeAssurance == TypeAssurance.Annulation).Count() > 0)
{
var rembourser = new CarteBancaireService().Rembourser(dossierReservation.CreditCardNumber,
dossierReservation.TotalPrice);
Display("Vous serez remboursé grâce à votre Assurance Annulation", MessageType.SUCCES);
}
}
dossierReservation.EtatDossier = EtatDossierReservation.Annule;
dossierReservation.RaisonAnnulationDossier = RaisonAnnulationDossier.Client;
db.Entry(dossierReservation).State = EntityState.Modified;
db.SaveChanges();
}
return(RedirectToAction("Index"));
}
// GET: Reservations/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
DossierReservation dossierReservation = db.DossiersReservations.Find(id);
if (dossierReservation == null)
{
return(HttpNotFound());
}
var clientId = GetCurrentClientId();
if (dossierReservation.ClientId != clientId)
{
Display("Vous n'avez pas accès à cette réservation", MessageType.ERROR);
return(RedirectToAction("Index"));
}
if (dossierReservation.EtatDossier == EtatDossierReservation.Refusee ||
dossierReservation.EtatDossier == EtatDossierReservation.Annule)
{
Display("Votre réservation avait déjà été réfusé ou annulé", MessageType.ERROR);
return(RedirectToAction("Index"));
}
return(View(dossierReservation));
}
// POST: BackOffice/DossierReservations/
public ActionResult Validate(int?id)
{
DossierReservation dossierReservation = db.DossiersReservations.Find(id);
if (dossierReservation == null)
{
return(HttpNotFound());
}
if (dossierReservation.EtatDossier != EtatDossierReservation.EnAttente)
{
Display("L'état du Dossier ne permet pas de valider ou a déjà été validé", MessageType.ERROR);
return(RedirectToAction("Index"));
}
var carteBancaireServie = new CarteBancaireService();
if (carteBancaireServie.ValiderSolvabilite(dossierReservation.CreditCardNumber,
dossierReservation.TotalPrice))
{
dossierReservation.EtatDossier = EtatDossierReservation.EnCours;
db.Entry(dossierReservation).State = EntityState.Modified;
db.SaveChanges();
Display("La réservation a été validée", MessageType.SUCCES);
}
else
{
dossierReservation.EtatDossier = EtatDossierReservation.Refusee;
dossierReservation.RaisonAnnulationDossier = RaisonAnnulationDossier.Insolvable;
Display("Opération Refusée pour insolvabilité", MessageType.ERROR);
}
return(RedirectToAction("Index"));
}
public IHttpActionResult PutDossierReservation(int id, DossierReservation dossierReservation)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != dossierReservation.Id)
{
return(BadRequest());
}
db.Entry(dossierReservation).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!DossierReservationExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public void CreerReservation()
{
ConsoleHelper.AfficherEntete("Nouvelle réservation");
var reservation = new DossierReservation {
};
ConsoleHelper.AfficherEntete("liste des participants");
var liste = Application.GetBaseDonnees().Participants.ToList();
ConsoleHelper.AfficherListe(liste, StrategieAffichage.AffichageParticipant());
using (var bd = Application.GetBaseDonnees())
{
reservation.IdParticipant = ConsoleSaisie.SaisirEntierObligatoire("Entrer Id du participant");
var listeparticipant = bd.Participants.Where(x => x.Id == reservation.IdParticipant);
ConsoleHelper.AfficherListe(listeparticipant, StrategieAffichage.AffichageParticipant());
ConsoleHelper.AfficherEntete("Liste des Voyages");
var listevoyage = Application.GetBaseDonnees().Voyages.ToList();
var listes = bd.Voyages.Where(x => x.Id == reservation.IdVoyage);
ConsoleHelper.AfficherListe(listes, StrategieAffichage.AffichageGestionVoyages());
reservation.IdVoyage = ConsoleSaisie.SaisirEntierObligatoire("Entrer Id du voyage");
reservation.NumeroUnique = ConsoleSaisie.SaisirEntierObligatoire("Entrez le numéro unique:");
reservation.NumeroCarteBancaire = ConsoleSaisie.SaisirChaineObligatoire("Entrez numéro de carte bancaire:");
bd.DossiersReservations.Add(reservation);
bd.SaveChanges();
}
}
public void CreerReservation()
{
ConsoleHelper.AfficherEntete("Nouvelle réservation");
var reservation = new DossierReservation {
};
{
reservation.IdVoyage = ConsoleSaisie.SaisirEntierObligatoire("IdVoyage :");
reservation.IdClient = ConsoleSaisie.SaisirEntierObligatoire("IdClient :");
reservation.IdParticipant = ConsoleSaisie.SaisirEntierObligatoire("IdParticipant :");
reservation.NumeroUnique = int.Parse(ConsoleSaisie.SaisirChaineObligatoire("Entrez le numéro (unique) client : "));
reservation.PrixTotal = int.Parse(ConsoleSaisie.SaisirChaineObligatoire("Entrez le prix Total : "));
reservation.NumeroCarteBancaire = ConsoleSaisie.SaisirEntierObligatoire("Entrez le numéro de la carte bancaire du client : ");
};
Console.WriteLine("Voulez vous une assurance annulation O / N");
if (Console.ReadLine().ToUpper() == "O")
{
reservation.Assurance = true;
}
using (var bd = Application.GetBaseDonnees())
{
bd.DossiersReservations.Add(reservation);
bd.SaveChanges();
}
}
private void AnnulerDossier()
{ // en attente ou en cours à refusé
ConsoleHelper.AfficherEntete("Annulation d'un Dossier");
ConsoleHelper.AfficherListe(new DossierData().GetList(), strategieAffichageDossiers);
var dossierReservationService = new DossierReservationService();
var dossierReservation = new DossierReservation();
dossierReservation.Id = ConsoleSaisie.SaisirEntierObligatoire("Numero du Dossier à Annuler :");
var raisonAnnulation = ConsoleSaisie.SaisirEntierObligatoire("Raison de l'annulation" +
"\n 1. Cause Client \n 2. Nombre de places inssufisant : ");
if (raisonAnnulation >= 1 && raisonAnnulation <= 2)
{
dossierReservation.RaisonAnnulationDossier = (RaisonAnnulationDossier)raisonAnnulation;
var succes = dossierReservationService.Annuler(dossierReservation.Id, dossierReservation.RaisonAnnulationDossier);
if (succes)
{
Console.WriteLine("Le Dossier numero " + dossierReservation.Id + " a bien été annulé ");
}
else
{
Console.WriteLine("Impossible d'annuler le dossier numero " + dossierReservation.Id);
}
}
else
{
Console.WriteLine("Choix non valide...");
}
}
private void Creer()
{
ConsoleHelper.AfficherEntete("Créer un dossier de réservation");
ConsoleHelper.AfficherListe(serviceVoyage.ListerVoyage(), ElementsAffichage.strategieAffichageVoyage);
var idVoyage = ConsoleSaisie.SaisirEntierObligatoire("Identifiant du voyage ?");
ConsoleHelper.AfficherListe(serviceClient.ListerClient(), ElementsAffichage.strategieAffichageClient);
var idClient = ConsoleSaisie.SaisirEntierObligatoire("Identifiant du client ?");
ConsoleHelper.AfficherListe(serviceParticipant.ListerParticipant(), ElementsAffichage.strategieAffichageParticipant);
List <string> listeIdentifiant = null;
while (listeIdentifiant == null)
{
listeIdentifiant = new List <string>();
var reponseListeIdentifiant = ConsoleSaisie.SaisirChaineObligatoire("Donnez la liste des identifiants des participants (maximum 9 et séparés par des virgules)");
listeIdentifiant = reponseListeIdentifiant.Split(',').ToList();
if (listeIdentifiant.Count() > 9)
{
ConsoleHelper.AfficherMessageErreur("Vous ne pouvez pas selectionner plus de 9 participants");
listeIdentifiant = null;
}
}
List <Participant> listeParticipant = new List <Participant>();
foreach (string identifiant in listeIdentifiant)
{
int idParticipant = int.Parse(identifiant);
listeParticipant.Add(serviceParticipant.TrouverParticipant(idParticipant));
}
ConsoleHelper.AfficherListe(serviceAssurance.ListerAssurance(), ElementsAffichage.strategieAffichageAssurance);
var idAssurance = ConsoleSaisie.SaisirEntierOptionnel("Identifiant de l'assurance ?");
decimal prixTotal = service.CalculerPrixTotal(listeParticipant, idVoyage, idAssurance);
var numeroUnique = ConsoleSaisie.SaisirEntierObligatoire("Numéro unique ?");
var numeroCarteBancaire = ConsoleSaisie.SaisirChaineObligatoire("Numéro carte bancaire ?");
var voyage = serviceVoyage.TrouverVoyage(idVoyage);
DossierReservation dossierReservation = new DossierReservation
{
NumeroUnique = numeroUnique,
NumeroCarteBancaire = numeroCarteBancaire,
IdClient = idClient,
NombreParticipant = listeParticipant.Count,
IdVoyage = idVoyage,
PrixTotal = prixTotal,
Participant = listeParticipant.First(),
PrixParPersonne = voyage.PrixParPersonne,
Etat = EtatDossierReservation.EnAttente,
IdAssurance = idAssurance
};
service.EnregistrerReservation(dossierReservation);
}
public ActionResult DeleteConfirmed(int id)
{
DossierReservation dossierReservation = db.DossierReservations.Find(id);
db.DossierReservations.Remove(dossierReservation);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void AjouterDossierReservation(DossierReservation dossierReservation)
{
using (Context context = new Context())
{
context.DossiersReservations.Add(dossierReservation);
context.SaveChanges();
}
}
public void SupprimerDossierReservation(DossierReservation dossier)
{
using (var contexte = new Contexte())
{
contexte.Entry(dossier).State = EntityState.Deleted;
contexte.SaveChanges();
}
}
public void CreerDossierReservation(DossierReservation dossierReservation)
{
using (var contexte = new Contexte())
{
contexte.DossiersReservations.Add(dossierReservation);
contexte.SaveChanges();
}
}
public void SupprimerDossierReservation(int id)
{
using (Context context = new Context())
{
DossierReservation dossierReservation = context.DossiersReservations.Single(x => x.Id == id);
context.DossiersReservations.Remove(dossierReservation);
context.SaveChanges();
}
}
public DossierReservation Ajouter(DossierReservation DossierReservation)
{
using (var contexte = new Contexte())
{
contexte.DossierReservations.Add(DossierReservation);
contexte.SaveChanges();
}
return(DossierReservation);
}
public void SupprimerDossierReservation(DossierReservation dossierReservation)
{
using (Context context = new Context())
{
context.DossiersReservations.Attach(dossierReservation);
context.DossiersReservations.Remove(dossierReservation);
context.SaveChanges();
}
}
public void ModifierDossierReservation(DossierReservation dossierReservation)
{
using (var contexte = new Contexte())
{
contexte.DossiersReservations.Attach(dossierReservation);
contexte.Entry(dossierReservation).State = EntityState.Modified;
contexte.SaveChanges();
}
}
public DossierReservation Update(DossierReservation dossierReservation)
{
using (var contexte = new BoVoyage())
{
contexte.DossierReservations.Attach(dossierReservation);
contexte.Entry(dossierReservation).State = EntityState.Modified;
contexte.SaveChanges();
}
return(dossierReservation);
}
public void EnregistrerReservation(DossierReservation dossierReservation)
{
if (dossierReservation.Id == 0)
{
CreerDossierReservation(dossierReservation);
}
else
{
ModifierDossierReservation(dossierReservation);
}
}
private static void SupprimerReservation()
{
Console.WriteLine();
Console.WriteLine(">SUPPRESSION D'UNE RESERVATION");
DossierReservation dossier = ChoisirDossier();
var serviceResa = new ServiceReservation();
serviceResa.SupprimerDossierReservation(dossier);
}
public IHttpActionResult GetDossierReservation(int id)
{
DossierReservation dossierReservation = db.DossiersReservations.Find(id);
if (dossierReservation == null)
{
return(NotFound());
}
return(Ok(dossierReservation));
}
public ActionResult Edit([Bind(Include = "Id,CreditCardNumber,UnitPrice,EtatDossier,ClientId,VoyageId")] DossierReservation dossierReservation)
{
if (ModelState.IsValid)
{
db.Entry(dossierReservation).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ClientId = new SelectList(db.Clients, "Id", "UserId", dossierReservation.ClientId);
ViewBag.VoyageId = new SelectList(db.Voyages, "Id", "Id", dossierReservation.VoyageId);
return(View(dossierReservation));
}
public ActionResult Edit([Bind(Include = "ID,NumeroCarteBancaire,PrixParPersonne,EtatDossierReservation,RaisonAnnulationDossier,PrixTotal,IDVoyage,IDClient")] DossierReservation dossierReservation)
{
if (ModelState.IsValid)
{
db.Entry(dossierReservation).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.IDClient = new SelectList(db.Clients, "ID", "Email", dossierReservation.IDClient);
ViewBag.IDVoyage = new SelectList(db.Voyages, "ID", "ID", dossierReservation.IDVoyage);
return(View(dossierReservation));
}
public IHttpActionResult GetDossierReservation(int id)
{
DossierReservation dossierReservation = db.DossierReservations.Include(x => x.Participants).Include(y => y.Client).Include(t => t.Voyage)
.Include(z => z.Assurances).SingleOrDefault(u => u.Id == id);
if (dossierReservation == null)
{
return(NotFound());
}
return(Ok(dossierReservation));
}
public IHttpActionResult PostDossierReservation(DossierReservation dossierReservation)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.DossierReservations.Add(dossierReservation);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = dossierReservation.Id }, dossierReservation));
}
