//-------------------------------------------------------------------------------
private CResultAErreur CreateVersionRecursif(CProjet projet)
{
CResultAErreur res = CResultAErreur.True;
if (projet.Projet != null)
{
res = CreateVersionRecursif(projet.Projet);
}
if (!res)
{
return(res);
}
if (projet.IsNew() && projet.TypeProjet != null && projet.TypeProjet.OptionVersion.Code == timos.data.projet.EOptionTypeProjetVersion.VersionAutomatique)
{
res = projet.CreateDataVersionInCurrentContext();
}
return(res);
}
//-----------------------------------------------------
private CResultAErreur AfficherEditeur(IElementDeProjet element)
{
CResultAErreur result = CResultAErreur.True;
if (element is CProjet)
{
CProjet projet = (CProjet)element;
if (projet.IsNew() && m_controlEdition.ModeEdition == EModeEditeurProjet.Selection)
{
projet.BeginEdit();
}
CFormNavigateurPopup.Show(new CFormEditionProjet(projet));
if (!projet.IsValide() || !projet.VerifieDonnees(false).Result)
{
result = CResultAErreur.False;
}
}
if (element is CIntervention)
{
CIntervention inter = (CIntervention)element;
if (inter.IsNew() && m_controlEdition.ModeEdition == EModeEditeurProjet.Selection)
{
inter.BeginEdit();
}
CFormNavigateurPopup.Show(new CFormEditionIntervention(inter));
if (!inter.IsValide() || !inter.VerifieDonnees(false).Result)
{
result = CResultAErreur.False;
}
}
if (result)
{
ActualiserDesigner();
GenererListeContenu();
}
return(result);
}
// /////////////////////////////////////////////////////////
/// <summary>
/// Le data du result contient un IBaseGantt
/// </summary>
/// <returns></returns>
public static CResultAErreur CreateGantt (
CProjet projet,
CParametreNiveauArbreGanttGroupe groupeRacine,
CFiltreData filtreElements )
{
CResultAErreur result = CResultAErreur.True;
if (projet == null)
return result;
CElementDeGanttProjet elementRacine = new CElementDeGanttProjet(null, projet);
if (!result)
return result;
List<CProjet> lstProjets = new List<CProjet>();
if (!projet.IsNew())//Si le projet est nouveau, on ne peut pas filtrer
//car les éléments ne sont pas encore en base
{
CFiltreData filtre = result.Data as CFiltreData;
filtre = CFiltreData.GetAndFiltre(filtreElements,
new CFiltreData(CProjet.c_champCodeSystemeComplet + " like @1 and " +
CProjet.c_champId + "<>@2",
projet.CodeSystemeComplet + "%",
projet.Id));
CListeObjetsDonnees lstObjetProjets = new CListeObjetsDonnees(projet.ContexteDonnee, typeof(CProjet), filtre);
lstObjetProjets.PreserveChanges = true;
lstObjetProjets.ModeSansTri = true;
lstProjets.AddRange(lstObjetProjets.ToList<CProjet>());
lstObjetProjets.ReadDependances("ProjetsFils","LiensEnTantQueProjetA", "LiensEnTantQueProjetB", "ContraintesPropres", "AnomaliesDuProjet");
CUtilElementAChamps.ReadChampsCustom(lstObjetProjets);
}
//Il faut ajouter les projets qui ne sont pas encore en base et qui n'ont donc pas de code system
List<CProjet> lstALire = new List<CProjet>();
lstALire.Add(projet);
DataRelation relation = null;
foreach ( DataRelation rel in projet.ContexteDonnee.Tables[CProjet.c_nomTable].ChildRelations )
{
if ( rel.ChildTable.TableName == CProjet.c_nomTable )
{
relation = rel;
break;
}
}
while (lstALire.Count > 0 && relation != null)
{
List<CProjet> prochaineGeneration = new List<CProjet>();
foreach (CProjet test in lstALire)
{
DataRow[] rowsDeps = test.Row.Row.GetChildRows(relation);
foreach (DataRow row in rowsDeps)
{
if (row.RowState != DataRowState.Deleted)
{
CProjet prj = new CProjet(row);
if (prj.IsNew() && !lstProjets.Contains(prj) )
{
lstProjets.Add(prj);
}
prochaineGeneration.Add(prj);
}
}
}
lstALire = prochaineGeneration;
}
//Comme on est passé par un filtre Avancé, les nouveaux éléments ne sont
//pas dans la liste. On les ajoute donc !
//Vérifie qu'il y a des éléments dont l'id est négatif
CListeObjetsDonnees lstTmp = new CListeObjetsDonnees(projet.ContexteDonnee,
typeof(CProjet));
lstTmp.Filtre = new CFiltreData(CProjet.c_champId + "<@1", 0);
lstTmp.InterditLectureInDB = true;
if (lstTmp.Count > 0)//Il y a des projets tous neufs dans le contexte
{
foreach (CProjet projetTmp in new ArrayList(lstProjets))
{
//N'utilise pas ProjetsFils pour ne pas lire dans la base
CListeObjetsDonnees lstFils = new CListeObjetsDonnees(projet.ContexteDonnee,
typeof(CProjet),
new CFiltreData(CProjet.c_champIdParent + "=@1", projetTmp.Id));
lstFils.InterditLectureInDB = true;
lstFils.Filtre = new CFiltreData(CProjet.c_champId + "<0");
foreach (CProjet projetFils in lstFils)
if (!lstProjets.Contains(projetFils))
lstProjets.Add(projetFils);
}
//Les nouveaux sous projet du projet principal doivent également être ajoutés
CListeObjetsDonnees lstFilsPrincipal = projet.ProjetsFils;
lstFilsPrincipal.Filtre = new CFiltreData(CProjet.c_champId + "<0");
foreach (CProjet projetFils in lstFilsPrincipal)
if (!lstProjets.Contains(projetFils))
lstProjets.Add(projetFils);
}
CContexteDonnee contexteDeTravail = projet.ContexteDonnee;
return PrepareGantt(groupeRacine,result, elementRacine, lstProjets, contexteDeTravail);
}
//-------------------------------------------------------------------
public override CResultAErreur TraitementAvantSauvegarde(CContexteDonnee contexte)
{
CResultAErreur result = CResultAErreur.True;
try
{
result = base.TraitementAvantSauvegarde(contexte);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
return(result);
}
if (!result)
{
return(result);
}
DataTable table = contexte.Tables[GetNomTable()];
if (table == null)
{
return(result);
}
HashSet <CProjet> projetsARecalculer = new HashSet <CProjet>();
HashSet <CMetaProjet> metaProjetsARecalculer = new HashSet <CMetaProjet>();
bool bIsCalculatingAsynchrones = CGestionnaireProjetsAsynchrones.IsModeCalculProjet(contexte);
List <int> lstProjetsAsynchrones = new List <int>();
List <int> lstMetasProjetsAsynchrones = new List <int>();
foreach (DataRow row in new ArrayList(table.Rows))
{
if (!bIsCalculatingAsynchrones)
{
GereProjetAsynchrone(row);
}
if (row.RowState == DataRowState.Modified || row.RowState == DataRowState.Added)
{
CProjet projet = new CProjet(row);
if (projet.ModeCalculDatesParentes == (int)EModeCalculDatesProjet.Suspended)
{
projet.ModeCalculDatesParentes = (int)EModeCalculDatesProjet.Automatic;
}
if (projet.IsNew())
{
result = CreateVersionRecursif(projet);
if (!result)
{
return(result);
}
projetsARecalculer.Add(projet);
}
// Si les dates réelles (Début ou fin ) sont renseignées, alors on mes le flag Dates Auto à False
if ((projet.DateDebutReel != null || projet.DateFinRelle != null) && !projet.HasChilds())
{
projet.DateDebutAuto = false;
}
// Si les dates planifiées on changées, force le Parent de plus haut niveau à recalculer ses dates
if (!row.HasVersion(DataRowVersion.Original) ||
(row[CProjet.c_champDateDebutPlanifiee] != row[CProjet.c_champDateDebutPlanifiee, DataRowVersion.Original] ||
row[CProjet.c_champDateFinPlanifiee] != row[CProjet.c_champDateFinPlanifiee, DataRowVersion.Original] ||
row[CProjet.c_champDateDebutReel] != row[CProjet.c_champDateDebutReel, DataRowVersion.Original] ||
row[CProjet.c_champDateFinReel] != row[CProjet.c_champDateFinReel, DataRowVersion.Original] ||
row[CProjet.c_champPctAvancement] != row[CProjet.c_champPctAvancement, DataRowVersion.Original] ||
row[CProjet.c_champPoids] != row[CProjet.c_champPoids, DataRowVersion.Original])
)
{
foreach (CRelationMetaProjet_Projet rel in projet.RelationsMetaProjets)
{
if (rel.IsValide() && rel.MetaProjet.IsValide())
{
if (rel.MetaProjet.ModeUpdateAsynchrone && rel.MetaProjet.Row.RowState != DataRowState.Added || bIsCalculatingAsynchrones)
{
lstMetasProjetsAsynchrones.Add(rel.MetaProjet.Id);
}
else
{
metaProjetsARecalculer.Add(rel.MetaProjet);
}
}
}
if (projet.IsNew() && !projet.HasChilds())
{
projet.CalcWeight(false);
projet.CalcProgress(false);
}
projet = projet.Projet;
while (projet != null && projet.IsValide())
{
if (!projet.ModeUpdateAsynchrone || projet.Row.RowState == DataRowState.Added || bIsCalculatingAsynchrones)
{
projetsARecalculer.Add(projet);
projet = projet.Projet;
}
else
{
lstProjetsAsynchrones.Add(projet.Id);
break;
}
}
}
}
if (row.RowState == DataRowState.Deleted)
{
CProjet projet = new CProjet(row);
projet.VersionToReturn = DataRowVersion.Original;
if (projet.Projet != null && projet.Projet.IsValide())
{
projetsARecalculer.Add(projet.Projet);
}
}
}
//Tri les projets par profondeur (du plus profond au moins profond)
List <CProjet> lstProjetsTries = new List <CProjet>();
foreach (CProjet projet in projetsARecalculer)
{
if (projet.Row.RowState != DataRowState.Deleted)
{
lstProjetsTries.Add(projet);
}
}
try
{
lstProjetsTries.Sort(delegate(CProjet x, CProjet y)
{
return(-x.CodeSystemeComplet.Length.CompareTo(y.CodeSystemeComplet.Length));
});
}
catch (Exception ex)
{
result.EmpileErreur(new CErreurException(ex));
return(result);
}
// Recalcul les dates PLANIFIEES des projets marqués A recalculés, et leur Avancement
foreach (CProjet projet in lstProjetsTries)
{
if (projet.HasChilds())
{
projet.UpdateDateDebutPlanifieeCalculeeFromChilds();
projet.UpdateDateFinPlanifieeCalculeeFromChilds();
projet.UpdateDateDebutReelleFromFils();
projet.UpdateDateFinReelleFromFils();
}
projet.UpdateWeight();
projet.UpdateProgress();
}
foreach (CMetaProjet meta in metaProjetsARecalculer)
{
meta.UpdateDateDebutPlanifieeFromChilds(true);
meta.UpdateDateFinPlanifieeFromChilds(true);
meta.UpdateDateDebutReelleFromChilds(true);
meta.UpdateDateFinReelleFromChilds(true);
meta.CalcProgress(false);
}
if (!bIsCalculatingAsynchrones)
{
CGestionnaireProjetsAsynchrones.ASyncCalc(IdSession, lstProjetsAsynchrones, lstMetasProjetsAsynchrones);
}
return(result);
}