private void buttonAjouter_Click(object sender, EventArgs e)
{
Faction FactionExiste = null;
FactionExiste = Program.GMBD.EnumererFaction(null,
null,
new MyDB.CodeSql("WHERE fa_name = {0}", textBoxFaction.Text),
null).FirstOrDefault();
// Si la faction n'existe pas, on crée une nouvelle faction
if (FactionExiste == null)
{
Faction NouvelleFaction = new Faction();
NouvelleFaction.SurErreur += FactionEnEdition_SurErreur;
NouvelleFaction.Name = textBoxFaction.Text;
if ((NouvelleFaction.EstValide) && (Program.GMBD.AjouterFaction(NouvelleFaction)))
{
ChargerFaction();
ValidationProvider.SetError(textBoxFaction, "Faction correctement ajouté");
}
}
else
{
errorProviderErreurFaction.SetError(textBoxFaction, "Cette faction existe déjà");
}
buttonAnnuler.Enabled = false;
}
private void buttonAjouter_Click(object sender, EventArgs e)
{
Article NouvelArticle = new Article();
NouvelArticle.SurErreur += Article_SurErreur;
NouvelArticle.NomArticle = textBoxNomArticle.Text;
NouvelArticle.PrixUnite = double.Parse(numericUpDownPrixUnitaire.Value.ToString());
NouvelArticle.Stock = int.Parse(numericUpDownQuantite.Value.ToString());
NouvelArticle.Disponible = 1;
Article ArticleExiste = Program.GMBD.EnumererArticle(null, null, new PDSGBD.MyDB.CodeSql("WHERE nom_article = {0} AND disponible = 1", textBoxNomArticle.Text), null).FirstOrDefault();
if ((ArticleExiste != null) && (ArticleExiste.Disponible == 1))
{
errorProvider.SetError(buttonAjouter, "Cet article existe déjà");
}
else
{
if ((NouvelArticle.EstValide) && (Program.GMBD.AjouterArticle(NouvelArticle)))
{
RefreshPage();
ValidationProvider.SetError(buttonAjouter, "Article correctement ajouté");
}
}
}
private void pictureBoxAjouterP_Click(object sender, EventArgs e)
{
ValidationProvider.Clear();
errorProvider.Clear();
if (fichePackOptionsAChoisir.PackOptionsSelectionnee != null)
{
PopvVehicule NouvelleLiaisonPack = new PopvVehicule();
NouvelleLiaisonPack.Vehicule = Vehicule;
NouvelleLiaisonPack.PackOptionPackVehicule = fichePackOptionsAChoisir.PackOptionsSelectionnee;
PopvVehicule LiaisonExiste = Program.GMBD.EnumererPopvVehicule(null, new PDSGBD.MyDB.CodeSql("JOIN pack_option_pack_vehicule ON popv_vehicule.fk_id_popv = pack_option_pack_vehicule.id_pack_option_pack_vehicule"), new PDSGBD.MyDB.CodeSql("WHERE fk_id_popv = {0} AND fk_id_vehicule = {1} AND disponible = 1", fichePackOptionsAChoisir.PackOptionsSelectionnee.Id, Vehicule.Id), null).FirstOrDefault();
if (LiaisonExiste == null)
{
if ((NouvelleLiaisonPack.EstValide) && (Program.GMBD.AjouterPopvVehicule(NouvelleLiaisonPack)))
{
RefreshFichePackDispo();
RefreshFichePacksLies();
ValidationProvider.SetError(pictureBoxAjouterP, "Pack correctement lié à ce véhicule");
}
}
else
{
errorProvider.SetError(pictureBoxAjouterP, "Ce pack existe déjà pour ce véhicule");
}
}
else
{
errorProvider.SetError(pictureBoxAjouterP, "Vous devez séléctionner un pack dans la liste");
}
}
private void buttonModifier_Click(object sender, EventArgs e)
{
if (ficheArticle1.ArticleSelectionnee != null)
{
Article ArticleAModifier = ficheArticle1.ArticleSelectionnee;
ArticleAModifier.SurErreur += Article_SurErreur;
ArticleAModifier.NomArticle = textBoxNomArticle.Text;
ArticleAModifier.PrixUnite = double.Parse(numericUpDownPrixUnitaire.Value.ToString());
ArticleAModifier.Stock = int.Parse(numericUpDownQuantite.Value.ToString());
Article ArticleExiste = Program.GMBD.EnumererArticle(null, null, new PDSGBD.MyDB.CodeSql("WHERE nom_article = {0} AND id_article != {1}", textBoxNomArticle.Text, ficheArticle1.ArticleSelectionnee.Id), null).FirstOrDefault();
if ((ArticleExiste != null) && (ArticleExiste.Disponible == 1))
{
errorProvider.SetError(buttonModifier, "Cet article existe déjà, veuillez choisir un autre nom pour l'article");
}
else
{
if ((ArticleAModifier.EstValide) && (Program.GMBD.ModifierArticle(ArticleAModifier)))
{
RefreshPage();
ValidationProvider.SetError(buttonModifier, "Article correctement modifié");
}
}
}
}
private void RajouterNouvelleSpecificite(int NumeroDuCamp)
{
Condi_Camp NouvelleSpecificite = new Condi_Camp();
NouvelleSpecificite.SurErreur += Specificite_SurErreur;
NouvelleSpecificite.AvantChangement += Specificite_AvantChangement;
NouvelleSpecificite.Unity = listeDeroulanteUnity1.UnitySelectionnee;
NouvelleSpecificite.Scenario_Camp = Program.GMBD.EnumererScenarioCamp(null, new MyDB.CodeSql(@"JOIN scenario ON scenario.sc_id = scenario_camp.sca_fk_scenario_id
JOIN camp ON camp.ca_id = scenario_camp.sca_fk_camp_id "),
new MyDB.CodeSql("WHERE scenario.sc_id = {0} AND camp.ca_id = {1}", Scenario.Scenario.Id, NumeroDuCamp), null).FirstOrDefault();
NouvelleSpecificite.Min = Convert.ToInt32(numericUpDownObligatoire.Value);
NouvelleSpecificite.Max = Convert.ToInt32(numericUpDown2.Value);
Condi_Camp SpecificiteExiste = Program.GMBD.EnumererCondiCamp(null, null, new MyDB.CodeSql("WHERE cc_fk_scenario_camp_id = {0} AND cc_fk_unity_id = {1}", NouvelleSpecificite.Scenario_Camp.Id, NouvelleSpecificite.Unity.Id), null).FirstOrDefault();
if (SpecificiteExiste == null)
{
if (NouvelleSpecificite.EstValide && Program.GMBD.AjouterSpecificite(NouvelleSpecificite))
{
ChargerSpecificite(NumeroDuCamp);
ValidationProvider.SetError(ficheSpecifiteScenario1, "Spécificité correctement rajoutée");
}
}
else
{
errorProvider1.SetError(listeDeroulanteUnity1, "Cette spécificté existe déjà pour ce camp");
}
}
private void buttonSupprimer_Click(object sender, EventArgs e)
{
PopUpConfirmation FormConfirmation = new PopUpConfirmation();
Army ScenarioLie = Program.GMBD.EnumererArmy(null, null, new MyDB.CodeSql("WHERE ar_fk_scenario_camp_id = {0}", Scenario.Id), null).FirstOrDefault();
if (ScenarioLie == null)
{
FormConfirmation.LabelDuTexte = "Êtes vous certain de vouloir supprimer cet enregistrement ?";
FormConfirmation.ShowDialog();
// S'il accepte
if (FormConfirmation.Confirmation)
{
if ((ficheSpecifiteScenario1.SpecificiteSelectionne != null) && (Program.GMBD.SupprimerSpecificite(ficheSpecifiteScenario1.SpecificiteSelectionne)))
{
ChargerSpecificite(Scenario.Camp.Id);
buttonAjouter.Enabled = true;
buttonSupprimer.Enabled = false;
ValidationProvider.SetError(ficheSpecifiteScenario1, "Suppresion correctement effectuée");
}
}
// S'il refuse
else if (FormConfirmation.Annulation)
{
// ne rien faire
}
}
else
{
errorProvider1.SetError(ficheSpecifiteScenario1, "Ce scénario est utilisée par armée, veuillez la supprimer avant de supprimer une spécifitée");
}
}
private void buttonModifierLier_Click(object sender, EventArgs e)
{
errorProvider.Clear();
ValidationProvider.Clear();
if (ficheTechnique1.CaracteristiqueSelectionnee != null)
{
VehiculeCaracteristique CaracteristiqueAModifier = ficheTechnique1.CaracteristiqueSelectionnee;
CaracteristiqueAModifier.SurErreur += NouvelleValeurCaracteristique_SurErreur;
CaracteristiqueAModifier.Valeur = textBoxInfo.Text;
if (listeDeroulanteVehicule1.VehiculeSelectionne != null)
{
CaracteristiqueAModifier.Vehicule = listeDeroulanteVehicule1.VehiculeSelectionne;
}
else
{
errorProvider.SetError(listeDeroulanteVehicule1, "Veuillez sélectionner un véhicule");
}
CaracteristiqueAModifier.Caracteristique = listeDeroulanteCaracteristique1.CaracteristiqueSelectionne;
if ((CaracteristiqueAModifier.EstValide) && (Program.GMBD.ModifierVehiculeCaracteristique(CaracteristiqueAModifier)))
{
errorProvider.Clear();
ValidationProvider.SetError(buttonModifierLier, "Caractéristique correctement modifiée");
RefreshFicheTechnique();
}
}
}
private void buttonAjouterO_Click(object sender, EventArgs e)
{
errorProvider.Clear();
ValidationProvider.Clear();
OptionVehicule NouvelleOption = new OptionVehicule();
NouvelleOption.SurErreur += NouvelleOption_SurErreur;
NouvelleOption.AvantChangement += NouvelleOption_AvantChangement;
NouvelleOption.NomOption = textBoxNomOption.Text;
NouvelleOption.Disponible = 1;
int Prix = -1;
if (int.TryParse(numericUpDownPrixOption.Value.ToString(), out Prix))
{
NouvelleOption.Prix = int.Parse(numericUpDownPrixOption.Value.ToString());
}
NouvelleOption.TypeOption = listeDeroulanteTypeOptions1.TypeOptionsSelectionne;
if ((NouvelleOption.EstValide) && (Program.GMBD.AjouterOptionVehicule(NouvelleOption)))
{
ValidationProvider.SetError(buttonAjouterO, "Option correctement ajoutée");
ficheOptionsAjouter.Options = Program.GMBD.EnumererOptionVehicule(null, new PDSGBD.MyDB.CodeSql("JOIN type_option ON option_vehicule.fk_id_type_option = type_option.id_type_option"), new PDSGBD.MyDB.CodeSql("WHERE disponible = 1"), null);
ficheOptionsPackRecherche.Options = Program.GMBD.EnumererOptionVehicule(null, new PDSGBD.MyDB.CodeSql("JOIN type_option ON option_vehicule.fk_id_type_option = type_option.id_type_option"), new PDSGBD.MyDB.CodeSql("WHERE disponible = 1"), null);
ClearOptions();
}
}
private void buttonSupprimerCaract_Click(object sender, EventArgs e)
{
errorProvider.Clear();
ValidationProvider.Clear();
if (listeDeroulanteCaracteristiqueAjouter.CaracteristiqueSelectionne != null)
{
VehiculeCaracteristique VehiculeCaractUtilise = Program.GMBD.EnumererVehiculeCaracteristique(null, null, new PDSGBD.MyDB.CodeSql("WHERE fk_id_caracteristique = {0}", listeDeroulanteCaracteristiqueAjouter.CaracteristiqueSelectionne.Id), null).FirstOrDefault();
if (VehiculeCaractUtilise == null)
{
if (Program.GMBD.SupprimerCaracteristique(listeDeroulanteCaracteristiqueAjouter.CaracteristiqueSelectionne))
{
ClearCaract();
errorProvider.Clear();
ValidationProvider.Clear();
ValidationProvider.SetError(buttonSupprimerCaract, "La caractéristique a bien été supprimée");
RefreshNouvelleCaract();
RefreshListeCaract();
}
}
else
{
errorProvider.Clear();
ValidationProvider.Clear();
Caracteristique CaracteristiqueASupprimer = listeDeroulanteCaracteristiqueAjouter.CaracteristiqueSelectionne;
CaracteristiqueASupprimer.Disponible = 0;
if ((CaracteristiqueASupprimer.EstValide) && (Program.GMBD.ModifierCaracteristique(CaracteristiqueASupprimer)))
{
ValidationProvider.SetError(buttonSupprimerCaract, "La caractéristique a bien été supprimée");
RefreshNouvelleCaract();
RefreshListeCaract();
}
}
}
}
private void textBoxLastName_Validating(object sender, System.ComponentModel.CancelEventArgs e)
{
if (textBoxSignUPLastName.Text == string.Empty)
{
errorProvider.SetError(textBoxSignUPLastName, "Empty");
}
else if (textBoxSignUPLastName.Text != string.Empty)
{
string lastName = textBoxSignUPLastName.Text;
foreach (char item in lastName)
{
if (char.IsLetter(item))
{
lNFlag = true;
}
}
if (lNFlag == false)
{
errorProvider.SetError(textBoxSignUPLastName, @"First Name Contains 'numbers or special character");
}
else if (lNFlag == true)
{
ValidationProvider.SetError(textBoxSignUPLastName, "Valid");
validationFlag[1] = true;
}
}
}
/// <summary>
/// Se produit lors du clic sur le bouton d'ajout des informations propres du véhicule
/// </summary>
private void buttonAjouter_Click(object sender, EventArgs e)
{
errorProvider.Clear();
ValidationProvider.Clear();
Vehicule NouveauVehicule = new Vehicule();
NouveauVehicule.SurErreur += NouveauVehicule_SurErreur;
NouveauVehicule.AvantChangement += NouveauVehicule_AvantChangement;
NouveauVehicule.Modele = textBoxModele.Text;
NouveauVehicule.PrixVehicule = double.Parse(numericUpDownPrix.Value.ToString());
NouveauVehicule.TempsLivraison = int.Parse(numericUpDownTempsLivraison.Value.ToString());
NouveauVehicule.TypeVehicule = Program.GMBD.EnumererTypeVehicule(null, null, new PDSGBD.MyDB.CodeSql("WHERE type = {0}", (EstMoto) ? "Moto" : "Voiture"), null).FirstOrDefault();
NouveauVehicule.Disponible = 1;
if (listeDeroulanteVehicule1.VehiculeSelectionne != null)
{
NouveauVehicule.NomImage = (ImageChangee) ? pictureBox1.Tag.ToString() : listeDeroulanteVehicule1.VehiculeSelectionne.NomImage;
}
else
{
NouveauVehicule.NomImage = (ImageChangee) ? pictureBox1.Tag.ToString() : null;
}
if ((NouveauVehicule.EstValide) && (Program.GMBD.AjouterVehicule(NouveauVehicule)))
{
listeDeroulanteVehicule1.Vehicule = Program.GMBD.EnumererVehicule(null, new PDSGBD.MyDB.CodeSql("JOIN type ON vehicule.fk_id_type = type.id_type"), new PDSGBD.MyDB.CodeSql("WHERE type = {0} AND disponible = 1", (EstVoiture) ? "Voiture" : "Moto"), null);
listeDeroulanteVehicule1.VehiculeSelectionne = NouveauVehicule;
if (File.Exists(Environment.GetFolderPath(Environment.SpecialFolder.Desktop).ToString() + "/ImagesVehicule/" + listeDeroulanteVehicule1.VehiculeSelectionne.NomImage + ""))
{
pictureBox1.Image = Image.FromFile(Environment.GetFolderPath(Environment.SpecialFolder.Desktop).ToString() + "/ImagesVehicule/" + listeDeroulanteVehicule1.VehiculeSelectionne.NomImage + "");
}
ImageChangee = false;
ValidationProvider.SetError(buttonAjouter, (EstMoto) ? "Moto correctement sauvegardée" : "Voiture correctement sauvegardée");
}
}
private void buttonDelier_Click(object sender, EventArgs e)
{
if (ficheSubSub1.SubSubSelectionne != null)
{
SubUnity SubUnityLie = Program.GMBD.EnumererSubUnity(null, null, new MyDB.CodeSql(" WHERE ((subunity.su_id IN(SELECT sub_sub.ss_fk_su_id_master FROM sub_sub)) AND (subunity.su_id NOT IN(SELECT char_rank.cr_sub_id FROM char_rank) AND subunity.su_id NOT IN (SELECT stuff_subunity.cfs_fk_subunity_id FROM stuff_subunity))AND (subunity.su_id = {0} OR subunity.su_id = {1}))", ficheSubSub1.SubSubSelectionne.Master.Id, ficheSubSub1.SubSubSelectionne.Slave.Id), null).FirstOrDefault();
if (SubUnityLie == null)
{
PopUpConfirmation FormConfirmation = new PopUpConfirmation();
FormConfirmation.LabelDuTexte = "Êtes vous certain de vouloir supprimer ce \nlien entre ces 2 sous unités ?";
FormConfirmation.ShowDialog();
if (FormConfirmation.Confirmation)
{
if (Program.GMBD.SupprimerSubSub(ficheSubSub1.SubSubSelectionne))
{
ValidationProvider.SetError(buttonDelier, "Votre lien entre les sous unité a bien été supprimée");
ChargerSubSub(listeDeroulanteFaction1.FactionSelectionnee.Id, listeDeroulanteSousFaction1.SousFactionSelectionnee.Id, listeDeroulanteUnity1.UnitySelectionnee.Id);
}
}
else if (FormConfirmation.Annulation)
{
// Ne rien faire
}
}
else
{
errorProviderUnity.SetError(textBoxSousUnity, "Ces sous unité sont déjà utilisées, impossible de la supprimer avant de supprimer les élements attacher");
}
}
}
private void pictureBoxSupprimerEntretien_Click(object sender, EventArgs e)
{
if (listeDeroulanteEntretien.EntretienSelectionne != null)
{
FactureEntretien LienExistant = Program.GMBD.EnumererFactureEntretien(null, new MyDB.CodeSql("JOIN entretien ON facture_entretien.fk_id_entretien = entretien.id_entretien"), new MyDB.CodeSql("WHERE fk_id_entretien = {0}", listeDeroulanteEntretien.EntretienSelectionne.Id), null).FirstOrDefault();
if (LienExistant != null)
{
Entretien EntretienIndisponible = LienExistant.Entretien;
EntretienIndisponible.Disponible = 0;
// Si l'entretien est référencé, suppression fictive afin de garder la trace de celui-ci
if ((EntretienIndisponible.EstValide) && (Program.GMBD.ModifierEntretien(EntretienIndisponible)))
{
ValidationProvider.SetError(pictureBoxSupprimerEntretien, "Entretien correctement supprimé");
entretiens.EntretienSelectionner = null;
listeDeroulanteEntretien.EntretienSelectionne = null;
}
}
// Si l'entretien n'a aucune référence, la suppresion définitive peut être effectuée
else if ((LienExistant == null) && (Program.GMBD.SupprimerEntretien(listeDeroulanteEntretien.EntretienSelectionne)))
{
listeDeroulanteEntretien.Entretien = Program.GMBD.EnumererEntretien(null, null, new MyDB.CodeSql("WHERE disponible = 1"), null);
ValidationProvider.SetError(pictureBoxSupprimerEntretien, "Entretien correctement supprimé");
entretiens.EntretienSelectionner = null;
listeDeroulanteEntretien.EntretienSelectionne = null;
}
}
}
private void buttonSupprimer_Click(object sender, EventArgs e)
{
if (ficheArticle1.ArticleSelectionnee != null)
{
if (ficheArticle1.ArticleSelectionnee.Stock > 0)
{
errorProvider.SetError(buttonSupprimer, "Suppression impossible tant qu'il y a encore du stock pour cet article");
}
else
{
Reparation ArticleReference = Program.GMBD.EnumererReparation(null, null, new PDSGBD.MyDB.CodeSql("WHERE fk_id_article = {0}", ficheArticle1.ArticleSelectionnee.Id), null).FirstOrDefault();
if (ArticleReference != null)
{
// Afin de garder la trace de cet article pour la facture, l'article deviendra indisponible et sera considéré comme supprimé
Article ArticleIndisponible = ficheArticle1.ArticleSelectionnee;
ArticleIndisponible.Disponible = 0;
Program.GMBD.ModifierArticle(ArticleIndisponible);
RefreshPage();
ValidationProvider.SetError(buttonSupprimer, "Article correctement supprimé");
}
else
{
Program.GMBD.SupprimerArticle(ficheArticle1.ArticleSelectionnee);
RefreshPage();
ValidationProvider.SetError(buttonSupprimer, "Article correctement supprimé");
}
}
}
}
private void buttonModifier_Click(object sender, EventArgs e)
{
if (listeDeroulanteClient.ClientSelectionne != null)
{
Client ClientEnEdition = null;
ClientEnEdition = listeDeroulanteClient.ClientSelectionne;
ClientEnEdition.SurErreur += ClientEnEdition_SurErreur;
ClientEnEdition.AvantChangement += ClientEnEdition_AvantChangement;
ClientEnEdition.Nom = textBoxNom.Text;
ClientEnEdition.Prenom = textBoxPrenom.Text;
ClientEnEdition.Email = textBoxEmail.Text;
ClientEnEdition.Civilite = listeDeroulanteCivilite.CiviliteSelectionne;
ClientEnEdition.Adresse = listeDeroulanteLocaliteCP.AdresseSelectionne;
ClientEnEdition.DateNaissance = dateTimePickerDateNaissance.Value;
ClientEnEdition.Rue = textBoxAdresse.Text;
ClientEnEdition.NumeroTelephone = textBoxNumTel.Text;
ClientEnEdition.NumeroHabitation = textBoxNumHabitation.Text;
if ((ClientEnEdition.EstValide) && (Program.GMBD.ModifierClient(ClientEnEdition)))
{
RefreshListeClient();
listeDeroulanteClient.ClientSelectionne = ClientEnEdition;
ValidationProvider.SetError(listeDeroulanteClient, "Vos modifications se sont correctement modifiée");
}
}
else
{
ValidationProvider.Clear();
errorProviderClient.SetError(listeDeroulanteClient, "Veuillez choisir un client existant");
}
}
private void buttonAjouter_Click(object sender, EventArgs e)
{
ValidationProvider.Clear();
errorProvider.Clear();
Employe NouvelEmploye = new Employe();
NouvelEmploye.SurErreur += NouvelEmploye_SurErreur;
NouvelEmploye.AvantChangement += NouvelEmploye_AvantChangement;
NouvelEmploye.ModificationSansMotDePasse = true;
NouvelEmploye.Nom = textBoxNom.Text;
NouvelEmploye.Prenom = TextBoxPrenom.Text;
NouvelEmploye.Email = TextBoxEmail.Text;
NouvelEmploye.Civilite = listeDeroulanteCivilite.CiviliteSelectionne;
NouvelEmploye.Adresse = listeDeroulanteLocaliteCP.AdresseSelectionne;
NouvelEmploye.DateNaissance = dateTimePickerDateNaissance.Value;
NouvelEmploye.Rue = TextBoxNomRue.Text;
NouvelEmploye.NumeroTelephone = TextBoxNumTel.Text;
NouvelEmploye.NumeroHabitation = TextBoxNumHabitation.Text;
NouvelEmploye.MotDePasse = TextBoxMdp.Text;
NouvelEmploye.CompteActif = 1;
NouvelEmploye.Statut = listeDeroulanteStatutEmploye1.StatutEmployeSelectionne;
if ((NouvelEmploye.EstValide) && (Program.GMBD.AjouterEmploye(NouvelEmploye)))
{
RefreshFormulaire();
ValidationProvider.SetError(buttonAjouter, "Employé correctement ajouté");
if (SActiveLorsDunAjoutOuModification != null)
{
SActiveLorsDunAjoutOuModification(this, EventArgs.Empty);
}
}
}
private void buttonSupprimerOptions_Click(object sender, EventArgs e)
{
if (ficheOptionsAjouter.OptionsSelectionnee != null)
{
OptionVehicule OptionASupprimer = ficheOptionsAjouter.OptionsSelectionnee;
OptionASupprimer.Disponible = 0;
if (Program.GMBD.ModifierOptionVehicule(OptionASupprimer))
{
textBoxNomOption.Text = "";
numericUpDownPrixOption.Value = 0;
buttonAjouterO.Enabled = true;
buttonModifierO.Enabled = false;
buttonSupprimerOptions.Enabled = false;
listeDeroulanteTypeOptions1.TypeOptionsSelectionne = null;
ficheOptionsAjouter.Options = Program.GMBD.EnumererOptionVehicule(null, new PDSGBD.MyDB.CodeSql("JOIN type_option ON option_vehicule.fk_id_type_option = type_option.id_type_option"), new PDSGBD.MyDB.CodeSql("WHERE disponible = 1"), null);
ValidationProvider.SetError(buttonSupprimerOptions, "Suppression de l'option correctement effectuée");
#region Requêtes pour les options à choisir
///////////////////////////////
// Requêtes pour les options //
///////////////////////////////
ficheOptionsPackRecherche.Options = Program.GMBD.EnumererOptionVehicule(null, new PDSGBD.MyDB.CodeSql("JOIN type_option ON option_vehicule.fk_id_type_option = type_option.id_type_option"), new PDSGBD.MyDB.CodeSql("WHERE disponible = 1"), null);
#endregion
}
}
}
private void buttonAjouter_Click(object sender, EventArgs e)
{
if (listeDeroulanteClient.ClientSelectionne == null)
{
Client NouveauClient = new Client();
NouveauClient.SurErreur += ClientEnEdition_SurErreur;
NouveauClient.AvantChangement += ClientEnAjout_AvantChangement;
NouveauClient.Nom = textBoxNom.Text;
NouveauClient.Prenom = textBoxPrenom.Text;
NouveauClient.Email = textBoxEmail.Text;
NouveauClient.Civilite = listeDeroulanteCivilite.CiviliteSelectionne;
NouveauClient.Adresse = listeDeroulanteLocaliteCP.AdresseSelectionne;
NouveauClient.DateNaissance = dateTimePickerDateNaissance.Value;
NouveauClient.Rue = textBoxAdresse.Text;
NouveauClient.NumeroTelephone = textBoxNumTel.Text;
NouveauClient.NumeroHabitation = textBoxNumHabitation.Text;
if ((NouveauClient.EstValide) && (Program.GMBD.AjouterClient(NouveauClient)))
{
errorProviderClient.Clear();
RefreshListeClient();
listeDeroulanteClient.ClientSelectionne = NouveauClient;
ValidationProvider.SetError(listeDeroulanteClient, "Client correctement enregistré");
}
}
}
private void pictureBoxAjouterO_Click(object sender, EventArgs e)
{
ValidationProvider.Clear();
errorProvider.Clear();
if (ficheOptionsDisponibles.OptionsSelectionnee != null)
{
VehiculeOptionVehicule NouvelleLiaisonOption = new VehiculeOptionVehicule();
NouvelleLiaisonOption.Vehicule = Vehicule;
NouvelleLiaisonOption.OptionVehicule = ficheOptionsDisponibles.OptionsSelectionnee;
VehiculeOptionVehicule LiaisonExiste = Program.GMBD.EnumererVehiculeOptionVehicule(null, new PDSGBD.MyDB.CodeSql("JOIN option_vehicule ON vehicule_option_vehicule.fk_id_option_vehicule = option_vehicule.id_option_vehicule"), new PDSGBD.MyDB.CodeSql("WHERE vehicule_option_vehicule.fk_id_option_vehicule = {0} AND vehicule_option_vehicule.fk_id_vehicule = {1} AND disponible = 1", ficheOptionsDisponibles.OptionsSelectionnee.Id, Vehicule.Id), null).FirstOrDefault();
if (LiaisonExiste == null)
{
if ((NouvelleLiaisonOption.EstValide) && (Program.GMBD.AjouterVehiculeOptionVehicule(NouvelleLiaisonOption)))
{
RefreshFicheOptionDispo();
RefreshFicheOptionsLiees();
ValidationProvider.SetError(pictureBoxAjouterO, "Option correctement liée à ce véhicule");
}
}
else
{
errorProvider.SetError(pictureBoxAjouterO, "Cette option existe déjà pour ce véhicule");
}
}
else
{
errorProvider.SetError(pictureBoxAjouterO, "Vous devez sélectionner une option dans la liste");
}
}
private void buttonTerminer_Click(object sender, EventArgs e)
{
if (CalendrierRdv.FactureSelectionnee != null)
{
ValidationProvider.Clear();
errorProvider.Clear();
if (numericUpDownH.Value < 1)
{
errorProvider.SetError(numericUpDownH, "La réparation nécessite au minimum une heure de prestation");
}
else
{
if (ficheArticleFacture.NombreDeLigne > 0)
{
RendezVousEntretienReparation RdvEntretienReparation = CalendrierRdv.FactureSelectionnee.RendezVous;
RdvEntretienReparation.Statut = Program.GMBD.EnumererStatut(null, null, new MyDB.CodeSql("WHERE statut = {0}", string.Format("Terminé")), null).FirstOrDefault();
if ((RdvEntretienReparation.EstValide) && (Program.GMBD.ModifierRendezvous(RdvEntretienReparation)))
{
Facture NouvelleFacture = CalendrierRdv.FactureSelectionnee;
NouvelleFacture.HeurePrestation = int.Parse(numericUpDownH.Value.ToString());
double PrixTotal = 0;
foreach (Reparation Reparation in NouvelleFacture.EnumReparation)
{
PrixTotal += Reparation.Article.PrixUnite * Reparation.QuantiteArticle;
}
foreach (FactureEntretien Entretien in NouvelleFacture.EnumFactureEntretien)
{
PrixTotal += Entretien.Entretien.Prix;
}
NouvelleFacture.PrixTotal = PrixTotal;
NouvelleFacture.Commentaire = textBoxConseil.Text;
if ((NouvelleFacture.EstValide) && (Program.GMBD.ModifierFacture(NouvelleFacture)))
{
ClearPage();
CalendrierRdv.ChargerListViewRdv();
ValidationProvider.SetError(buttonTerminer, "Votre facture a été correctement enregsitrée");
}
else
{
RdvEntretienReparation.Statut = Program.GMBD.EnumererStatut(null, null, new MyDB.CodeSql("WHERE statut = {0}", string.Format("En attente")), null).FirstOrDefault();
if (RdvEntretienReparation.EstValide)
{
Program.GMBD.ModifierRendezvous(RdvEntretienReparation);
}
errorProvider.SetError(buttonTerminer, "Votre facture n'a pas été correctement enregistrée");
}
}
else
{
errorProvider.SetError(buttonTerminer, "Erreur interne, veuillez contacter un administrateur");
}
}
else
{
errorProvider.SetError(ficheArticleFacture, "Il vous faut au minimum un article");
}
}
}
}
/// <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>
/// Methode permettant d'agir après le changement de cette faction
/// </summary>
/// <param name="Entite"></param>
/// <param name="Champ"></param>
/// <param name="ValeurPrecedente"></param>
/// <param name="ValeurActuelle"></param>
private void FactionEnEdition_ApresChangement(Faction Entite, Faction.Champ Champ, object ValeurPrecedente, object ValeurActuelle)
{
switch (Champ)
{
case Faction.Champ.Name:
ValidationProvider.SetError(textBoxFaction, "Votre faction a bien été modifiée");
break;
}
buttonAjouter.Enabled = m_FactionEnEdition.EstValide;
}
private void buttonSupprimer_Click(object sender, EventArgs e)
{
errorProvider.Clear();
ValidationProvider.Clear();
if (listeDeroulanteVehicule1.VehiculeSelectionne != null)
{
Vehicule VehiculeReference = Program.GMBD.EnumererVehicule(null, new PDSGBD.MyDB.CodeSql("JOIN type ON vehicule.fk_id_type = type.id_type")
, new PDSGBD.MyDB.CodeSql(@"WHERE (vehicule.id_vehicule IN(SELECT client_vehicule.fk_id_vehicule FROM client_vehicule WHERE fk_id_vehicule = {0})
OR vehicule.id_vehicule IN(SELECT vehicule_vente.fk_id_vehicule FROM vehicule_vente WHERE fk_id_vehicule = {0})) AND id_vehicule = {0}", listeDeroulanteVehicule1.VehiculeSelectionne.Id), null).FirstOrDefault();
// Si le véhicule est référencé au moins une fois dans les tables désignées au dessus on ne supprime que fictivement
if (VehiculeReference != null)
{
VehiculeReference.Disponible = 0;
if ((VehiculeReference.EstValide) && (Program.GMBD.ModifierVehicule(VehiculeReference)))
{
ValidationProvider.SetError(buttonSupprimer, "Ce véhicule a été correctement supprimé");
textBoxModele.Text = "";
numericUpDownPrix.Value = 0;
numericUpDownTempsLivraison.Value = 1;
pictureBox1.Image = null;
listeDeroulanteVehicule1.VehiculeSelectionne = null;
listeDeroulanteVehicule1.Vehicule = Program.GMBD.EnumererVehicule(null, new PDSGBD.MyDB.CodeSql("JOIN type ON vehicule.fk_id_type = type.id_type"), new PDSGBD.MyDB.CodeSql("WHERE disponible = 1 AND type = {0}", (EstMoto) ? "Moto" : "Voiture"), null);
ficheTechnique1.Caracteristique = null;
panelAjouterCaract.BringToFront();
buttonAjouter.Enabled = true;
buttonModifier.Enabled = false;
buttonSupprimer.Enabled = false;
buttonAnnulerModele.Enabled = true;
}
}
// Sinon aucun problème pour une suppression en cascade des packs, options et caractéristiques
else
{
if (Program.GMBD.SupprimerVehicule(listeDeroulanteVehicule1.VehiculeSelectionne))
{
ValidationProvider.SetError(buttonSupprimer, "Ce véhicule a été correctement supprimé");
textBoxModele.Text = "";
numericUpDownPrix.Value = 0;
numericUpDownTempsLivraison.Value = 1;
pictureBox1.Image = null;
listeDeroulanteVehicule1.VehiculeSelectionne = null;
listeDeroulanteVehicule1.Vehicule = Program.GMBD.EnumererVehicule(null, new PDSGBD.MyDB.CodeSql("JOIN type ON vehicule.fk_id_type = type.id_type"), new PDSGBD.MyDB.CodeSql("WHERE disponible = 1 AND type = {0}", (EstMoto) ? "Moto" : "Voiture"), null);
ficheTechnique1.Caracteristique = null;
panelAjouterCaract.BringToFront();
buttonAjouter.Enabled = true;
buttonModifier.Enabled = false;
buttonSupprimer.Enabled = false;
buttonAnnulerModele.Enabled = true;
}
}
}
}
/// <summary>
/// Retire l'élément choisi de la liste des options désirées
/// </summary>
private void pictureBoxRetirerO_Click(object sender, EventArgs e)
{
if (ficheOptionsChoisies.OptionsSelectionnee != null)
{
ValidationProvider.Clear();
errorProvider.Clear();
PrixEstimeApresChoix -= ficheOptionsGeneral.OptionsSelectionnee.Prix;
textBoxPrixTotal.Text = string.Format("{0} €", PrixEstimeApresChoix);
OptionsChoisies.Remove(ficheOptionsChoisies.OptionsSelectionnee);
ficheOptionsChoisies.Options = OptionsChoisies;
ValidationProvider.SetError(pictureBoxRetirerO, "L'option a bien été retirée");
}
}
private void textBoxconfirmpass_Validating(object sender, System.ComponentModel.CancelEventArgs e)
{
bool flagLetter = false;
bool flagDigit = false;
string checkpassword = textBoxSignUpconfirmpass.Text;
if (checkpassword != string.Empty)
{
foreach (char item in checkpassword)
{
if (char.IsLetter(item))
{
flagLetter = true;
}
else if (!char.IsLetter(item))
{
flagLetter = false;
}
else if (char.IsDigit(item))
{
flagDigit = true;
}
else if (!char.IsDigit(item))
{
flagDigit = false;
}
}
if (flagLetter == true)
{
errorProvider.SetError(textBoxSignUpconfirmpass, "Contains Only Letter");
}
else if (flagDigit == true)
{
errorProvider.SetError(textBoxSignUpconfirmpass, "Contains Only Digits");
}
}
else if (checkpassword == string.Empty)
{
errorProvider.SetError(textBoxSignUpconfirmpass, "Empty");
}
else if (checkpassword.Length < 5)
{
errorProvider.SetError(textBoxSignUpconfirmpass, "Must Contain More than 5 characters");
}
if (textBoxSignUpconfirmpass.Text == textBoxSignuppass.Text)
{
ValidationProvider.SetError(textBoxSignUpconfirmpass, "Valid");
confirmPasswordFlag = true;
}
}
private void pictureBoxCaractR_Click(object sender, EventArgs e)
{
if (ficheTechnique1.CaracteristiqueSelectionnee != null)
{
if (Program.GMBD.SupprimerVehiculeCaracteristique(ficheTechnique1.CaracteristiqueSelectionnee))
{
ClearCaract();
errorProvider.Clear();
ValidationProvider.Clear();
ValidationProvider.SetError(pictureBoxCaractR, "La caractéristique a bien été retirée");
RefreshFicheTechnique();
}
}
}
private void buttonAnnulationRendezvous_Click(object sender, EventArgs e)
{
if (CalendrierRdv.FactureSelectionnee != null)
{
RendezVousEntretienReparation RdvEnEdition = CalendrierRdv.FactureSelectionnee.RendezVous;
RdvEnEdition.Statut = Program.GMBD.EnumererStatut(null, null, new MyDB.CodeSql("WHERE statut = \"Annuler\""), null).FirstOrDefault();
if (Program.GMBD.ModifierRendezvous(RdvEnEdition))
{
ValidationProvider.SetError(buttonAnnulationRendezvous, "Le rendez-vous a été annulé");
CalendrierRdv.ChargerListViewRdv();
ClearFormulaire();
}
}
}
/// <summary>
/// Rajoute l'élément choisi à la liste des options désirés
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void pictureBoxAjouterO_Click(object sender, EventArgs e)
{
if (ficheOptionsGeneral.OptionsSelectionnee != null)
{
ValidationProvider.Clear();
errorProvider.Clear();
if (OptionsChoisies != null)
{
if (!ficheOptionsChoisies.Options.Contains(ficheOptionsGeneral.OptionsSelectionnee))
{
OptionVehicule OptionExiste = OptionsChoisies.Find(item => (item.Id == ficheOptionsGeneral.OptionsSelectionnee.Id) || (item.TypeOption.NomType == listeDeroulanteTypeOptions1.TypeOptionsSelectionne.NomType));
if ((OptionExiste == null) || ((ficheOptionsGeneral.OptionsSelectionnee.TypeOption.NomType == "Autres")))
{
bool OptionDispoDansPack = false;
if (PackChoisis.Count > 0)
{
foreach (PackOptionPackVehicule POPV in PackChoisis)
{
foreach (PackOption PO in POPV.EnumPackOption)
{
if (PO.OptionVehicule.Id == ficheOptionsGeneral.OptionsSelectionnee.Id)
{
errorProvider.SetError(pictureBoxAjouterO, "Cette option est déjà disponible avec le pack : " + POPV.NomPack);
OptionDispoDansPack = true;
}
}
}
}
if (OptionDispoDansPack == false)
{
PrixEstimeApresChoix += ficheOptionsGeneral.OptionsSelectionnee.Prix;
textBoxPrixTotal.Text = string.Format("{0} €", PrixEstimeApresChoix);
OptionsChoisies.Add(ficheOptionsGeneral.OptionsSelectionnee);
ficheOptionsChoisies.Options = OptionsChoisies;
ValidationProvider.SetError(pictureBoxAjouterO, "L'option a bien été ajoutée");
}
}
else
{
errorProvider.SetError(pictureBoxAjouterO, "Ce type d'option a déjà été choisi");
}
}
else
{
errorProvider.SetError(pictureBoxAjouterO, "Cette option a déjà été choisie");
}
}
}
}
/// <summary>
/// Retire l'élément choisi de la liste des packs désirés
/// </summary>
private void pictureBoxRetirerP_Click(object sender, EventArgs e)
{
if (fichePackOptionsGeneral.PackOptionsSelectionnee != null)
{
ValidationProvider.Clear();
errorProvider.Clear();
if (PackChoisis.Count > 0)
{
PrixEstimeApresChoix -= fichePackOptionsChoisis.PackOptionsSelectionnee.PrixPack;
textBoxPrixTotal.Text = string.Format("{0} €", PrixEstimeApresChoix);
PackChoisis.Remove(fichePackOptionsGeneral.PackOptionsSelectionnee);
fichePackOptionsChoisis.PackOptions = PackChoisis;
ValidationProvider.SetError(pictureBoxRetirerP, "Le pack a bien été retiré");
}
}
}
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");
}
}
}
