void ExtraitIndicateur(XElement element)
{
foreach (XElement childElement in element.Elements())
{
if (childElement.Name == "Indicateur")
{
Indicateur p = new Indicateur();
foreach (XElement xl in childElement.Elements())
{
switch (xl.Name.ToString())
{
case "ID":
{ p.ID = int.Parse(xl.Value.ToString()); break; }
case "Libelle":
{ p.Libelle = xl.Value.ToString(); break; }
case "Code":
{ p.Code = xl.Value.ToString(); break; }
case "Actif":
{ p.Actif = bool.Parse(xl.Value.ToString()); break; }
case "TypeIndicateur":
{ p.TypeIndicateur = (TypeIndicateur)int.Parse(xl.Value.ToString()); break; }
}
}
if (!Acces.Existe_Element(Acces.type_INDICATEUR, "CODE", p.Code))
{
Acces.Ajouter_Element(Acces.type_INDICATEUR, p);
}
}
}
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
Indicateur indicateur = await db.Indicateurs.FindAsync(id);
db.Indicateurs.Remove(indicateur);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public IActionResult Post([FromBody] Indicateur indicateur)
{
using (var scope = new TransactionScope())
{
_indicateurRepository.InsertIndicateur(indicateur);
scope.Complete();
return(CreatedAtAction(nameof(Get), new { id = indicateur.Id }, indicateur));
}
}
void AjouterSousIndicateur()
{
if (lstIndicateur.SelectedNode is null)
{
MessageBox.Show("Choix d'un indicateur"); return;
}
Indicateur indParent = (Indicateur)Acces.Trouver_Element(Acces.type_INDICATEUR.id, int.Parse(lstIndicateur.SelectedNode.Name.ToString()));
if (!(indParent.TypeIndicateur == TypeIndicateur.DOSSIER))
{
MessageBox.Show("Impossible de créer un indicateur sous un indicateur autre qu'un type DOSSIER", "Erreur", MessageBoxButtons.OK);
return;
}
var f = new frmIndicateur();
f.Acces = Acces;
f.Creation = true;
f.indicateur = new PATIO.Classes.Indicateur();
f.indicateur.Actif = true;
f.indicateur.Code = indParent.Code;
f.Initialise();
if (f.ShowDialog(this) == DialogResult.OK)
{
if (!(lstIndicateur.SelectedNode is null))
{
//Création du lien avec le parent
Lien l = new Lien()
{
element0_type = Acces.type_PLAN.id,
element0_id = 1,
element0_code = "SYSTEME",
element1_type = Acces.type_INDICATEUR.id,
element2_type = Acces.type_INDICATEUR.id,
element1_id = int.Parse(lstIndicateur.SelectedNode.Name),
element1_code = ((Indicateur)Acces.Trouver_Element(Acces.type_INDICATEUR.id, int.Parse(lstIndicateur.SelectedNode.Name))).Code,
element2_id = f.indicateur.ID,
element2_code = ((Indicateur)Acces.Trouver_Element(Acces.type_INDICATEUR.id, f.indicateur.ID)).Code,
ordre = 1,
Acces = Acces,
};
l.Ajouter();
Acces.Ajouter_Lien(l);
}
Afficher_ListeIndicateur();
TreeNode[] Nod = lstIndicateur.Nodes.Find(f.indicateur.ID.ToString(), true);
if (Nod.Length > 0)
{
lstIndicateur.SelectedNode = Nod[0].Parent; Nod[0].EnsureVisible();
}
}
}
public async Task <ActionResult> Edit([Bind(Include = "IdIndicateur,Libelle,Valeur,DateEvaluation")] Indicateur indicateur)
{
if (ModelState.IsValid)
{
db.Entry(indicateur).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(indicateur));
}
public IActionResult Put([FromBody] Indicateur Model)
{
if (Model != null)
{
using (var scope = new TransactionScope())
{
_indicateurRepository.UpdateIndicateur(Model);
scope.Complete();
return(new OkResult());
}
}
return(new NoContentResult());
}
// GET: Indicateurs/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Indicateur indicateur = await db.Indicateurs.FindAsync(id);
if (indicateur == null)
{
return(HttpNotFound());
}
return(View(indicateur));
}
public void InsertMesure(Mesure Mesure)
{
if (Mesure != null)
{
Indicateur indicateur = _dbContext.Indicateurs.Where(A => A.Id == Mesure.IndicateurId).FirstOrDefault();
//Calcul de valeur de mesure par l'indictateur.
string expression = indicateur.Methode;
string exp = expression.Replace("A", Mesure.Valeur1.ToString()).Replace("B", Mesure.Valeur2.ToString());
DataTable dt = new DataTable();
long v = (long)Convert.ToInt64(dt.Compute(exp, string.Empty));
Mesure.Resultat = v;
indicateur.Mesures.Add(Mesure);
Save();
}
}
public async Task <ActionResult> Create([Bind(Include = "IdIndicateur,Libelle,Valeur,DateEvaluation,IdModule")] IndicateurView indicateur)
{
if (ModelState.IsValid)
{
Indicateur indic = new Indicateur();
Module m = new Module();
Module modeleSelectionne = db.Modules.SingleOrDefault(x => x.id == indicateur.IdModule);
indic.Libelle = indicateur.Libelle; indic.Module = modeleSelectionne; indic.DateEvaluation = indicateur.DateEvaluation; indic.Valeur = indicateur.Valeur;
db.Indicateurs.Add(indic);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(indicateur));
}
/// <summary>
/// Edition de la fiche pour un indicateur
/// </summary>
public string Editer_Fiche_Indicateur()
{
//Création de l'application Excel
app = new Microsoft.Office.Interop.Excel.Application();
app.DisplayAlerts = false;
Indicateur indic = (Indicateur)Acces.Trouver_Element(Acces.type_INDICATEUR, id_element);
var modele = Chemin + "\\Modeles\\Fiche_INDICATEUR.xltx";
var fichier = Chemin + "\\Fichiers\\" + "FI-" + indic.Code;
app.Workbooks.Open(modele);
Workbooks wk = app.Workbooks;
Workbook wb = app.ActiveWorkbook;
Worksheet ws = wb.Sheets[1];
Range r;
r = ws.Cells[2, 2];
r.Value = indic.Code;
r = ws.Cells[3, 2];
r.Value = indic.Libelle;
r = ws.Cells[4, 2];
//if (indic.Pilote != null) { r.Value = indic.Pilote.Nom + " " + indic.Pilote.Prenom; }
r = ws.Cells[6, 2];
//r.Value = Conversion(indic.Description);
//Sauvegarde du fichier
wb.SaveAs(fichier + ".xlsx");
wb.ExportAsFixedFormat(Microsoft.Office.Interop.Excel.XlFixedFormatType.xlTypePDF, fichier + ".pdf");
wb.Close(false);
wk.Close();
//Fermeture de l'application Excel
app.Quit();
app = null;
if (OuvertureAuto)
{
OuvertureFichier(fichier + ".pdf");
}
return(fichier);
}
public void UpdateIndicateur(Indicateur Indicateur)
{
_dbContext.Entry(Indicateur).State = EntityState.Modified;
Save();
}
public void InsertIndicateur(Indicateur Indicateur)
{
_dbContext.Objectifs.Where(A => A.Id == Indicateur.ObjectifId).FirstOrDefault().Indicateurs.Add(Indicateur);
Save();
}
private void lstIndicateur_AfterSelect(object sender, TreeViewEventArgs e)
{
int id = int.Parse(lstIndicateur.SelectedNode.Name);
indicateur = (Indicateur)Acces.Trouver_Element(Acces.type_INDICATEUR.id, id);
}
protected override Task HandleRequirementAsync(AuthorizationHandlerContext context,
SameUserRequirement requirement,
object resource)
{
if (resource.GetType() == typeof(Projet))
{
Projet model = (Projet)resource;
Projet Projet = _projetRepository.GetProjetByID(model.Id);
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Projet.UserId)
{
context.Succeed(requirement);
}
}
else if (resource.GetType() == typeof(Document))
{
Document d = (Document)resource;
Document document = _documentRepository.GetDocumentByID(d.Id);
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == document.Projet.UserId)
{
context.Succeed(requirement);
}
}
else if (resource.GetType() == typeof(Phase))
{
Phase model = (Phase)resource;
Phase Phase = _phaseRepository.GetPhaseByID(model.Id);
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Phase.Projet.UserId)
{
context.Succeed(requirement);
}
}
else if (resource.GetType() == typeof(Models.Action))
{
Models.Action model = (Models.Action)resource;
Models.Action Action = _actionRepository.GetActionByID(model.Id);
if (Action.ProjetId != null)
{
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Action.Projet.UserId)
{
context.Succeed(requirement);
}
}
else
{
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Action.Phase.Projet.UserId)
{
context.Succeed(requirement);
}
}
}
else if (resource.GetType() == typeof(Tache))
{
Tache model = (Tache)resource;
Tache Tache = _tacheRepository.GetTacheByID(model.Id);
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Tache.Action.Projet.UserId)
{
context.Succeed(requirement);
}
}
else if (resource.GetType() == typeof(Reunion))
{
Reunion model = (Reunion)resource;
Reunion Reunion = _reunionRepository.GetReunionByID(model.Id);
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Reunion.Projet.UserId)
{
context.Succeed(requirement);
}
}
else if (resource.GetType() == typeof(Objectif))
{
Objectif model = (Objectif)resource;
Objectif Objectif = _objectifRepository.GetObjectifByID(model.Id);
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Objectif.Projet.UserId)
{
context.Succeed(requirement);
}
}
else if (resource.GetType() == typeof(Risque))
{
Risque model = (Risque)resource;
Risque Risque = _risqueRepository.GetRisqueByID(model.Id);
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Risque.Projet.UserId)
{
context.Succeed(requirement);
}
}
else if (resource.GetType() == typeof(Opportunite))
{
Opportunite model = (Opportunite)resource;
Opportunite Opportunite = _opportuniteRepository.GetOpportuniteByID(model.Id);
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Opportunite.Projet.UserId)
{
context.Succeed(requirement);
}
}
else if (resource.GetType() == typeof(Indicateur))
{
Indicateur model = (Indicateur)resource;
Indicateur Indicateur = _indicateurRepository.GetIndicateurByID(model.Id);
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Indicateur.Objectif.Projet.UserId)
{
context.Succeed(requirement);
}
}
else if (resource.GetType() == typeof(Mesure))
{
Mesure model = (Mesure)resource;
Mesure Mesure = _mesureRepository.GetMesureByID(model.Id);
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Mesure.Indicateur.Objectif.Projet.UserId)
{
context.Succeed(requirement);
}
}
else if (resource.GetType() == typeof(Evaluation))
{
Evaluation model = (Evaluation)resource;
Evaluation Evaluation = _evaluationRepository.GetEvaluationByID(model.Id);
if (Evaluation.OpportuniteId != null)
{
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Evaluation.Opportunite.Projet.UserId)
{
context.Succeed(requirement);
}
}
else
{
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Evaluation.Risque.Projet.UserId)
{
context.Succeed(requirement);
}
}
}
return(Task.CompletedTask);
}
/// <summary>
/// Repositionne les éléments selon la hiérarchie définie
/// </summary>
void CreeStructure()
{
int nbObjectif = 0; int nbAction = 0; int nbOpération = 0; int nbIndicateur = 0;
//Affichage de la structure actuelle du plan d'actions
tree.Nodes.Clear();
TreeNode NodG = new TreeNode()
{
Text = "Plan d'actions de " + plan.NiveauPlan,
Name = Acces.type_PLAN.code + "-" + plan.ID,
ImageIndex = 1,
Tag = Acces.type_PLAN.id,
};
NodG.Expand();
n = 1;
//Placement des objectifs/sous-objectifs
List <Lien> listeLien = Acces.Remplir_ListeLien(Acces.type_PLAN, plan.ID.ToString());
listeLien.Sort();
//On balaye la liste des éléments
//On crée l'élément sous le parent
foreach (var p in listeLien)
{
//Recherche du parent
string Parent = Acces.Trouver_TableValeur(p.element1_type).Code + "-" + p.element1_id.ToString();
TreeNode NodParent = NodG;
if (!(Parent == NodG.Name))
{
TreeNode[] NodP = NodG.Nodes.Find(Parent, true);
if (NodP.Length > 0)
{
NodParent = NodP[0];
}
}
string Enfant = Acces.Trouver_TableValeur(p.element2_type).Code + "-" + p.element2_id.ToString();
if (!(Enfant is null))
{
Boolean Ajoute = true;
//Création de l'élément enfant
TreeNode NodEnfant = new TreeNode()
{
Name = Enfant,
Tag = p,
};
if (p.element2_type == Acces.type_OBJECTIF.id)
//if (p.element2_type == Acces.Trouver_TableValeur_ID("TYPE_ELEMENT", p.element1_type.ToString()))
{
Objectif q = (Objectif)Acces.Trouver_Element(Acces.type_OBJECTIF.id, p.element2_id);
if (!(q is null))
{
NodEnfant.Text = q.Libelle;
NodEnfant.Name = Acces.type_OBJECTIF.code + "-" + q.ID;
//NodEnfant.ImageIndex = Donner_ImageIndex(Acces.type_OBJECTIF.id, p.element2_id);
NodEnfant.ToolTipText = q.Code;
nbObjectif++;
}
else
{
Console.Ajouter("[Objectif non trouvé] ID:" + p.element2_id + " Code :" + p.element2_code);
}
}
if (p.element2_type == Acces.type_ACTION.id)
{
PATIO.Classes.Action q = (PATIO.Classes.Action)Acces.Trouver_Element(Acces.type_ACTION.id, p.element2_id);
if (!optOpération.Checked)
{
Ajoute = (q.TypeAction == TypeAction.ACTION);
}
if (!(q is null))
{
NodEnfant.Text = q.Libelle;
NodEnfant.Name = Acces.type_ACTION.code + "-" + q.ID;
//NodEnfant.ImageIndex = Donner_ImageIndex(Acces.type_ACTION.id, p.element2_id);
//if (q.ActionPhare) { NodEnfant.ImageIndex = imgs[PosImageActionPhare].Id; }
NodEnfant.ToolTipText = q.Code + " [" + p.ordre + "]";
if (q.TypeAction == TypeAction.ACTION)
{
nbAction++;
}
if (q.TypeAction == TypeAction.OPERATION)
{
nbOpération++;
}
}
else
{
Console.Ajouter("[Action non trouvée] ID:" + p.element2_id + " CODE:" + p.element2_code);
}
}
if (p.element2_type == Acces.type_INDICATEUR.id)
{
Ajoute = optIndicateur.Checked;
Indicateur q = (Indicateur)Acces.Trouver_Element(Acces.type_INDICATEUR.id, p.element2_id);
if (!(q is null))
{
NodEnfant.Text = q.Libelle;
NodEnfant.Name = Acces.type_INDICATEUR.code + "-" + q.ID;
//NodEnfant.ImageIndex = Donner_ImageIndex(Acces.type_INDICATEUR.id, p.element2_id);
NodEnfant.ToolTipText = q.Code;
nbIndicateur++;
}
else
{
Console.Ajouter("[Indicateur non trouvée] ID:" + p.element2_id + " CODE:" + p.element2_code);
}
}
public Indicateur Add(Indicateur i)
{
bdc.Indicateurs.Add(i);
bdc.SaveChanges();
return(i);
}
/// <summary>
/// Repositionne les éléments selon la hiérarchie définie
/// </summary>
void Repositionner(Plan plan)
{
int nbObjectif = 0; int nbAction = 0; int nbOpération = 0; int nbIndicateur = 0;
//Placement des objectifs/sous-objectifs
listeLien = Acces.Remplir_ListeLien_Niv0(Acces.type_PLAN, plan.ID.ToString());
listeLien.Sort();
//On balaye la liste des éléments
//On crée l'élément sous le parent
foreach (var p in listeLien)
{
//Recherche du parent
string Parent = Acces.Trouver_TableValeur(p.Element1_Type).Code + "-" + p.Element1_ID.ToString();
TreeNode NodParent = NodG;
if (!(Parent == NodG.Name))
{
TreeNode[] NodP = NodG.Nodes.Find(Parent, true);
if (NodP.Length > 0)
{
NodParent = NodP[0];
}
}
string Enfant = Acces.Trouver_TableValeur(p.Element2_Type).Code + "-" + p.Element2_ID.ToString();
if (!(Enfant is null))
{
Boolean Ajoute = true;
//Création de l'élément enfant
TreeNode NodEnfant = new TreeNode()
{
Name = Enfant,
Tag = p,
};
if (p.Element2_Type == Acces.type_OBJECTIF.ID)
//if (p.Element2_Type == Acces.Trouver_TableValeur_ID("TYPE_ELEMENT", p.Element1_Type.ToString()))
{
Objectif q = (Objectif)Acces.Trouver_Element(Acces.type_OBJECTIF, p.Element2_ID);
if (!(q is null))
{
NodEnfant.Text = q.Libelle;
NodEnfant.Name = Acces.type_OBJECTIF.Code + "-" + q.ID;
NodEnfant.ImageIndex = Donner_ImageIndex(Acces.type_OBJECTIF, p.Element2_ID);
NodEnfant.ToolTipText = q.Code;
nbObjectif++;
}
else
{
Console.Ajouter("[Objectif non trouvé] ID:" + p.Element2_ID + " Code :" + p.Element2_Code);
}
}
if (p.Element2_Type == Acces.type_ACTION.ID)
{
PATIO.CAPA.Classes.Action q = (PATIO.CAPA.Classes.Action)Acces.Trouver_Element(Acces.type_ACTION, p.Element2_ID);
if (!(q is null))
{
NodEnfant.Text = q.Libelle;
NodEnfant.Name = Acces.type_ACTION.Code + "-" + q.ID;
NodEnfant.ImageIndex = Donner_ImageIndex(Acces.type_ACTION, p.Element2_ID);
if (q.ActionPhare)
{
NodEnfant.ImageIndex = imgs[PosImageActionPhare].Id;
}
NodEnfant.ToolTipText = q.Code + " [" + p.ordre + "]";
if (q.TypeAction == TypeAction.ACTION)
{
nbAction++;
}
if (q.TypeAction == TypeAction.OPERATION)
{
nbOpération++;
}
}
else
{
Console.Ajouter("[Action non trouvée] ID:" + p.Element2_ID + " CODE:" + p.Element2_Code);
}
}
if (p.Element2_Type == Acces.type_INDICATEUR.ID)
{
Indicateur q = (Indicateur)Acces.Trouver_Element(Acces.type_INDICATEUR, p.Element2_ID);
if (!(q is null))
{
NodEnfant.Text = q.Libelle;
NodEnfant.Name = Acces.type_INDICATEUR.Code + "-" + q.ID;
NodEnfant.ImageIndex = Donner_ImageIndex(Acces.type_INDICATEUR, p.Element2_ID);
NodEnfant.ToolTipText = q.Code;
nbIndicateur++;
}
else
{
Console.Ajouter("[Indicateur non trouvée] ID:" + p.Element2_ID + " CODE:" + p.Element2_Code);
}
}
//Extraction d'une page Indicateur
void Extraction_Indicateur(string Code)
{
string repert = Chemin + "//Import//Indicateur//";
if (!(Directory.Exists(repert)))
{
Directory.CreateDirectory(repert);
}
string Fichier = repert + Code + ".xml";
//Test le mode d'extraction
if (!(optSave.Checked))
{
//Téléchargement de la page
string url = "https://ars-hdf.xwiki.com/xwiki/rest/wikis/plansactions/spaces/Indicateur/pages/" + Code + "/objects/Indicateur.Code.IndicateurClass/0";
string command = "curl -o " + Fichier + " --cookie " + Chemin + "/Import/loginCookies " + url;
ExecuteCommandSync(command);
}
//Lecture des informations
DataSet ds = new DataSet();
try
{
ds.ReadXml(Fichier);
}
catch { lst.Items.Add("Erreur Indicateur : " + Code); return; }
//Traitement des informations
bool modif = false;
lIndicateur lp = new lIndicateur();
lp.Acces = Acces;
lp.ChargeCode(Code);
//Enregistrement des informations
Indicateur p;
if (lp.Liste.Count > 0)
{
p = lp.Liste[0];
modif = true;
}
else
{
p = new Indicateur();
p.Code = Code;
p.TypeIndicateur = TypeIndicateur.DOSSIER;
p.Actif = true;
}
//Traitement des données
foreach (DataRow r in ds.Tables["Property"].Rows)
{
switch (r["name"].ToString())
{
case "indicateur_libelle":
p.Libelle = r["value"].ToString();
break;
case "indicateur_type":
if (r["value"].ToString() == "Impact")
{
p.TypeIndicateur = TypeIndicateur.IMPACT;
}
if (r["value"].ToString() == "MOY")
{
p.TypeIndicateur = TypeIndicateur.MOYEN;
}
if (r["value"].ToString() == "RLT")
{
p.TypeIndicateur = TypeIndicateur.RESULTAT;
}
if (r["value"].ToString() == "RIT")
{
p.TypeIndicateur = TypeIndicateur.RESULTAT;
}
if (r["value"].ToString() == "RCT")
{
p.TypeIndicateur = TypeIndicateur.RESULTAT;
}
break;
}
}
if (!modif)
{
lp.Ajouter(p);
lst.SelectedIndex = lst.Items.Count - 1;
lst.Items[lst.Items.Count - 1] += lst.Items[lst.Items.Count - 1] + "-->Créé";
}
else
{
lp.Enregistrer();
lst.SelectedIndex = lst.Items.Count - 1;
lst.Items[lst.Items.Count - 1] += lst.Items[lst.Items.Count - 1] + "-->Modifié";
}
}
