public static void CreerComposant(ComposantModel nouveauComposant)
{
using (GDA_Context context = new GDA_Context())
{
var composant = new Composant
{
Nom = nouveauComposant.Nom,
Abreviation = nouveauComposant.Abreviation,
Version = nouveauComposant.Version,
Description = nouveauComposant.Description,
ComposantTypeId = nouveauComposant.Type.Id,
NomBD = nouveauComposant.NomBD,
SourceControlPath = nouveauComposant.SourceControlPath,
BC = nouveauComposant.BC,
BW = nouveauComposant.BW,
DerniereMAJ = DateTime.Now
};
context.Composants.InsertOnSubmit(composant);
context.SubmitChanges();
nouveauComposant.Id = composant.Id; //Set the newly inserted id
CreerEnvironnements(context, nouveauComposant); //This call has to be made before adding dependencies
ModifierClients(context, nouveauComposant);
ModifierResponsables(context, nouveauComposant);
ModifierTechnologies(context, nouveauComposant);
ModifierDependances(context, nouveauComposant);
}
}
public PageModifierQuantiteComposantDuMedicament(Composant leComposant, Medicament leMedicament, int laQte)
{
InitializeComponent();
ContexteComposant = leComposant;
ContexteMedicament = leMedicament;
ContexteQuantite = laQte;
AfficherLesInformationsNecessaires();
}
public ActionResult DeleteConfirmed(int id)
{
Composant composant = db.Composant.Find(id);
db.Composant.Remove(composant);
db.SaveChanges();
return(RedirectToAction("Index"));
}
private async void LvComposants_ItemSelected(object sender, SelectedItemChangedEventArgs e)
{
if (lvComposants.SelectedItem != null)
{
Composant leComposantSelectionner = (lvComposants.SelectedItem as Composant);
Pages.PageModifierComposant page = new Pages.PageModifierComposant(leComposantSelectionner);
await Navigation.PushModalAsync(page);
}
}
public static ComposantBase ToComposantBaseModel(this Composant composant)
{
return(new ComposantBase
{
Id = composant.Id,
Nom = composant.Nom,
Abreviation = composant.Abreviation,
Version = composant.Version
});
}
public ActionResult Edit([Bind(Include = "ID,Nom")] Composant composant)
{
if (ModelState.IsValid)
{
db.Entry(composant).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(composant));
}
public void Create(Composant item, string user = "")
{
_composantRepository.Insert(item);
_applicationTraceService.create(new ApplicationTrace
{
utilisateur = user,
action = Parametres.Action.Creation.ToString(),
description = String.Format("Création du composant {0} composant_id = {1}", item.libe, item.id)
});
}
public ActionResult Create([Bind(Include = "ID,Nom")] Composant composant)
{
if (ModelState.IsValid)
{
db.Composants.Add(composant);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(composant));
}
public static CSVComposantListeModelCourt ToCSVComposantListeModelCourt(this Composant composant)
{
return(new CSVComposantListeModelCourt
{
Nom = composant.Nom,
Abreviation = composant.Abreviation,
Version = composant.Version,
Description = composant.Description,
DerniereMAJ = composant.DerniereMAJ.ToString()
});
}
private static List <DependanceModel> GetDependanceComposant(Composant composant, int typeDependance)
{
return(composant.ComposantDependances.Where(x => x.DependanceTypeId == typeDependance).Select(x => new DependanceModel
{
Etiquette = new EtiquetteModel {
Id = x.Dependance.Id, Nom = x.Dependance.Nom
},
Type = new EtiquetteModel {
Id = typeDependance, Nom = x.DependanceType.Nom
},
EnvironnementId = x.EnvironnementId
}).ToList());
}
public ActionResult Edit([Bind(Include = "idFormulaire,idQuestion,idTypeReponse")] Composant composant)
{
if (ModelState.IsValid)
{
db.Entry(composant).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.idFormulaire = new SelectList(db.Formulaire, "id", "titre", composant.idFormulaire);
ViewBag.idQuestion = new SelectList(db.Question, "id", "contenu", composant.idQuestion);
ViewBag.idTypeReponse = new SelectList(db.TypeReponse, "id", "type", composant.idTypeReponse);
return(View(composant));
}
private async void LvCompositionMedicament_ItemSelected(object sender, SelectedItemChangedEventArgs e)
{
if (lvCompositionMedicament.SelectedItem != null)
{
Composant leComposantAModifer = new Composant();
leComposantAModifer.IdComposant = (lvCompositionMedicament.SelectedItem as QteComposantParMedicament).IdComposant;
leComposantAModifer.LibelleComposant = (lvCompositionMedicament.SelectedItem as QteComposantParMedicament).LibelleComposant;
int laQuantite = (lvCompositionMedicament.SelectedItem as QteComposantParMedicament).QteComposant;
Pages.PageModifierQuantiteComposantDuMedicament page = new Pages.PageModifierQuantiteComposantDuMedicament(leComposantAModifer, leMedicamentSelectionne, laQuantite);
await Navigation.PushModalAsync(page);
}
}
public ActionResult Edit(ComposantDTO composant)
{
Composant cpst = new Composant();
Personne frnsr = new Personne();
if (composant.id != 0)//update
{
try
{
cpst = _composantService.Get(composant.id);
cpst.libe = composant.libe;
cpst.prixHT = composant.prixHT;
cpst.qteStock = composant.qteStock;
//cpst.fournisseur =
//cpst.gamme = _tmoduleService.Get(composant.gamme.id);
//mdl = Mapper.Map<ModuleDTO, Module>(module);
_composantService.Update(cpst, _donneNomPrenomUtilisateur());
FlashMessage.Confirmation("Composant mis à jour avec succès");
}
catch (Exception e)
{
FlashMessage.Danger("Erreur lors de la mise à jour du composant");
}
}
else
{
try
{
cpst = Mapper.Map <ComposantDTO, Composant>(composant);
//On prépare le fournisseur
cpst.fournisseur = _personneService.Get(composant.fournisseur.id);
//On prépare la gamme
cpst.gamme = _gammeService.Get(composant.gamme.id);
_composantService.Create(cpst, _donneNomPrenomUtilisateur());
FlashMessage.Confirmation("Composant créé avec succès.");
}
catch (Exception e)
{
FlashMessage.Danger("Erreur lors de l'ajout du composant");
}
}
_composantService.Save();
return(RedirectToAction("Index"));
}
public ActionResult Create([Bind(Include = "idFormulaire,idQuestion,idTypeReponse")] Composant composant)
{
if (ModelState.IsValid)
{
db.Composant.Add(composant);
db.SaveChanges();
return(RedirectToAction("Details", "Formulaires", new { id = composant.idFormulaire }));
}
ViewBag.idFormulaire = new SelectList(db.Formulaire, "id", "titre", composant.idFormulaire);
ViewBag.idQuestion = new SelectList(db.Question, "id", "contenu", composant.idQuestion);
ViewBag.idTypeReponse = new SelectList(db.TypeReponse, "id", "type", composant.idTypeReponse);
return(View(composant));
}
// GET: Composants/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Composant composant = db.Composant.Find(id);
if (composant == null)
{
return(HttpNotFound());
}
return(View(composant));
}
public static ComposantModel ToComposantModel(this Composant composant)
{
return(new ComposantModel
{
Id = composant.Id,
Nom = composant.Nom,
Abreviation = composant.Abreviation,
Description = composant.Description,
Version = composant.Version,
Type = new EtiquetteModel {
Id = composant.ComposantType.Id, Nom = composant.ComposantType.Nom
},
Clients = composant.ComposantClients.Select(x => new EtiquetteModel {
Id = x.Client.Id,
Nom = x.Client.Nom
}).ToList(),
Responsables = composant.ComposantResponsables.Select(x => new EtiquetteModel
{
Id = x.Responsable.Id,
Nom = x.Responsable.Nom
}).ToList(),
NomBD = composant.NomBD,
SourceControlPath = composant.SourceControlPath,
BC = composant.BC,
BW = composant.BW,
DerniereMAJ = composant.DerniereMAJ,
Technologies = composant.ComposantTechnologies.Select(x => new EtiquetteModel
{
Id = x.Technologie.Id,
Nom = x.Technologie.Nom
}).ToList(),
Environnements = composant.ComposantEnvironnements.OrderBy(x => x.Ordre).Select(x => new EnvironnementModel
{
Etiquette = new EtiquetteModel {
Id = x.Environnement.Id, Nom = x.Environnement.Nom
},
Ordre = x.Environnement.Ordre
}).ToList(),
Dependances = new DependanceModelListe
{
Web = GetDependanceComposant(composant, Constantes.DEPENDANCE_WEB),
BDs = GetDependanceComposant(composant, Constantes.DEPENDANCE_BD),
Interfaces = GetDependanceComposant(composant, Constantes.DEPENDANCE_INTERFACE),
Rapports = GetDependanceComposant(composant, Constantes.DEPENDANCE_RAPPORT),
Externes = GetDependanceComposant(composant, Constantes.DEPENDANCE_EXTERNE),
Jobs = GetDependanceComposant(composant, Constantes.DEPENDANCE_JOB)
}
});
}
public Composant GetById(int id)
{
Composant dto = new Composant();
using (var db = new maderaEntities())
{
var query = from a in db.COMPOSANT where a.COMPOSANT_ID.Equals(id) select a;
dto.Id = query.First().COMPOSANT_ID;
dto.Nom = query.First().COMPOSANT_NOM;
dto.Stock = query.First().COMPOSANT_STOCK;
dto.ValeurCaracteristique1 = query.First().COMPOSANT_VALEUR_CARACTERISTIQUE_1;
dto.ValeurCaracteristique2 = query.First().COMPOSANT_VALEUR_CARACTERISTIQUE_2;
dto.ValeurAjoutee = query.First().VALEUR_AJOUTEE;
}
return(dto);
}
static void Main()
{
/// Jeu d'essai
Client C1 = new Client("Riri");
Client C2 = new Client("Fifi");
Client C3 = new Client("Loulou");
Commande CO1 = new Commande(DateTime.Now, C1);
Commande CO2 = new Commande(DateTime.Now, C1);
Commande CO3 = new Commande(DateTime.Now, C1);
Commande CO4 = new Commande(DateTime.Now, C3);
Pizza P1 = new Pizza("Calzone", 8.9);
Pizza P2 = new Pizza("Reine", 7.9);
Pizza P3 = new Pizza("4 fromages", 9.9);
Pizza P4 = new Pizza("margharita", 10.9);
Pizza P5 = new Pizza("Peperoni", 11.9);
Composant CP1 = new Composant("composant 1", 100, 8.9);
Composant CP2 = new Composant("composant 2", 100, 8.9);
Composant CP3 = new Composant("composant 3", 100, 8.9);
P1.LesComposants.Add(CP1);
P1.LesComposants.Add(CP2);
P1.LesComposants.Add(CP2);
CO1.LesPizzas.Add(P1, 1);
CO1.LesPizzas.Add(P3, 1);
CO2.LesPizzas.Add(P2, 1);
CO2.LesPizzas.Add(P4, 2);
CO2.LesPizzas.Add(P5, 1);
CO3.LesPizzas.Add(P1, 3);
CO4.LesPizzas.Add(P2, 1);
CO4.LesPizzas.Add(P3, 2);
CO4.LesPizzas.Add(P4, 1);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
// GET: Composants/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Composant composant = db.Composant.Find(id);
if (composant == null)
{
return(HttpNotFound());
}
ViewBag.idFormulaire = new SelectList(db.Formulaire, "id", "titre", composant.idFormulaire);
ViewBag.idQuestion = new SelectList(db.Question, "id", "contenu", composant.idQuestion);
ViewBag.idTypeReponse = new SelectList(db.TypeReponse, "id", "type", composant.idTypeReponse);
return(View(composant));
}
public void Add(Composant composant)
{
COMPOSANT entity = new COMPOSANT();
entity.COMPOSANT_ID = composant.Id;
entity.COMPOSANT_NOM = composant.Nom;
entity.COMPOSANT_STOCK = composant.Stock;
entity.COMPOSANT_VALEUR_CARACTERISTIQUE_1 = composant.ValeurCaracteristique1;
entity.COMPOSANT_VALEUR_CARACTERISTIQUE_2 = composant.ValeurCaracteristique2;
entity.VALEUR_AJOUTEE = composant.ValeurAjoutee;
using (var db = new maderaEntities())
{
db.COMPOSANT.Add(entity);
db.SaveChanges();
}
}
// GET: Composants
public ActionResult Index()
{
// get projects and get composants for each project
List <Task> projects = db.Tasks.Where(t => t.ParentId == null).ToList();
List <Composant> composants = new List <Composant>();
foreach (var project in projects)
{
var projectComposants = db.Tasks.Where(t => t.ParentId == project.Id).ToList();
foreach (var comp in projectComposants)
{
var composant = new Composant(comp);
composant.Projet = project.Text;
composants.Add(composant);
}
}
return(View(composants));
}
public LigneCommande GetLastByComposant(Composant composant)
{
LigneCommande dto = new LigneCommande();
using (var db = new maderaEntities())
{
var query = (from a in db.LIGNE_COMMANDE
where a.COMPOSANT_ID.Equals(composant.Id)
orderby a.COMMANDE_ID descending
select a).Take(1);
dto.Id = query.First().COMMANDE_ID;
dto.PrixAchat = query.First().PRIX_ACHAT;
dto.Quantite = query.First().QUANTITE_LIGNE_COMMANDE;
// TODO: Fournisseur
}
return(dto);
}
public static CSVComposantListeModelLong ToCSVComposantListeModelLong(this Composant composant)
{
return(new CSVComposantListeModelLong
{
Nom = composant.Nom,
Abreviation = composant.Abreviation,
Version = composant.Version,
Description = composant.Description,
NomBD = composant.NomBD,
SourceControlPath = composant.SourceControlPath,
DerniereMAJ = composant.DerniereMAJ.ToString(),
Type = composant.ComposantType.Nom,
BC = composant.BC,
BW = composant.BW,
Clients = string.Join(", ", composant.ComposantClients.Select(x => x.Client.Nom).ToArray()),
EnvironnementsProductionWeb = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_WEB, Constantes.ENVIRONNEMENT_PRODUCTION),
EnvironnementsProductionBDs = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_BD, Constantes.ENVIRONNEMENT_PRODUCTION),
EnvironnementsProductionRapports = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_RAPPORT, Constantes.ENVIRONNEMENT_PRODUCTION),
EnvironnementsProductionInterfaces = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_INTERFACE, Constantes.ENVIRONNEMENT_PRODUCTION),
EnvironnementsProductionJobs = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_JOB, Constantes.ENVIRONNEMENT_PRODUCTION),
EnvironnementsProductionExternes = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_EXTERNE, Constantes.ENVIRONNEMENT_PRODUCTION),
EnvironnementsDeveloppementWeb = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_WEB, Constantes.ENVIRONNEMENT_DEVELOPPEMENT),
EnvironnementsDeveloppementBDs = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_BD, Constantes.ENVIRONNEMENT_DEVELOPPEMENT),
EnvironnementsDeveloppementRapports = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_RAPPORT, Constantes.ENVIRONNEMENT_DEVELOPPEMENT),
EnvironnementsDeveloppementInterfaces = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_INTERFACE, Constantes.ENVIRONNEMENT_DEVELOPPEMENT),
EnvironnementsDeveloppementJobs = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_JOB, Constantes.ENVIRONNEMENT_DEVELOPPEMENT),
EnvironnementsDeveloppementExternes = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_EXTERNE, Constantes.ENVIRONNEMENT_DEVELOPPEMENT),
EnvironnementsQAWeb = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_WEB, Constantes.ENVIRONNEMENT_QA),
EnvironnementsQABDs = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_BD, Constantes.ENVIRONNEMENT_QA),
EnvironnementsQARapports = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_RAPPORT, Constantes.ENVIRONNEMENT_QA),
EnvironnementsQAInterfaces = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_INTERFACE, Constantes.ENVIRONNEMENT_QA),
EnvironnementsQAJobs = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_JOB, Constantes.ENVIRONNEMENT_QA),
EnvironnementsQAExternes = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_EXTERNE, Constantes.ENVIRONNEMENT_QA),
EnvironnementsPreProductiontWeb = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_WEB, Constantes.ENVIRONNEMENT_PREPRODUCTION),
EnvironnementsPreProductiontBDs = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_BD, Constantes.ENVIRONNEMENT_PREPRODUCTION),
EnvironnementsPreProductiontRapports = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_RAPPORT, Constantes.ENVIRONNEMENT_PREPRODUCTION),
EnvironnementsPreProductiontInterfaces = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_INTERFACE, Constantes.ENVIRONNEMENT_PREPRODUCTION),
EnvironnementsPreProductiontJobs = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_JOB, Constantes.ENVIRONNEMENT_PREPRODUCTION),
EnvironnementsPreProductiontExternes = GetDependanceEnvironnementComposant(composant, Constantes.DEPENDANCE_EXTERNE, Constantes.ENVIRONNEMENT_PREPRODUCTION),
Responsables = string.Join(", ", composant.ComposantResponsables.Select(x => x.Responsable.Nom).ToArray()),
Technologies = string.Join(", ", composant.ComposantTechnologies.Select(x => x.Technologie.Nom).ToArray()),
});
}
// GET: Composants/Create
public ActionResult Create(int?idFormulaire)
{
ViewBag.idFormulaire = new SelectList(db.Formulaire, "id", "titre");
ViewBag.idQuestion = new SelectList(db.Question, "id", "contenu");
ViewBag.idTypeReponse = new SelectList(db.TypeReponse, "id", "type");
if (idFormulaire == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Composant composant = new Composant {
idFormulaire = (int)idFormulaire
};
if (composant == null)
{
return(HttpNotFound());
}
return(View(composant));
}
public static ComposantListeModel ToComposantListeModel(this Composant composant)
{
return(new ComposantListeModel
{
Id = composant.Id,
Nom = composant.Nom,
Abreviation = composant.Abreviation,
Description = composant.Description,
Version = composant.Version,
Technologies = composant.ComposantTechnologies.Select(comp => new EtiquetteModel
{
Id = comp.Technologie.Id,
Nom = comp.Technologie.Nom
}).ToList(),
Dependances = composant.ComposantDependances.DistinctBy(x => x.DependanceId).Select(comp => new EtiquetteModel
{
Id = comp.Dependance.Id,
Nom = comp.Dependance.Nom
}).ToList()
});
}
public Info AjouterCorps(Body2 body)
{
String Base = null;
String Materiau = body.eGetMateriau(Composant.eNomConfiguration(), out Base);
Boolean Herite = false;
if (String.IsNullOrWhiteSpace(Materiau))
{
Base = Info.Base;
Materiau = Info.Materiau;
Herite = true;
}
Info infoMat = new Info(Materiau, Base, body.eVolume(), Herite);
if (_DicClasse.ContainsKey(infoMat.Classe))
{
Dictionary <String, Info> _DcMateriaux = _DicClasse[infoMat.Classe];
if (_DcMateriaux.ContainsKey(infoMat.Key))
{
_DcMateriaux[infoMat.Key].Ajouter(infoMat);
}
else
{
_DcMateriaux.Add(infoMat.Key, infoMat);
}
}
else
{
Dictionary <String, Info> _DcMateriaux = new Dictionary <String, Info>();
_DcMateriaux.Add(infoMat.Key, infoMat);
_DicClasse.Add(infoMat.Classe, _DcMateriaux);
}
Masse += infoMat.Masse;
return(infoMat);
}
public void AfficherLesInformations(Composant unComposant)
{
txtIdComposant.Text = unComposant.IdComposant.ToString();
txtLibelleComposant.Text = unComposant.LibelleComposant;
}
public Body2 GetCorps()
{
return(Composant.eChercherCorps(Corps.Name, false));
}
public ActionResult DetailComposant(int id, int idComposant)
{
CardComposantViewModel modelOut = new CardComposantViewModel();
try
{
Module mdl = new Module();
mdl = _moduleService.Get(id);
Composant cpst = new Composant();
cpst = _composantService.Get(idComposant);
Composition cpstion = new Composition();
cpstion.composant = cpst;
cpstion.module = mdl;
mdl.compositions.Add(cpstion);
decimal prixAvecTaux = Convert.ToDecimal(cpst.prixHT * (1 + (cpst.gamme.pourcentageGamme / 100)));
decimal prixtotal = Decimal.Add(mdl.prix, prixAvecTaux);
mdl.prix = prixtotal;
_moduleService.Update(mdl, _donneNomPrenomUtilisateur());
_moduleService.Save();
//On reconstruit le tableau récapitulant les composants de l'employé
modelOut.tableauComposant.avecActionCrud = false;
modelOut.tableauComposant.lesLignes.Add(new List <object> {
"Composant", "Prix fournisseur", "Prix de vente", "Gamme", ""
});
List <Composition> composition1 = new List <Composition>();
composition1 = _compositionService.DonneTousComposants(id);
if (composition1.Count != 0)
{
foreach (Composition cpst1 in composition1)
{
modelOut.tableauComposant.lesLignes.Add(new List <object> {
cpst1.composant.libe, cpst1.composant.prixHT.ToString(), (cpst1.composant.prixHT * (1 + (cpst1.composant.gamme.pourcentageGamme / 100))).ToString(), cpst1.composant.gamme.libe, cpst1.id
});
}
}
modelOut.lesComposants = _donneListeComposants();
FlashMessage.Confirmation("Composant mis à jour avec succès");
}
catch (Exception e)
{
FlashMessage.Danger("Erreur lors de la mise à jour du composant");
return(PartialView("~/Areas/RechercheDeveloppement/Views/Module/_CardComposantPartial.cshtml", modelOut));
}
//List<Composition> composition = new List<Composition>();
//composition = _compositionService.DonneTousComposants(id);
//modelOut.lesTypesEmployes = _donneListeTypeEmploye();
//modelOut.tableauComposant.lesLignes.Add(new List<object> { , module.typeModule.libe, module.prix.ToString(), module.id });
return(PartialView("~/Areas/RechercheDeveloppement/Views/Module/_CardComposantPartial.cshtml", modelOut));
}
private static string GetDependanceEnvironnementComposant(Composant composant, int typeDependance, int environnementID)
{
return(string.Join(", ", composant.ComposantDependances
.Where(x => x.DependanceTypeId == typeDependance && x.EnvironnementId == environnementID)
.Select(x => x.Dependance.Nom).ToArray()));
}
