/// <summary>
/// Constructeur spécifique
/// </summary>
/// <param name="Connexion">Connexion au serveur MySQL</param>
/// <param name="Enregistrement">Enregistrement d'où extraire les valeurs de champs</param>
public PopvVehicule(PDSGBD.MyDB Connexion, PDSGBD.MyDB.IEnregistrement Enregistrement)
: this()
{
DefinirId(Enregistrement.ValeurChampComplet <int>(NomDeLaTablePrincipale, "id_popv_vehicule"));
this.Vehicule = new Vehicule(Connexion, Enregistrement);
this.PackOptionPackVehicule = new PackOptionPackVehicule(Connexion, Enregistrement);
}
/// <summary>
/// Constructeur spécifique
/// </summary>
/// <param name="OptionVehicule">Option liée à ce pack d'option</param>
/// <param name="PackOptionPackVehicule">Pack ayant cette option</param>
public PackOption(OptionVehicule OptionVehicule, PackOptionPackVehicule PackOptionPackVehicule)
: this()
{
DefinirId(Id);
this.OptionVehicule = OptionVehicule;
this.PackOptionPackVehicule = PackOptionPackVehicule;
}
/// <summary>
/// Constructeur spécifique
/// </summary>
/// <param name="VehiculeVente">Vehicule lié à cette option</param>
/// <param name="PackOptionPackVehicule">Pack lié à ce véhicule</param>
public ChoixPackVehicule(VehiculeVente VehiculeVente, PackOptionPackVehicule PackOptionPackVehicule)
: this()
{
DefinirId(Id);
this.VehiculeVente = VehiculeVente;
this.PackOptionPackVehicule = PackOptionPackVehicule;
}
/// <summary>
/// Constructeur spécifique
/// </summary>
/// <param name="Vehicule">Véhicule ayant ce pack disponible</param>
/// <param name="PackOptionPackVehicule">Pack disponible pour ce véhicule</param>
public PopvVehicule(Vehicule Vehicule, PackOptionPackVehicule PackOptionPackVehicule)
: this()
{
DefinirId(Id);
this.Vehicule = Vehicule;
this.PackOptionPackVehicule = PackOptionPackVehicule;
}
private void RefreshListeDeroulantePack(PackOptionPackVehicule PackASelectionner = null)
{
listeDeroulantePackOptions1.PackOptionPackVehicule = Program.GMBD.EnumererPackOptionVehicule(null, null, new PDSGBD.MyDB.CodeSql("WHERE disponible = 1"), null);
if (PackASelectionner != null)
{
listeDeroulantePackOptions1.PackOptionPackVehiculeSelectionne = PackASelectionner;
}
}
/// <summary>
/// Rajoute l'élément choisi à la liste des options désirées
/// </summary>
private void pictureBoxAjouterP_Click(object sender, EventArgs e)
{
if (fichePackOptionsGeneral.PackOptionsSelectionnee != null)
{
ValidationProvider.Clear();
errorProvider.Clear();
if (PackChoisis != null)
{
PackOptionPackVehicule PackExiste = PackChoisis.Find(item => (item.Id == fichePackOptionsGeneral.PackOptionsSelectionnee.Id));
if (PackExiste == null)
{
bool ValidationIndiquee = false;
foreach (PackOption PO in fichePackOptionsGeneral.PackOptionsSelectionnee.EnumPackOption)
{
foreach (OptionVehicule OV in ficheOptionsChoisies.Options)
{
if ((PO.OptionVehicule.Id == OV.Id) || ((PO.OptionVehicule.TypeOption.Id == OV.TypeOption.Id) && (OV.TypeOption.NomType != "Autres")))
{
PrixEstimeApresChoix -= OV.Prix;
OptionsChoisies.Remove(OV);
ficheOptionsChoisies.Options = OptionsChoisies;
}
}
if (PackChoisis.Count > 0)
{
foreach (PackOptionPackVehicule POPV in fichePackOptionsGeneral.PackOptions)
{
foreach (PackOption PO2 in POPV.EnumPackOption)
{
if ((PO.OptionVehicule.Id == PO2.OptionVehicule.Id) && (PO2.PackOptionPackVehicule.Id != fichePackOptionsGeneral.PackOptionsSelectionnee.Id))
{
PackChoisis.Remove(PackChoisis.Find(item => item.Id == PO2.PackOptionPackVehicule.Id));
PrixEstimeApresChoix -= PO2.PackOptionPackVehicule.PrixPack;
ValidationProvider.SetError(pictureBoxAjouterP, "Un ou plusieurs packs comprenant des duplications d'options ont été retirés");
ValidationIndiquee = true;
}
}
}
}
}
if (!ValidationIndiquee)
{
ValidationProvider.SetError(pictureBoxAjouterP, "Le pack a bien été ajouté");
}
PrixEstimeApresChoix += fichePackOptionsGeneral.PackOptionsSelectionnee.PrixPack;
textBoxPrixTotal.Text = string.Format("{0} €", PrixEstimeApresChoix);
PackChoisis.Add(fichePackOptionsGeneral.PackOptionsSelectionnee);
fichePackOptionsChoisis.PackOptions = PackChoisis;
}
else
{
errorProvider.SetError(pictureBoxAjouterP, "Ce pack a déjà été choisi");
}
}
}
}
/// <summary>
/// Met à jour la listview des PackOptions et y insére les elements
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Entites"></param>
/// <returns></returns>
private bool MettreAJourListe <T>(IEnumerable <T> Entites)
where T : class, IEntiteMySQL
{
bool EstPackOptions = typeof(T).Equals(typeof(PackOptionPackVehicule));
if (!EstPackOptions)
{
return(false);
}
listViewPackOptions.Items.Clear();
if (Entites == null)
{
return(false);
}
if (EstPackOptions && (listViewPackOptions.Columns.Count != 2))
{
listViewPackOptions.Columns.Clear();
listViewPackOptions.Columns.Add(new ColumnHeader()
{
Name = "NomPackOptions",
Text = "Nom du pack",
TextAlign = HorizontalAlignment.Center,
});
listViewPackOptions.Columns.Add(new ColumnHeader()
{
Name = "Prix",
Text = "Prix",
TextAlign = HorizontalAlignment.Center,
});
}
foreach (T Entite in Entites)
{
PackOptionPackVehicule PackOptions = Entite as PackOptionPackVehicule;
ListViewItem NouvelElement = new ListViewItem()
{
Tag = Entite,
Text = PackOptions.NomPack.ToString(),
};
NouvelElement.SubItems.Add(string.Format("{0} €", PackOptions.PrixPack.ToString()));
listViewPackOptions.Items.Add(NouvelElement);
}
listViewPackOptions.Visible = false;
foreach (ColumnHeader Colonne in listViewPackOptions.Columns)
{
Colonne.Width = listViewPackOptions.Width / listViewPackOptions.Columns.Count;
}
listViewPackOptions.Visible = true;
listViewPackOptions_SelectedIndexChanged(listViewPackOptions, EventArgs.Empty);
return(true);
}
private void Pack_SurErreur(PackOptionPackVehicule Entite, PackOptionPackVehicule.Champs Champ, string MessageErreur)
{
switch (Champ)
{
case PackOptionPackVehicule.Champs.NomPack:
errorProvider.SetError(textBoxNomPack, MessageErreur);
break;
case PackOptionPackVehicule.Champs.PrixPack:
errorProvider.SetError(numericUpDownPrixPack, MessageErreur);
break;
}
}
private void AjouterNouveauPack_AvantChangement(PackOptionPackVehicule Entite, PackOptionPackVehicule.Champs Champ, object ValeurActuelle, object NouvelleValeur, AccumulateurErreur AccumulateurErreur)
{
switch (Champ)
{
case PackOptionPackVehicule.Champs.NomPack:
{
PackOptionPackVehicule PackExiste = Program.GMBD.EnumererPackOptionVehicule(new PDSGBD.MyDB.CodeSql("nom_pack"), null, new PDSGBD.MyDB.CodeSql("where nom_pack = {0} AND disponible = 1", NouvelleValeur), null).FirstOrDefault();
if (PackExiste != null)
{
AccumulateurErreur.NotifierErreur("Ce pack existe déjà, veuillez rajouter cette option au pack existant ou recréer un nouveau pack");
}
break;
}
}
}
private void buttonSupprimerPack_Click(object sender, EventArgs e)
{
if (listeDeroulantePackOptions1.PackOptionPackVehiculeSelectionne != null)
{
PackOptionPackVehicule PackASupprimer = listeDeroulantePackOptions1.PackOptionPackVehiculeSelectionne;
PackASupprimer.Disponible = 0;
if (Program.GMBD.ModifierPackOptionPackVehicule(PackASupprimer))
{
textBoxNomPack.Text = "";
numericUpDownPrixPack.Value = 0;
RefreshListeDeroulantePack();
listeDeroulantePackOptions1.PackOptionPackVehiculeSelectionne = null;
ficheOptionsPackActuel.Options = null;
ValidationProvider.SetError(buttonSupprimerPack, "Suppression du pack correctement effectuée");
}
}
}
private void buttonAjouterP_Click(object sender, EventArgs e)
{
errorProvider.Clear();
ValidationProvider.Clear();
PackOptionPackVehicule NouveauPack = new PackOptionPackVehicule();
NouveauPack.SurErreur += Pack_SurErreur;
NouveauPack.AvantChangement += AjouterNouveauPack_AvantChangement;
NouveauPack.NomPack = textBoxNomPack.Text;
NouveauPack.PrixPack = double.Parse(numericUpDownPrixPack.Value.ToString());
NouveauPack.Disponible = 1;
if ((NouveauPack.EstValide) && (Program.GMBD.AjouterPackOptionPackVehicule(NouveauPack)))
{
ValidationProvider.SetError(buttonAjouterP, "Pack correctement ajouté");
RefreshListeDeroulantePack(NouveauPack);
listeDeroulantePackOptions1.PackOptionPackVehiculeSelectionne = NouveauPack;
RefreshFichePack(listeDeroulantePackOptions1.PackOptionPackVehiculeSelectionne.Id);
}
}
private void buttonModifierP_Click(object sender, EventArgs e)
{
errorProvider.Clear();
ValidationProvider.Clear();
if (listeDeroulantePackOptions1.PackOptionPackVehiculeSelectionne != null)
{
PackOptionPackVehicule PackAModifier = listeDeroulantePackOptions1.PackOptionPackVehiculeSelectionne;
PackAModifier.SurErreur += Pack_SurErreur;
PackAModifier.AvantChangement += ModifierPack_AvantChangement;
PackAModifier.NomPack = textBoxNomPack.Text;
PackAModifier.PrixPack = int.Parse(numericUpDownPrixPack.Value.ToString());
if ((PackAModifier.EstValide) && (Program.GMBD.ModifierPackOptionPackVehicule(PackAModifier)))
{
buttonAjouterP.Enabled = true;
buttonModifierP.Enabled = false;
ValidationProvider.SetError(buttonModifierP, "Pack correctement modifié");
RefreshListeDeroulantePack(PackAModifier);
ClearOptions();
}
}
}
/// <summary>
/// Constructeur par défaut
/// </summary>
public PackOption()
: base()
{
m_OptionVehicule = null;
m_PackOptionPackVehicule = null;
}
public Element(PackOptionPackVehicule PackOptionPackVehicule)
{
this.PackOptionPackVehicule = PackOptionPackVehicule;
}
/// <summary>
/// Constructeur par défaut
/// </summary>
public ChoixPackVehicule()
: base()
{
m_VehiculeVente = null;
m_PackOptionPackVehicule = null;
}
/// <summary>
/// Constructeur par défaut
/// </summary>
public PopvVehicule()
: base()
{
m_Vehicule = null;
m_PackOptionPackVehicule = null;
}
private void pictureBoxPackA_Click(object sender, EventArgs e)
{
ValidationProvider.Clear();
errorProvider.Clear();
if (ficheOptionsPackRecherche.OptionsSelectionnee != null)
{
// Si un pack a été choisi, alors on rajoute directement la valeur
if (listeDeroulantePackOptions1.PackOptionPackVehiculeSelectionne != null)
{
bool DoublonsSurOption = false;
foreach (OptionVehicule OV in ficheOptionsPackActuel.Options)
{
if ((ficheOptionsPackRecherche.OptionsSelectionnee.TypeOption.NomType == OV.TypeOption.NomType) && (ficheOptionsPackRecherche.OptionsSelectionnee.TypeOption.NomType != "Autres"))
{
DoublonsSurOption = true;
}
}
if (!DoublonsSurOption)
{
PackOption PackChoisi = new PackOption();
PackChoisi.AvantChangement += NouvelleOptionLiee_AvantChangement;
PackChoisi.SurErreur += NouvelleOptionLie_SurErreur;
PackChoisi.OptionVehicule = ficheOptionsPackRecherche.OptionsSelectionnee;
PackChoisi.PackOptionPackVehicule = listeDeroulantePackOptions1.PackOptionPackVehiculeSelectionne;
if ((PackChoisi.EstValide) && (Program.GMBD.AjouterPackOption(PackChoisi)))
{
ValidationProvider.SetError(pictureBoxPackA, "Option correctement ajoutée");
RefreshFichePack(listeDeroulantePackOptions1.PackOptionPackVehiculeSelectionne.Id);
}
}
else
{
errorProvider.SetError(pictureBoxPackA, "Ce type d'option a déjà été choisi");
}
}
// Sinon on crée le pack avec les valeurs de nom et de prix encodés, si elles ne le sont pas, on retourne un message d'erreur
else
{
PackOptionPackVehicule NouveauPack = new PackOptionPackVehicule();
NouveauPack.SurErreur += Pack_SurErreur;
NouveauPack.AvantChangement += AjouterNouveauPack_AvantChangement;
NouveauPack.NomPack = textBoxNomPack.Text;
NouveauPack.PrixPack = double.Parse(numericUpDownPrixPack.Value.ToString());
NouveauPack.Disponible = 1;
if ((NouveauPack.EstValide) && (Program.GMBD.AjouterPackOptionPackVehicule(NouveauPack)))
{
PackOption NouvelleOptionDeCePack = new PackOption();
NouvelleOptionDeCePack.OptionVehicule = ficheOptionsPackRecherche.OptionsSelectionnee;
NouvelleOptionDeCePack.PackOptionPackVehicule = NouveauPack;
if ((NouvelleOptionDeCePack.EstValide) && (Program.GMBD.AjouterPackOption(NouvelleOptionDeCePack)))
{
ValidationProvider.SetError(pictureBoxPackA, "Ce pack et cette option ont bien été ajoutés");
RefreshFichePack(NouveauPack.Id);
}
else
{
Program.GMBD.SupprimerPackOptionPackVehicule(NouveauPack);
errorProvider.SetError(pictureBoxPackA, "L'ajout semble impossible, veuillez revérifier vos valeurs");
}
}
}
}
}
