//-------------------------------------------------------------------------
public CResultAErreur Init(CObjetDeGroupe objet)
{
m_objet = objet;
m_typeGroupe = m_objet.TypeGroupe;
using (CGroupeStructurant tempGroupe = ((CGroupeStructurant)Activator.CreateInstance(m_typeGroupe, new object[] { m_objet.ContexteDonnee })))
{
m_typeRelationNecessite = tempGroupe.TypeRelationNecessaire;
m_strNomTable = tempGroupe.GetNomTable();
m_strChampIdGroupe = tempGroupe.GetChampId();
}
CResultAErreur result = CResultAErreur.True;
if (!m_typeGroupe.IsSubclassOf(typeof(CGroupeStructurant)))
{
throw new Exception("The group type must inherit from CGroupeStructurant.|30077");
}
Nodes.Clear();
//Lit tous les groupes et toutes les dépendances du groupe
m_listeTousLesGroupes = new CListeObjetsDonnees(objet.ContexteDonnee, m_typeGroupe);
m_listeTousLesGroupes.ReadDependances("RelationsGroupesNecessitants", "RelationsGroupesNecessaires");
FillNodes(null, null);
return(result);
}
//----------------------------------------------------
private CResultAErreur AssureSessionEtContexte()
{
CResultAErreur resErreur = CResultAErreur.True;
System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.Lowest;
if (m_sessionClient == null || !m_sessionClient.IsConnected)
{
m_sessionClient = CSessionClient.CreateInstance();
resErreur = m_sessionClient.OpenSession(new CAuthentificationSessionServer(),
I.T("Alarm management|20154"),
ETypeApplicationCliente.Service);
if (!resErreur)
{
resErreur.EmpileErreur(resErreur.Erreur);
C2iEventLog.WriteErreur(I.T("Error while open alarm management session|20155"));
resErreur.EmpileErreur(I.T("Error while open alarm management session|20155"));
return(resErreur);
}
}
if (m_contexteDonnee == null)
{
m_contexteDonnee = new CContexteDonnee(m_sessionClient.IdSession, true, true);
CListeObjetsDonnees lst = new CListeObjetsDonnees(m_contexteDonnee, typeof(CTypeAlarme));
lst.AssureLectureFaite();
lst.ReadDependances("RelationsChampsCustomListe");
lst = new CListeObjetsDonnees(m_contexteDonnee, typeof(CSeveriteAlarme));
lst.AssureLectureFaite();
}
return(resErreur);
}
//-------------------------------------------------------------------
//S'il n'y a pas de paramètres, lit tous les champs custom
public static void ReadChampsCustom(CListeObjetsDonnees lstObjets, params int[] idsChamps)
{
if (lstObjets.Count == 0)
{
return;
}
IObjetDonneeAChamps eltAChamps = lstObjets[0] as IObjetDonneeAChamps;
if (eltAChamps == null)
{
return;
}
if (idsChamps.Length == 0)
{
lstObjets.ReadDependances("RelationsChampsCustom");
foreach (IObjetDonneeAChamps eltAChamp in lstObjets)
{
SetTousChampsLus(eltAChamp);
}
return;
}
List <string> lstChamps = new List <string>();
foreach (int nIdChamp in idsChamps)
{
CChampCustom champ = new CChampCustom(eltAChamps.ContexteDonnee);
if (champ.ReadIfExists(nIdChamp))
{
CDefinitionProprieteDynamiqueChampCustom def = new CDefinitionProprieteDynamiqueChampCustom(champ);
lstChamps.Add(def.NomPropriete);
}
}
lstObjets.ReadDependances(lstChamps.ToArray());
foreach (IObjetDonneeAChamps eltAChamp in lstObjets)
{
foreach (int nIdChamp in idsChamps)
{
SetChampsLus(eltAChamp, nIdChamp);
}
}
}
public void InitFromSchema(CSchemaReseau schema)
{
m_dbKeySchemaReseau = schema.DbKey;
m_schema = schema;
CListeObjetsDonnees lstElements = schema.ElementsDeSchema;
lstElements.ReadDependances(
"SchemaReseauInclu",
"SchemaReseauContenu");
foreach (CElementDeSchemaReseau elt in lstElements)
{
IElementDeSchemaReseau elementFils = elt.ElementAssocie;
if (elementFils != null)
{
CInfoElementDeSchemaSupervise fils = null;
if (elementFils is CSite)
{
fils = new CInfoSiteDeSchemaSupervise(this, elt, m_base, NiveauProfondeur + 1);
}
if (elementFils is CLienReseau)
{
fils = new CInfoLienDeSchemaSupervise(this, elt, m_base, NiveauProfondeur + 1);
}
if (elementFils is CElementDeSchemaReseau)
{
fils = new CInfoEquipementDeSchemaSupervise(this, elt, m_base, NiveauProfondeur + 1);
}
if (elementFils is CSchemaReseau)
{
fils = new CInfoSchemaDeSchemaSupervise(this, elt, m_base, NiveauProfondeur + 1);
}
if (elementFils is CEquipementLogique)
{
fils = new CInfoEquipementDeSchemaSupervise(this, elt, m_base, NiveauProfondeur + 1);
}
if (elementFils is CEntiteSnmp)
{
fils = new CInfoEntiteSnmpDeSchemaSupervise(this, elt, m_base, NiveauProfondeur + 1);
}
if (elementFils != null)
{
fils.InitFromElementDeSchema(elt);
m_listeFils.Add(fils);
}
}
}
PrepareSupervisionEtatOperationnel(schema);
CalculArbreOperationnel();
}
//----------------------------------------------------------------
/// <summary>
/// Retourne la liste des Sites du Contrat, qu'ils soient définis par Profil ou par une liste de relations "manuelle"
/// </summary>
/// <returns></returns>
public IList <CSite> GetTousLesSitesDuContrat()
{
IList <CSite> listeSites = new List <CSite>();
StringBuilder bl = new StringBuilder();
if (this.TypeContrat != null && this.TypeContrat.GestionSitesManuel)
{
// Ajout des Sites par relation
RelationsSites.ReadDependances("Site");
foreach (CContrat_Site rel in RelationsSites)
{
listeSites.Add(rel.Site);
bl.Append(rel.Site.Id);
bl.Append(",");
}
if (bl.Length > 0)
{
bl.Remove(bl.Length - 1, 1);
}
CFiltreData filtre;
if (bl.Length > 0)
{
filtre = new CFiltreData(CSite.c_champId + " in (" + bl.ToString() + ")");
CListeObjetDonneeGenerique <CSite> lst = new CListeObjetDonneeGenerique <CSite>(ContexteDonnee, filtre);
return(lst);
}
else
{
return(new List <CSite>());
}
}
else
{
CProfilElement profil = ProfilSite;
if (profil != null)
{
CListeObjetsDonnees liste = profil.GetElementListForSource(this);
foreach (CSite site in liste)
{
listeSites.Add(site);
}
}
return(listeSites);
}
}
//--------------------------------------------------------------------------
public IEnumerable <CTraitementReleveEquipement> GetTraitements()
{
List <CTraitementReleveEquipement> traitements = new List <CTraitementReleveEquipement>();
CListeObjetsDonnees lst = EquipementsReleves;
//Préchargement de données
lst.ReadDependances("Equipement", "RelevesEquipementsFils");
new CListeObjetsDonnees(ContexteDonnee, typeof(CTypeEquipement)).AssureLectureFaite();
new CListeObjetsDonnees(ContexteDonnee, typeof(CRelationTypeEquipement_Constructeurs)).AssureLectureFaite();
lst.Filtre = new CFiltreData(CReleveEquipement.c_champParentEqpt + " is null");
foreach (CReleveEquipement rel in lst)
{
CTraitementReleveEquipement traitement = rel.GetTraitement();
if (traitement != null)
{
traitements.Add(traitement);
}
}
return(traitements.AsReadOnly());
}
//--------------------------------------------------------------------
public void Init(CPhaseSpecifications phaseSpecifications)
{
CancelEdit();
CurrentItemIndex = null;
Items = new CCustomizableListItem[0];
m_phaseSpecifications = phaseSpecifications;
if (m_phaseSpecifications != null)
{
List <CCustomizableListItem> items = new List <CCustomizableListItem>();
CListeObjetsDonnees lstBesoins = m_phaseSpecifications.Besoins;
lstBesoins.ReadDependances("BesoinsFils", "TypeProjet", "TypeEquipement", "TypeConsommable", "TypeOperation");
CRelationBesoin_Satisfaction.PreloadBesoinsSatisfaits(lstBesoins);
lstBesoins.Filtre = new CFiltreData(CBesoin.c_champIdBesoinParent + " is null");
foreach (CBesoin besoin in lstBesoins)
{
AddItemBesoinEtFils(null, besoin, items);
}
Items = items.ToArray();
}
m_panelResumeElementACout.Init(m_phaseSpecifications);
Refresh();
}
public void InitFromSchema(CSchemaReseau schema)
{
m_nIdSchemaReseau = schema.Id;
m_schema = schema;
CSpvSchemaReseau schemaSPV = CSpvSchemaReseau.GetObjetSpvFromObjetTimos(schema);
if (schemaSPV != null)
{
m_nIdSchemaReseauSpv = schemaSPV.Id;
}
CListeObjetsDonnees lstElements = schema.ElementsDeSchema;
lstElements.ReadDependances(
"SchemaReseauInclu",
"SchemaReseauContenu");
//Charge les données SPV
AssureRelationsToSpv();
CListeObjetsDonnees lstTmp = lstElements.GetDependances("Site");
lstTmp.GetDependances(m_relationFromSiteSpvToSite).AssureLectureFaite();
lstTmp = lstElements.GetDependances("EquipementLogique");
lstTmp.GetDependances(m_relationFromEquipementSpvToEquipement).AssureLectureFaite();
lstTmp = lstElements.GetDependances("LienReseau");
lstTmp.GetDependances(m_relationFromLiaisonSpvToLiaison).AssureLectureFaite();
//CSpvService service = CSpvService.GetObjetSpvFromObjetTimos(schema);
foreach (CElementDeSchemaReseau elt in lstElements)
{
IElementDeSchemaReseau elementFils = elt.ElementAssocie;
if (elementFils != null)
{
CInfoElementDeSchemaSupervise fils = null;
if (elementFils is CSite)
{
fils = new CInfoSiteDeSchemaSupervise(this, elt, m_base, NiveauProfondeur + 1);
}
if (elementFils is CLienReseau)
{
fils = new CInfoLienDeSchemaSupervise(this, elt, m_base, NiveauProfondeur + 1);
}
if (elementFils is CElementDeSchemaReseau)
{
fils = new CInfoEquipementDeSchemaSupervise(this, elt, m_base, NiveauProfondeur + 1);
}
if (elementFils is CSchemaReseau)
{
fils = new CInfoSchemaDeSchemaSupervise(this, elt, m_base, NiveauProfondeur + 1);
}
if (elementFils is CEquipementLogique)
{
fils = new CInfoEquipementDeSchemaSupervise(this, elt, m_base, NiveauProfondeur + 1);
}
if (elementFils != null)
{
fils.InitFromElementDeSchema(elt);
m_listeFils.Add(fils);
}
}
}
PrepareSupervisionEtatOperationnel(schema);
CalculArbreOperationnel();
}
//----------------------------------------------------------
public List <ITranchePlanning> GetTranchesForElementsAInterventionBetween(DateTime dateDebut, DateTime dateFin)
{
List <ITranchePlanning> lstRetour = new List <ITranchePlanning>();
Hashtable tableTypeToIds = new Hashtable();
if (m_listeElementsAInterventions.Count == 0)
{
return(lstRetour);
}
//Si tous les elements à Intervention sont du même type
foreach (IElementAIntervention elt in m_listeElementsAInterventions)
{
string strIds = (string)tableTypeToIds[elt.GetType()];
if (strIds == null)
{
strIds = elt.Id + "";
}
else
{
strIds += ";" + elt.Id;
}
tableTypeToIds[elt.GetType()] = strIds;
}
dateFin = dateFin.AddDays(1);
foreach (DictionaryEntry entry in tableTypeToIds)
{
Type tp = (Type)entry.Key;
string strIds = (string)entry.Value;
if (tp == typeof(CSite))
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(ContexteDonnee, typeof(CFractionIntervention));
liste.PreserveChanges = true;
liste.Filtre = new CFiltreDataAvance(
CFractionIntervention.c_nomTable,
CIntervention.c_nomTable + "." + CIntervention.c_champIdElementLie + " in (" + strIds + ") and " +
CFractionIntervention.c_champDateDebutPlanifie + "<@1 and " +
CFractionIntervention.c_champDateFinPlanifiee + ">@2",
dateFin,
dateDebut
);
//Lit dans la base
liste.AssureLectureFaite();
liste.ReadDependances("Intervention");
m_contexteDonnee.GetTableSafe(CIntervention.c_nomTable);
strIds = strIds.Replace(';', ',');
string strNomRelation = m_contexteDonnee.GetForeignKeyName(typeof(CFractionIntervention), "Intervention");
//Et filtre sur les existants (pour prendre les nouveaux en compte)
string strFiltre = "Parent(" + strNomRelation + ")." + CIntervention.c_champIdElementLie + " in (" + strIds + ") and " +
CFractionIntervention.c_champDateDebutPlanifie + "<=" + dateFin.ToString("#MM/dd/yyyy#") + " and " +
CFractionIntervention.c_champDateFinPlanifiee + ">=" + dateDebut.ToString("#MM/dd/yyyy#") + "";
DataTable table = m_contexteDonnee.Tables[CFractionIntervention.c_nomTable];
DataRow[] rows = table.Select(strFiltre);
foreach (DataRow row in rows)
{
lstRetour.Add(new CFractionIntervention(row));
}
}
}
return(lstRetour);
}
/////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Lit les dépendances filles du type de donné
/// </summary>
/// <returns></returns>
private void ReadDependanceFille(
string strPropriete,
CListeObjetsDonnees lstSource,
CListeObjetsDonnees.CArbreProps arbre,
CInfoRelation relation,
List <string> listePaquets)
{
CResultAErreur result = CResultAErreur.True;
Type tpFille = null;
PropertyInfo info = lstSource.TypeObjets.GetProperty(strPropriete);
if (info == null)
{
return;
}
object[] attrs = info.GetCustomAttributes(typeof(RelationFilleAttribute), true);
if (attrs == null || attrs.Length < 0)
{
return;
}
tpFille = ((RelationFilleAttribute)attrs[0]).TypeFille;
DataTable table = lstSource.ContexteDonnee.GetTableSafe(lstSource.NomTable);
//S'assure que la table fille est chargée
lstSource.ContexteDonnee.GetTableSafe(relation.TableFille);
string strKey = relation.RelationKey;
DataColumn colDependance = table.Columns[strKey];
if (listePaquets == null)
{
listePaquets = lstSource.GetPaquetsPourLectureFils(relation.ChampsParent[0], colDependance);
}
int nNbPaquets = listePaquets.Count;
//Lit les relations par paquet
for (int nPaquet = 0; nPaquet < nNbPaquets; nPaquet++)
{
string strPaquet = (string)listePaquets[nPaquet];
if (strPaquet.Length > 0)
{
CListeObjetsDonnees listeFille = new CListeObjetsDonnees(lstSource.ContexteDonnee, tpFille);
listeFille.Filtre = new CFiltreData(relation.ChampsFille[0] + " in " + strPaquet);
if (arbre.Filtre.Length > 0)
{
listeFille.Filtre.Filtre += " and " + arbre.Filtre;
}
listeFille.ModeSansTri = true;
listeFille.PreserveChanges = true;
listeFille.AssureLectureFaite();
int nMax = Math.Min(lstSource.Count, (nPaquet + 1) * CListeObjetsDonnees.c_nNbLectureParLotFils);
if (colDependance != null && arbre.Filtre.Length == 0)
{
//Indique que les lignes ont été lues
for (int nRow = nPaquet * CListeObjetsDonnees.c_nNbLectureParLotFils; nRow < nMax; nRow++)
{
DataRow row = lstSource.View.GetRow(nRow);
DataRowState oldState = row.RowState;
row[colDependance] = true;
if (oldState == DataRowState.Unchanged)
{
row.AcceptChanges();
}
}
}
listeFille.ReadDependances(arbre);
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
private void ReadDependanceParente(
string strPropriete,
CListeObjetsDonnees lstSource,
CListeObjetsDonnees.CArbreProps arbre,
CInfoRelation relation)
{
int nNbTotal = lstSource.Count;
string strKey = relation.RelationKey;
Type tp = null;
PropertyInfo info = lstSource.TypeObjets.GetProperty(strPropriete);
if (info == null)
{
return;
}
tp = info.PropertyType;
if (tp != null && typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tp))
{
//Crée les paquets
ArrayList lstPaquets = new ArrayList();
Hashtable tableIdsParentTraites = new Hashtable();
int nPaquet = 0;
string strChampFille = relation.ChampsFille[0];
string strPaquetEnCours = "";
int nNbInPaquet = 0;
for (int n = 0; n < lstSource.View.Count; n++)
{
DataRow row = lstSource.View.GetRow(n);
string strCle = row[strChampFille].ToString();
if (strCle != "")
{
if (tableIdsParentTraites[strCle] == null)
{
tableIdsParentTraites[strCle] = true;
strPaquetEnCours += strCle + ",";
nNbInPaquet++;
if (nNbInPaquet >= CListeObjetsDonnees.c_nNbLectureParLotFils)
{
strPaquetEnCours = "(" + strPaquetEnCours.Substring(0, strPaquetEnCours.Length - 1) + ")";
lstPaquets.Add(strPaquetEnCours);
strPaquetEnCours = "";
nNbInPaquet = 0;
}
}
}
}
if (strPaquetEnCours.Length > 0)
{
strPaquetEnCours = "(" + strPaquetEnCours.Substring(0, strPaquetEnCours.Length - 1) + ")";
lstPaquets.Add(strPaquetEnCours);
}
//Lit les relations par paquet
int nNbPaquets = lstPaquets.Count;
for (nPaquet = 0; nPaquet < nNbPaquets; nPaquet++)
{
string strPaquet = (string)lstPaquets[nPaquet];
if (strPaquet != "()")
{
CListeObjetsDonnees listeParent = new CListeObjetsDonnees(lstSource.ContexteDonnee, tp);
listeParent.ModeSansTri = true;
listeParent.PreserveChanges = true;
listeParent.Filtre = new CFiltreData(relation.ChampsParent[0] + " in " + strPaquet);
listeParent.AssureLectureFaite();
//Indique que les lignes ont été lues
//Stef 2/12/2011 : non, on n'indique pas que c'est lu puisqu'il
//s'agit de dépendances parentes !
//Ca pose le problème suivant : si on est sur une table hiérarchique,
//lorsqu'on lit le parent (d'un projet par exemple), le fait de
//dire que les dépendances sont lues implique qu'on indique
//qu'on a lu les fils.
//De ma compréhension à ce jour, on ne gère pas de colonne
//indiquant si la dépendance a été chargé pour des dépendances
//parentes
/*if ( lstSource.View.Table.Columns[strKey] != null )
* {
* for ( int nRow = 0; nRow < lstSource.View.Count; nRow++ )
* {
* CContexteDonnee.ChangeRowSansDetectionModification ( lstSource.View.GetRow ( nRow ), strKey, true );
* }
* }*/
listeParent.ReadDependances(arbre);
}
}
}
}
// /////////////////////////////////////////////////////////
/// <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);
}
// /////////////////////////////////////////////////////////
/// <summary>
/// Le data du result contient un IBaseGantt
/// </summary>
/// <returns></returns>
public static CResultAErreur CreateGantt(
CMetaProjet metaProjet,
CParametreNiveauArbreGanttGroupe groupeRacine,
CFiltreData filtreElements)
{
CResultAErreur result = CResultAErreur.True;
if (metaProjet == null)
return result;
CElementDeGanttMetaProjet elementRacine = new CElementDeGanttMetaProjet(null, metaProjet);
if (!result)
return result;
List<CProjet> lstProjets = new List<CProjet>();
bool bLectureDansContexteCourant = false;
//S'il y a des éléments modifiés, ajoutés ou supprimés dans
//les relations, charge manuellement
DataTable table = metaProjet.ContexteDonnee.GetTableSafe(CRelationMetaProjet_Projet.c_nomTable);
if ( table != null )
{
if ( table.Select ( "", "", DataViewRowState.Added | DataViewRowState.Deleted | DataViewRowState.ModifiedCurrent ).Length > 0 )
{
bLectureDansContexteCourant = true;
//Il y a des modifs, on ne peut donc pas appliquer le filtre,
//et on doit aller chercher les projets manuellement
foreach ( CRelationMetaProjet_Projet rel in metaProjet.RelationsProjets )
{
List<CProjet> lstTmp = new List<CProjet>();
lstTmp.Add ( rel.Projet );
while ( lstTmp.Count > 0 )
{
List<CProjet> lstSuivante = new List<CProjet>();
foreach ( CProjet prj in lstTmp )
{
lstProjets.Add ( prj );
lstSuivante.AddRange ( prj.ProjetsFils.ToList<CProjet>());
}
lstTmp = lstSuivante;
}
}
}
}
if (!bLectureDansContexteCourant)
{
CFiltreData filtre = result.Data as CFiltreData;
filtre = CFiltreData.GetAndFiltre(filtreElements,
new CFiltreDataAvance(
CProjet.c_nomTable,
CRelationMetaProjet_Projet.c_nomTable + "." +
CMetaProjet.c_champId + "=@1",
metaProjet.Id));
filtre.IntegrerFilsHierarchiques = !metaProjet.HideChildProjects;
CListeObjetsDonnees lstObjetProjets = new CListeObjetsDonnees(metaProjet.ContexteDonnee, typeof(CProjet), filtre);
lstObjetProjets.PreserveChanges = true;
lstObjetProjets.ModeSansTri = true;
lstProjets.AddRange(lstObjetProjets.ToList<CProjet>());
if ( metaProjet.HideChildProjects )
lstObjetProjets.ReadDependances("LiensEnTantQueProjetA.ProjetB", "LiensEnTantQueProjetB.ProjetA", "ContraintesPropres", "AnomaliesDuProjet");
else
lstObjetProjets.ReadDependances("ProjetsFils", "LiensEnTantQueProjetA.ProjetB", "LiensEnTantQueProjetB.ProjetA", "ContraintesPropres", "AnomaliesDuProjet");
CUtilElementAChamps.ReadChampsCustom(lstObjetProjets);
}
CContexteDonnee contexteDeTravail = metaProjet.ContexteDonnee;
return PrepareGantt(groupeRacine, result, elementRacine, lstProjets, contexteDeTravail);
}
//**********************************************************************************
public void ReadArbre(CListeObjetsDonnees listeSource, CListeObjetsDonnees.CArbreProps arbre, List <string> lstPaquetsALire)
{
if (listeSource.Count == 0)
{
return;
}
CObjetDonneeAIdNumerique objExemple = listeSource[0] as CObjetDonneeAIdNumerique;
if (objExemple == null)
{
return;
}
string strCle = "";
string strPropSansCle = "";
if (!CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(arbre.ProprietePrincipale, ref strCle, ref strPropSansCle))
{
return;
}
//trouve la relation correspondante à l'identifiant de la propriété
RelationTypeIdAttribute relation = null;
foreach (RelationTypeIdAttribute relTest in CContexteDonnee.RelationsTypeIds)
{
if (relTest.IdRelation == strPropSansCle)
{
relation = relTest;
break;
}
}
if (relation == null)
{
return;
}
string strNomColDep = relation.GetNomColDepLue();
DataColumn col = objExemple.Table.Columns[strNomColDep];
if (col == null)
{
col = new DataColumn(strNomColDep, typeof(bool));
col.DefaultValue = false;
col.AllowDBNull = false;
objExemple.Table.Columns.Add(col);
}
if (lstPaquetsALire == null)
{
lstPaquetsALire = listeSource.GetPaquetsPourLectureFils(objExemple.GetChampId(), col);
}
foreach (string strPaquet in lstPaquetsALire)
{
if (strPaquet != null && strPaquet.Trim().Length > 0)
{
CListeObjetsDonnees lst = new CListeObjetsDonnees(listeSource.ContexteDonnee,
CContexteDonnee.GetTypeForTable(relation.TableFille));
lst.Filtre = new CFiltreData(
relation.ChampType + "=@1 and " +
relation.ChampId + " in " + strPaquet,
listeSource.TypeObjets.ToString());
lst.AssureLectureFaite();
lst.ReadDependances(arbre);
}
}
foreach (CObjetDonneeAIdNumerique obj in listeSource)
{
CContexteDonnee.ChangeRowSansDetectionModification(obj.Row, strNomColDep, true);
}
}
public CResultAErreur Execute(int nIdSession, Hashtable valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee contexte = new CContexteDonnee(nIdSession, true, false))
{
StreamReader reader = null;
try
{
CHandlerEvenementServeur.SuspendGestionnaire(true);
contexte.EnableTraitementsAvantSauvegarde = false;
// Charges tous les tickets
CListeObjetsDonnees listeTicketsACharger = new CListeObjetsDonnees(contexte, typeof(CTicket));
listeTicketsACharger.ReadDependances("RelationsChampsCustom");
// Lire le CSV
string strFichierImport = "c:\\TimosData\\IMPORT_JANVIER_MARS_2009.csv";
reader = new StreamReader(strFichierImport);
// Lit l'entête de colonnes
string strLine = reader.ReadLine();
// Lit la première ligne
strLine = reader.ReadLine();
while (strLine != null)
{
// Pour chaque ligne du ficher
string[] strChamps = strLine.Split(';');
string strNumeroTicket = strChamps[0];
string strIdQualif = strChamps[2];
// Traitement
CTicket ticket = new CTicket(contexte);
if (ticket.ReadIfExists(new CFiltreData(
CTicket.c_champNumero + " = @1",
strNumeroTicket)))
{
CQualificationTicket qualif = new CQualificationTicket(contexte);
if (qualif.ReadIfExists(new CFiltreData(
CQualificationTicket.c_champId + " = @1",
Int32.Parse(strIdQualif))))
{
// Affecte la valeur du champs custom 147 : Requalification
ticket.SetValeurChamp(147, qualif);
}
}
// Lit la ligne suivante
strLine = reader.ReadLine();
}
reader.Close();
result = contexte.SaveAll(true);
if (!result)
{
result.EmpileErreur("Erreur de sauvegarde des données");
return(result);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
CHandlerEvenementServeur.SuspendGestionnaire(false);
if (reader != null)
{
reader.Close();
}
}
}
return(result);
}
//----------------------------------------------------------
public List <ITranchePlanning> GetOccupationsForRessourcesBetween(DateTime dateDebut, DateTime dateFin)
{
List <ITranchePlanning> lstRetour = new List <ITranchePlanning>();
Hashtable tableTypeToIds = new Hashtable();
if (m_listeRessources.Count == 0)
{
return(lstRetour);
}
CContexteDonnee contexte = m_listeRessources[0].ContexteDonnee;
foreach (IRessourceEntreePlanning ressource in Ressources)
{
if (tableTypeToIds[ressource.GetType()] == null)
{
tableTypeToIds[ressource.GetType()] = ressource.Id + "";
}
else
{
string strId = (string)tableTypeToIds[ressource.GetType()];
strId += "," + ressource.Id;
tableTypeToIds[ressource.GetType()] = strId;
}
}
dateFin = dateFin.AddDays(1);
///IdFraction->True si elle a déjà été ajoutée
Hashtable tableFractions = new Hashtable();
foreach (DictionaryEntry entry in tableTypeToIds)
{
Type tp = (Type)entry.Key;
string strIds = (string)entry.Value;
CListeObjetsDonnees liste;
string strClauseRessource = "";
string strDependancesRessources = "";
string strTableLienRessource = "";
string strChampIdRessourceInTableLien = "";
Type typeLienRessource = null;
if (tp == typeof(CActeur))
{
strClauseRessource = CIntervention_Intervenant.c_nomTable + "." + CActeur.c_champId + " in (" + strIds + ")";
strDependancesRessources = "Intervention.RelationsIntervenants";
strTableLienRessource = CIntervention_Intervenant.c_nomTable;
typeLienRessource = typeof(CIntervention_Intervenant);
strChampIdRessourceInTableLien = CActeur.c_champId;
}
else if (tp == typeof(CRessourceMaterielle))
{
strClauseRessource = CIntervention_Ressource.c_nomTable + "." + CRessourceMaterielle.c_champId + " in (" + strIds + ")";
strDependancesRessources = "Intervention.RelationsRessourcesMaterielles";
strTableLienRessource = CIntervention_Ressource.c_nomTable;
typeLienRessource = typeof(CIntervention_Ressource);
strChampIdRessourceInTableLien = CRessourceMaterielle.c_champId;
}
else
{
throw new Exception("Type de ressource non prévu : " + tp.ToString());
}
liste = new CListeObjetsDonnees(contexte, typeof(CFractionIntervention));
liste.PreserveChanges = true;
liste.Filtre = new CFiltreDataAvance(
CFractionIntervention.c_nomTable,
CIntervention.c_nomTable + "." +
strClauseRessource + " and " +
CFractionIntervention.c_champDateDebutPlanifie + "<@1 and " +
CFractionIntervention.c_champDateFinPlanifiee + ">@2",
dateFin,
dateDebut
);
//Lit dans la base
liste.AssureLectureFaite();
liste.ReadDependances("Intervention", strDependancesRessources);
contexte.GetTableSafe(CIntervention.c_nomTable);
contexte.GetTableSafe(strTableLienRessource);
string strNomRelationIntervention = contexte.GetForeignKeyName(typeof(CFractionIntervention), "Intervention");
//Ne sélectionne que ceux qui sont liés à la ressource
CListeObjetsDonnees listeInterventionIt = new CListeObjetsDonnees(contexte, typeLienRessource);
listeInterventionIt.InterditLectureInDB = true;
listeInterventionIt.Filtre = new CFiltreData(strChampIdRessourceInTableLien + " in (" + strIds + ")");
string strIdsInterventions = "";
foreach (IEntreePlanning_Ressource it in listeInterventionIt)
{
strIdsInterventions += it.EntreePlanning.Id + ",";
}
if (strIdsInterventions.Length > 0)
{
string strFiltre = "Parent(" + strNomRelationIntervention + ")." + CIntervention.c_champId + " in (" + strIdsInterventions + ") and " +
CFractionIntervention.c_champDateDebutPlanifie + "<=" + dateFin.ToString("#MM/dd/yyyy#") + " and " +
CFractionIntervention.c_champDateFinPlanifiee + ">=" + dateDebut.ToString("#MM/dd/yyyy#") + "";
DataTable table = contexte.Tables[CFractionIntervention.c_nomTable];
DataRow[] rows = table.Select(strFiltre);
foreach (DataRow row in rows)
{
if (!tableFractions.Contains(row[CFractionIntervention.c_champId]))
{
lstRetour.Add(new CFractionIntervention(row));
tableFractions[row[CFractionIntervention.c_champId]] = true;
}
}
}
}
return(lstRetour);
}
public void UpdateOnglets()
{
if (!LockEdition)
{
//valide les modifs car on va tout supprimer
MAJ_Champs();
}
m_bIsInitializing = true;
Hashtable tablePagesToHide = new Hashtable();
foreach (Crownwood.Magic.Controls.TabPage page in TabPages)
{
m_tablePagesInit[page] = false;
tablePagesToHide[page] = true;
}
if (m_elementEdite == null)
{
return;
}
/* YK : On obtient la session de l'objet en cours d'édition au lieur de la session par défaut */
CSessionClient session = null;
IObjetDonneeAIdNumeriqueAuto objetDonnee = m_elementEdite as IObjetDonneeAIdNumeriqueAuto;
if (objetDonnee != null)
{
session = CSessionClient.GetSessionForIdSession(objetDonnee.ContexteDonnee.IdSession);
}
else
{
session = CSessionClient.GetSessionUnique();
}
ArrayList lstFormulaires = new ArrayList(m_elementEdite.GetFormulaires());
lstFormulaires.Sort(new CSorterFormulaires());
//Lit les champs liés et leurs valeurs
StringBuilder bl = new StringBuilder();
foreach (CFormulaire formulaire in lstFormulaires)
{
bl.Append(formulaire.Id);
bl.Append(",");
}
if (bl.Length > 0)
{
bl.Remove(bl.Length - 1, 1);
CListeObjetsDonnees lst = new CListeObjetsDonnees(((CFormulaire)lstFormulaires[0]).ContexteDonnee, typeof(CFormulaire));
lst.Filtre = new CFiltreData(CFormulaire.c_champId + " in (" + bl.ToString() + ")");
lst.AssureLectureFaite();
lst.ReadDependances("RelationsChamps", "RelationsChamps.Champ", "RelationsChamps.Champ.ListeValeurs");
}
foreach (CFormulaire formulaire in lstFormulaires)
{
CRestrictionUtilisateurSurType restriction = new CRestrictionUtilisateurSurType(m_elementEdite.GetType());
if (session.GetInfoUtilisateur() != null)
{
int?nIdVersion = null;
IObjetAContexteDonnee objetAContexte = m_elementEdite as IObjetAContexteDonnee;
if (objetAContexte != null)
{
nIdVersion = objetAContexte.ContexteDonnee.IdVersionDeTravail;
}
restriction = session.GetInfoUtilisateur().GetRestrictionsSurObjet(m_elementEdite, nIdVersion);
}
ERestriction restrictionFormulaire = restriction.GetRestriction(formulaire.CleRestriction);
if ((restrictionFormulaire & ERestriction.Hide) != ERestriction.Hide)
{
Crownwood.Magic.Controls.TabPage page = (Crownwood.Magic.Controls.TabPage)m_tableIdFormulaireToTabPage[formulaire.Id];
CCreateur2iFormulaire createur = null;
if (page == null)
{
C2iWndFenetre wnd = formulaire.Formulaire;
if (wnd != null)
{
page = new Crownwood.Magic.Controls.TabPage(wnd.Text);
page.SuspendLayout();
if (wnd.Text == "")
{
page.Title = formulaire.Libelle;
}
TabPages.Add(page);
m_tableCreateurs[page] = null;
m_tablePageTo2iWnd[page] = wnd;
m_tableIdFormulaireToTabPage[formulaire.Id] = page;
}
}
else
{
createur = (CCreateur2iFormulaire)m_tableCreateurs[page];
}
if (page != null)
{
m_tablePageToRestriction[page] = restrictionFormulaire;
if (!TabPages.Contains(page))
{
TabPages.Add(page);
}
tablePagesToHide.Remove(page);
}
}
}
/*CChampCustom[] champs = ElementEdite.GetChampsHorsFormulaire();
* if ( champs.Length != 0 )
* {
* UpdatePageChamps( nRest );
* if ( m_pageGrid != null )
* tablePagesToHide.Remove(m_pageGrid);
* }*/
foreach (Crownwood.Magic.Controls.TabPage pageToDel in tablePagesToHide.Keys)
{
TabPages.Remove(pageToDel);
}
if (TabPages.Count == 1)
{
this.HideTabsMode = Crownwood.Magic.Controls.TabControl.HideTabsModes.HideAlways;
}
else
{
this.HideTabsMode = Crownwood.Magic.Controls.TabControl.HideTabsModes.ShowAlways;
}
if (SelectedTab != null)
{
InitPageWithObjetCourant(SelectedTab);
}
m_bIsInitializing = false;
}
//-----------------------------------
public IEnumerable <CDocumentGED> GetDocuments(object sourceDeFormule)
{
Dictionary <CDocumentGED, int> dicDocs = new Dictionary <CDocumentGED, int>();
IEnumerable <CObjetDonneeAIdNumerique> lstObjets = GetListeAssociations(sourceDeFormule);
IEnumerable <CCategorieGED> lstCategories = GetListeCategories(sourceDeFormule);
//Ne prend que les documents qui sont dans toutes les catégories
//et communes à tous les éléments
bool bHasCategories = lstCategories.Count() > 0;
HashSet <int> setCats = new HashSet <int>();
foreach (CCategorieGED categorie in lstCategories)
{
AddCategory(categorie, setCats);
}
foreach (CObjetDonneeAIdNumerique objet in lstObjets)
{
CListeObjetsDonnees lstDocs = CDocumentGED.GetListeDocumentsForElement(objet);
if (bHasCategories)
{
lstDocs.ReadDependances(CRelationDocumentGED_Categorie.c_nomTable);
foreach (CDocumentGED doc in lstDocs)
{
int nNbCats = 0;
foreach (CRelationDocumentGED_Categorie rel in doc.RelationsCategories)
{
if (setCats.Contains((int)rel.Row[CCategorieGED.c_champId]))
{
nNbCats++;
}
}
if (nNbCats == lstCategories.Count())
{
int nTmp = 0;
if (!dicDocs.ContainsKey(doc))
{
dicDocs[doc] = 1;
}
else
{
nTmp = dicDocs[doc];
dicDocs[doc] = nTmp + 1;
}
}
}
}
else
{
foreach (CDocumentGED doc in lstDocs)
{
if (!dicDocs.ContainsKey(doc))
{
dicDocs[doc] = 1;
}
else
{
dicDocs[doc] = dicDocs[doc] + 1;
}
}
}
}
List <CDocumentGED> lstFinale = new List <CDocumentGED>();
int nObjectif = lstObjets.Count();
foreach (KeyValuePair <CDocumentGED, int> kv in dicDocs)
{
if (kv.Value == nObjectif)
{
lstFinale.Add(kv.Key);
}
}
lstFinale.Sort((x, y) => x.Libelle.CompareTo(y.Libelle));
return(lstFinale.AsReadOnly());
}
//----------------------------------------------------------------------------------
public CResultAErreur ExportSimple(int nIdSession, IEnumerable list, ref DataSet ds, IIndicateurProgression indicateur)
{
if (m_cacheValeurs == null)
{
m_cacheValeurs = new CCacheValeursProprietes();
}
DateTime dt = DateTime.Now;
CResultAErreur result = CResultAErreur.True;
if (list != null && !(list is CListeObjetsDonnees))
{
result.EmpileErreur(I.T("Impossible to use a simple export with something other than a Data Object list|102"));
return(result);
}
CListeObjetsDonnees listeObjets = (CListeObjetsDonnees)list;
CContexteDonnee contexteDestination = new CContexteDonnee(nIdSession, true, false);
result = contexteDestination.SetVersionDeTravail(listeObjets.ContexteDonnee.IdVersionDeTravail, false);
if (!result)
{
return(result);
}
contexteDestination.EnforceConstraints = false; //Ca gagne un temps fou !!!
ds = contexteDestination;
//Crée la table principale
DataTable tablePrincipale = contexteDestination.GetTableSafe(CContexteDonnee.GetNomTableForType(m_typeSource));
if (tablePrincipale == null)
{
result.EmpileErreur(I.T("Error during the creation of the main table|103"));
return(result);
}
if (listeObjets != null)
{
//Exporte les objets dans la table principale
foreach (CObjetDonnee objet in listeObjets)
{
tablePrincipale.ImportRow(objet.Row.Row);
}
}
foreach (C2iChampExport champ in Table.Champs)
//Crée les colonnes calculées et champs custom
{
result = CreateChampInTable(champ, tablePrincipale);
if (!result)
{
result.EmpileErreur(I.T("Error during field @1 creation|104", champ.NomChamp));
return(result);
}
}
//Crée les autres tables
foreach (C2iTableExport tableFille in Table.TablesFilles)
{
CreateTableSimpleInDataset(tableFille, contexteDestination, m_typeSource);
}
foreach (DataTable table in contexteDestination.Tables)
{
ArrayList lstColsToDelete = new ArrayList();
foreach (DataColumn col in table.Columns)
{
if (col.DataType == typeof(CDonneeBinaireInRow))
{
lstColsToDelete.Add(col);
}
}
foreach (DataColumn col in lstColsToDelete)
{
table.Columns.Remove(col);
}
}
if (listeObjets == null)
{
AddTablesCalculees(contexteDestination, null);
}
if (listeObjets == null)
{
return(result);
}
CListeObjetsDonnees listeDestination = new CListeObjetsDonnees(contexteDestination, m_typeSource, false);
listeDestination.InterditLectureInDB = true;
//Lit les dépendances dans le contexte
//Récupère toutes les sous tables nécéssaires
string[] definitionsOrigines = GetDependancesDeTableSimple(listeObjets.ContexteDonnee);
Hashtable tableDependances = new Hashtable();
foreach (string def in definitionsOrigines)
{
tableDependances[def] = true;
}
string[] strDependances = new string[tableDependances.Count];
int nDependance = 0;
foreach (string strDependance in tableDependances.Keys)
{
strDependances[nDependance] = strDependance;
nDependance++;
}
listeDestination.ReadDependances(strDependances);
//Et voila, le tour est joué, toutes les données sont dans le dataset de destination
//Il manque juste les compositions des éléments nouveaux
if (listeObjets != null)
{
//Exporte les compositions des objets nouveaux
foreach (CObjetDonnee objet in listeObjets)
{
if (objet.IsNew()) //Si nouveau, charge directement toutes ses données
{
objet.ContexteDonnee.CopieRowTo(objet.Row.Row, contexteDestination, true, false, false);
}
}
}
//S'assure que toutes les données sont lues
foreach (DataTable table in contexteDestination.Tables)
{
DataView view = new DataView(table);
view.RowFilter = CContexteDonnee.c_colIsToRead + "=1";
foreach (DataRowView rowView in view)
{
contexteDestination.ReadRow(rowView.Row);
}
}
//Ramène les champs calculés
List <ITableExport> toutesLesTables = ToutesLesTables();
m_cacheValeurs.CacheEnabled = true;
int nNbTotalPrincipal = tablePrincipale.Rows.Count;
//Récupère les champs par ID
//Id->Nom du champ
Dictionary <int, CChampCustom> dicoChamps = new Dictionary <int, CChampCustom>();
CListeObjetsDonnees listeChamps = new CListeObjetsDonnees(contexteDestination, typeof(CChampCustom));
foreach (CChampCustom champ in listeChamps)
{
dicoChamps[champ.Id] = champ;
}
//Liste des tables à conserver au final
Hashtable tableTablesAConserver = new Hashtable();
foreach (C2iTableExport table in toutesLesTables)
{
string strNomTable = "";
DataTable tableDestination = tablePrincipale;
if (table.ChampOrigine != null)
{
strNomTable = CContexteDonnee.GetNomTableForType(table.ChampOrigine.TypeDonnee.TypeDotNetNatif);
tableDestination = contexteDestination.Tables[strNomTable];
}
if (tableDestination != null)
{
tableTablesAConserver[tableDestination.TableName] = true;
List <C2iChampExport> champsCalcules = new List <C2iChampExport>();
List <C2iChampExport> champsCustoms = new List <C2iChampExport>();
foreach (C2iChampExport champ in table.Champs)
{
if (champ.Origine is C2iOrigineChampExportExpression)
{
champsCalcules.Add(champ);
}
if (champ.Origine is C2iOrigineChampExportChampCustom)
{
champsCustoms.Add(champ);
}
}
if (champsCalcules.Count != 0)
{
Type tp = CContexteDonnee.GetTypeForTable(tableDestination.TableName);
foreach (DataRow row in tableDestination.Rows)
{
#if PDA
CObjetDonnee objet = (CObjetDonnee)Activator.CreateInstance(tp);
objet.SetRow(row);
#else
object objet = Activator.CreateInstance(tp, new object[] { row });
#endif
foreach (C2iChampExport chp in champsCalcules)
{
if (chp.Origine is C2iOrigineChampExportExpression)
{
object valeur = chp.GetValeur(objet, m_cacheValeurs, null);
if (valeur == null)
{
valeur = DBNull.Value;
}
row[chp.NomChamp] = valeur;
}
}
m_cacheValeurs.ResetCache( );
}
}
if (champsCustoms.Count > 0)
{
Type tp = CContexteDonnee.GetTypeForTable(tableDestination.TableName);
if (typeof(IObjetDonneeAChamps).IsAssignableFrom(tp))
{
IObjetDonneeAChamps element = (IObjetDonneeAChamps)Activator.CreateInstance(tp, contexteDestination);
string strTableValeursChamps = element.GetNomTableRelationToChamps();
Type tpValeursChamps = CContexteDonnee.GetTypeForTable(strTableValeursChamps);
//Travaille les valeurs de champs customs par paquet de 500;
int nTaillePaquet = 500;
int nMax = tableDestination.Rows.Count;
string strChampId = tableDestination.PrimaryKey[0].ColumnName;
for (int nPaquet = 0; nPaquet < nMax; nPaquet += nTaillePaquet)
{
StringBuilder bl = new StringBuilder();
int nFin = Math.Min(nMax, nPaquet + nTaillePaquet);
for (int nRow = nPaquet; nRow < nFin; nRow++)
{
bl.Append(tableDestination.Rows[nRow][strChampId]);
bl.Append(',');
}
if (bl.Length > 0)
{
bl.Remove(bl.Length - 1, 1);
string strIds = bl.ToString();
foreach (C2iChampExport champACustom in champsCustoms)
{
C2iOrigineChampExportChampCustom origineChamp = (C2iOrigineChampExportChampCustom)champACustom.Origine;
//C'est un élément à champ, donc, va requeter dans les champs customs pour avoir les
//valeurs
CListeObjetsDonnees listeValeurs = new CListeObjetsDonnees(contexteDestination, tpValeursChamps);
StringBuilder blIdsChamps = new StringBuilder();
foreach (int nId in origineChamp.IdsChampCustom)
{
blIdsChamps.Append(nId);
blIdsChamps.Append(',');
}
if (blIdsChamps.Length > 0)
{
blIdsChamps.Remove(blIdsChamps.Length - 1, 1);
listeValeurs.Filtre = new CFiltreData(
CChampCustom.c_champId + " in (" + blIdsChamps.ToString() + ") and " +
strChampId + " in (" + strIds + ")");
listeValeurs.AssureLectureFaite();
//On n'a plus qu'à rebasculer les valeurs dans la table
foreach (CRelationElementAChamp_ChampCustom valeur in listeValeurs)
{
try
{
DataRow rowAttachee = tableDestination.Rows.Find(valeur.Row[strChampId]);
if (rowAttachee != null)
{
object valTmp = valeur.Valeur;
if (valTmp == null)
{
valTmp = DBNull.Value;
}
rowAttachee[c_strPrefixeChampCustom + valeur.ChampCustom.Nom] = valTmp;
}
}
catch
{ }
}
}
}
}
}
}
}
}
}
m_cacheValeurs.ResetCache();
ArrayList lstTablesToDelete = new ArrayList();
foreach (DataTable table in contexteDestination.Tables)
{
if (tableTablesAConserver[table.TableName] == null)
{
lstTablesToDelete.Add(table);
}
}
foreach (DataTable table in lstTablesToDelete)
{
contexteDestination.SupprimeTableEtContraintes(table);
}
AddTablesCalculees(contexteDestination, null);
return(result);
}
//----------------------------------------------------------------------------------------------------
public IDonneeSynchronisationMediation GetUpdatesForProxy(int nIdProxy, int nIdLastSyncSession)
{
using (CSessionClient session = CSessionClient.CreateInstance())
{
CResultAErreur result = session.OpenSession(new CAuthentificationSessionProcess());
if (!result)
{
return(null);
}
using (CContexteDonneesSynchro ctx = new CContexteDonneesSynchro(session.IdSession, true))
{
CSc2iDataServer connexionManager = CSc2iDataServer.GetInstance();
IDatabaseConnexionSynchronisable cnxSync = connexionManager.GetDatabaseConnexion(session.IdSession, typeof(CTypeAgentSnmpServeur)) as IDatabaseConnexionSynchronisable;
if (cnxSync == null)
{
return(null);
}
cnxSync.IncrementeSyncSession();
int nIdSyncMax = cnxSync.IdSyncSession - 1;
CFiltresSynchronisation filtres = new CFiltresSynchronisation();
filtres.AddFiltreForTable(CTypeAlarme.c_nomTable, null, false);
filtres.AddFiltreForTable(CSeveriteAlarme.c_nomTable, null, false);
filtres.AddFiltreForTable(CTypeAgentSnmp.c_nomTable, null, false);
filtres.AddFiltreForTable(CAgentSnmp.c_nomTable,
new CFiltreData(CSnmpProxyInDb.c_champId + "=@1",
nIdProxy)
, false);
filtres.AddFiltreForTable(CTypeEntiteSnmp.c_nomTable, null, false);
filtres.AddFiltreForTable(CEntiteSnmp.c_nomTable, new CFiltreDataAvance(
CEntiteSnmp.c_nomTable,
CAgentSnmp.c_nomTable + "." +
CSnmpProxyInDb.c_champId + "=@1",
nIdProxy), false);
filtres.AddFiltreForTable(CRelationTypeEntiteSnmp_ChampCustom.c_nomTable, null, false);
filtres.AddFiltreForTable(CRelationEntiteSnmp_ChampCustom.c_nomTable,
new CFiltreDataAvance(CRelationEntiteSnmp_ChampCustom.c_nomTable,
CEntiteSnmp.c_nomTable + "." +
CAgentSnmp.c_nomTable + "." +
CSnmpProxyInDb.c_champId + "=@1",
nIdProxy), false);
// Prend uniquement les Filtrages d'alarme compris entre les dates de validité et marqués Enabled
filtres.AddFiltreForTable(CParametrageFiltrageAlarmes.c_nomTable,
new CFiltreData(
CParametrageFiltrageAlarmes.c_champIsActif + " = @1 AND " +
CParametrageFiltrageAlarmes.c_champDateDebutValidite + " <= @2 AND " +
CParametrageFiltrageAlarmes.c_champDateFinValidite + " > @2",
true,
DateTime.Now.Date), false);
filtres.AddFiltreForTable(CCategorieMasquageAlarme.c_nomTable, null, false);
DateTime dt = DateTime.Now;
// Créer le MemoryDB
bool bHasData = false;
result = ctx.FillWithModifsFromVersion(nIdLastSyncSession, nIdSyncMax, ref bHasData, filtres, true);
if (!result)
{
return(null);
}
TimeSpan sp = DateTime.Now - dt;
Console.WriteLine("Lecture modifs médiation : " + sp.TotalMilliseconds);
dt = DateTime.Now;
CDonneesSynchronisationMediation donneesSynchro = new CDonneesSynchronisationMediation(
CMemoryDbPourSupervision.GetMemoryDb(ctx), nIdSyncMax);
CListeObjetsDonnees lstObjets = new CListeObjetsDonnees(ctx, typeof(CSeveriteAlarme));
lstObjets.InterditLectureInDB = true;
foreach (CSeveriteAlarme severite in lstObjets)
{
severite.GetTypeForSupervision(donneesSynchro.Database);
}
lstObjets = new CListeObjetsDonnees(ctx, typeof(CTypeAlarme));
lstObjets.InterditLectureInDB = true;
foreach (CTypeAlarme type in lstObjets)
{
type.GetTypeForSupervision(donneesSynchro.Database, true);
}
lstObjets = new CListeObjetsDonnees(ctx, typeof(CTypeAgentSnmp));
lstObjets.InterditLectureInDB = true;
lstObjets.ReadDependances("TypesEntites");
foreach (CTypeAgentSnmp type in lstObjets)
{
type.GetTypeAgentPourSupervision(donneesSynchro.Database);
}
lstObjets = new CListeObjetsDonnees(ctx, typeof(CAgentSnmp));
lstObjets.InterditLectureInDB = true;
lstObjets.ReadDependances("EntitesSnmp", "EntitesSnmp.RelationsChampsCustom",
"EntitesSnmp.SiteSupervise",
"EntitesSnmp.EquipementLogiqueSupervise",
"EntitesSnmp.EquipementLogiqueSupervise.Site",
"EntitesSnmp.LienReseauSupervise");
foreach (CAgentSnmp agent in lstObjets)
{
agent.GetAgentPourSupervision(donneesSynchro.Database, true);
}
lstObjets = new CListeObjetsDonnees(ctx, typeof(CParametrageFiltrageAlarmes));
lstObjets.InterditLectureInDB = true;
foreach (CParametrageFiltrageAlarmes parametreFiltre in lstObjets)
{
parametreFiltre.GetLocalParametrageForSupervision(donneesSynchro.Database);
}
lstObjets = new CListeObjetsDonnees(ctx, typeof(CCategorieMasquageAlarme));
lstObjets.InterditLectureInDB = true;
foreach (CCategorieMasquageAlarme categorie in lstObjets)
{
categorie.GetLocalCategorieForSupervision(donneesSynchro.Database);
}
//S'assure que les entités des valeurs de champ entité sont chargés
lstObjets = new CListeObjetsDonnees(ctx, typeof(CRelationEntiteSnmp_ChampCustom));
lstObjets.InterditLectureInDB = true;
foreach (CRelationEntiteSnmp_ChampCustom rel in lstObjets)
{
if (rel != null && rel.ElementAChamps != null)
{
((CObjetDonnee)rel.ElementAChamps).AssureData();
}
}
lstObjets = new CListeObjetsDonnees(ctx, typeof(CEntiteSnmp));
lstObjets.InterditLectureInDB = true;
foreach (CEntiteSnmp entite in lstObjets)
{
CTypeEntiteSnmp typeEntite = entite.TypeEntiteSnmp;
futurocom.snmp.entitesnmp.CTypeEntiteSnmpPourSupervision te = typeEntite.GetTypeEntitePourSupervision(donneesSynchro.Database, true);
entite.GetEntitePourSupervision(te);
}
sp = DateTime.Now - dt;
Console.WriteLine("Intégration modifs médiation : " + sp.TotalMilliseconds);
return(donneesSynchro);
}
}
}
//-------------------------------------
/// <summary>
/// Retourne tous les fils qui étaient affecté à l'objet à l'époque
/// </summary>
/// <param name="objet"></param>
/// <param name="relationFille"></param>
/// <returns></returns>
public int[] GetIdsChildsHistoriques(CObjetDonneeAIdNumerique objet, CInfoRelation relationFille)
{
Type tpFils = CContexteDonnee.GetTypeForTable(relationFille.TableFille);
if (!typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpFils))
{
return(new int[0]);
}
CChampPourVersionInDb champFille = new CChampPourVersionInDb(relationFille.ChampsFille[0], "");
//Recherche toutes les modifications de la propriété fille
CListeObjetsDonnees listeModifsFilles = new CListeObjetsDonnees(objet.ContexteDonnee, typeof(CVersionDonneesObjetOperation));
listeModifsFilles.Filtre = new CFiltreDataAvance(
CVersionDonneesObjetOperation.c_nomTable,
CVersionDonneesObjetOperation.c_champChamp + "=@1 and " +
CVersionDonneesObjetOperation.c_champTypeChamp + "=@2 and " +
CVersionDonneesObjet.c_nomTable + "." +
CVersionDonneesObjet.c_champTypeElement + "=@3 and " +
CVersionDonneesObjet.c_nomTable + "." +
CVersionDonnees.c_nomTable + "." +
CVersionDonnees.c_champTypeVersion + "=@4 and " +
CVersionDonneesObjet.c_nomTable + "." +
CVersionDonnees.c_champId + ">=@5",
champFille.FieldKey,
champFille.TypeChampString,
tpFils.ToString(),
(int)CTypeVersion.TypeVersion.Archive,
Id);
listeModifsFilles.Tri = CVersionDonneesObjetOperation.c_champId + " desc";
listeModifsFilles.ReadDependances("VersionObjet");
ArrayList lstFils = new ArrayList();
//Remplit la liste des fils avec les fils actuels
//Récupère la liste de tous les fils actuels
//et supprimés depuis. En effet, un element supprimé depuis cette version mais qui est
//toujours lié à l'objet était donc lié à l'objet à l'époque
C2iRequeteAvancee requete = new C2iRequeteAvancee(-1);
requete.TableInterrogee = relationFille.TableFille;
C2iChampDeRequete champDeRequete = new C2iChampDeRequete("ID",
new CSourceDeChampDeRequete(objet.ContexteDonnee.GetTableSafe(relationFille.TableFille).PrimaryKey[0].ColumnName),
typeof(int),
OperationsAgregation.None,
true);
requete.ListeChamps.Add(champDeRequete);
CFiltreData filtre = new CFiltreData(relationFille.ChampsFille[0] + "=@1 and (" +
CSc2iDataConst.c_champIdVersion + " is null or " +
CSc2iDataConst.c_champIdVersion + ">=@2)",
objet.Id,
Id);
filtre.IgnorerVersionDeContexte = true;
requete.FiltreAAppliquer = filtre;
CResultAErreur result = requete.ExecuteRequete(objet.ContexteDonnee.IdSession);
if (result)
{
foreach (DataRow row in ((DataTable)result.Data).Rows)
{
lstFils.Add(row[0]);
}
}
foreach (CVersionDonneesObjetOperation data in listeModifsFilles)
{
if (data.GetValeur() is int && (int)data.GetValeur() == objet.Id)
{
if (!lstFils.Contains(data.VersionObjet.IdElement))
{
lstFils.Add(data.VersionObjet.IdElement);
}
}
else
{
lstFils.Remove(data.VersionObjet.IdElement);
}
}
//Toutes les entités créées après la version ont également été ajoutées,
//Donc n'y étaient pas
if (lstFils.Count > 0)
{
StringBuilder builder = new StringBuilder();
foreach (int nId in lstFils)
{
builder.Append(nId.ToString());
builder.Append(",");
}
string strIds = builder.ToString();
strIds = strIds.Substring(0, strIds.Length - 1);
requete = new C2iRequeteAvancee(-1);
requete.TableInterrogee = CVersionDonneesObjet.c_nomTable;
requete.FiltreAAppliquer = new CFiltreData(
CVersionDonneesObjet.c_champIdElement + " in (" + strIds + ") and " +
CVersionDonneesObjet.c_champTypeElement + "=@1 and " +
CVersionDonneesObjet.c_champTypeOperation + "=@2 and " +
CVersionDonnees.c_champId + ">=@3",
tpFils.ToString(),
CTypeOperationSurObjet.TypeOperation.Ajout,
Id);
requete.FiltreAAppliquer.IgnorerVersionDeContexte = true;
requete.ListeChamps.Add(new C2iChampDeRequete("Id",
new CSourceDeChampDeRequete(CVersionDonneesObjet.c_champIdElement),
typeof(int),
OperationsAgregation.None,
true));
result = requete.ExecuteRequete(ContexteDonnee.IdSession);
if (result)
{
foreach (DataRow row in ((DataTable)result.Data).Rows)
{
lstFils.Remove(row[0]);
}
}
}
return((int[])lstFils.ToArray(typeof(int)));
}
public void UpdateOnglets()
{
this.SuspendDrawing();
try
{
/*if (!LockEdition)
* {
* //valide les modifs car on va tout supprimer
* MAJ_Champs();
* }*/
Crownwood.Magic.Controls.TabPage pageSelect = this.SelectedTab;
m_bIsInitializing = true;
Hashtable tablePagesToHide = new Hashtable();
ArrayList pages = new ArrayList(TabPages);
foreach (Crownwood.Magic.Controls.TabPage page in pages)
{
m_tablePagesInit[page] = false;
tablePagesToHide[page] = true;
TabPages.Remove(page);
}
if (m_elementEdite == null)
{
return;
}
/* YK : On obtient la session de l'objet en cours d'édition au lieur de la session par défaut */
CSessionClient session = null;
IObjetDonneeAIdNumerique objetDonnee = m_elementEdite as IObjetDonneeAIdNumerique;
if (objetDonnee != null)
{
session = CSessionClient.GetSessionForIdSession(objetDonnee.ContexteDonnee.IdSession);
}
else
{
session = CSessionClient.GetSessionUnique();
}
ArrayList lstFormulaires = new ArrayList(m_listeFormulaires);
lstFormulaires.Sort(new CSorterFormulaires());
//Lit les champs liés et leurs valeurs
StringBuilder bl = new StringBuilder();
foreach (CFormulaire formulaire in lstFormulaires)
{
bl.Append(formulaire.Id);
bl.Append(",");
}
if (bl.Length > 0)
{
bl.Remove(bl.Length - 1, 1);
CListeObjetsDonnees lst = new CListeObjetsDonnees(((CFormulaire)lstFormulaires[0]).ContexteDonnee, typeof(CFormulaire));
lst.Filtre = new CFiltreData(CFormulaire.c_champId + " in (" + bl.ToString() + ")");
lst.AssureLectureFaite();
lst.ReadDependances("RelationsChamps", "RelationsChamps.Champ", "RelationsChamps.Champ.ListeValeurs");
}
foreach (CFormulaire formulaire in lstFormulaires)
{
Crownwood.Magic.Controls.TabPage page = null;
m_tableIdFormulaireToTabPage.TryGetValue(formulaire.Id, out page);
CCreateur2iFormulaireObjetDonnee createur = null;
if (page == null)
{
C2iWndFenetre wnd = formulaire.Formulaire;
if (wnd != null)
{
page = new Crownwood.Magic.Controls.TabPage(wnd.Text);
page.Name = formulaire.IdUniversel;
if (wnd.Text == "")
{
page.Title = formulaire.Libelle;
}
TabPages.Add(page);
if (m_tableCreateurs.ContainsKey(page))
{
m_tableCreateurs.Remove(page);
}
m_tablePageTo2iWnd[page] = wnd;
m_tableIdFormulaireToTabPage[formulaire.Id] = page;
m_tablePageToIdFormulaire[page] = formulaire.Id;
}
}
else
{
m_tableCreateurs.TryGetValue(page, out createur);
}
if (page != null)
{
if (!TabPages.Contains(page))
{
TabPages.Add(page);
}
tablePagesToHide.Remove(page);
}
}
/*CChampCustom[] champs = ElementEdite.GetChampsHorsFormulaire();
* if ( champs.Length != 0 )
* {
* UpdatePageChamps( nRest );
* if ( m_pageGrid != null )
* tablePagesToHide.Remove(m_pageGrid);
* }*/
foreach (Crownwood.Magic.Controls.TabPage pageToDel in tablePagesToHide.Keys)
{
if (TabPages.Contains(pageToDel))
{
TabPages.Remove(pageToDel);
}
}
if (TabPages.Count == 1)
{
this.HideTabsMode = Crownwood.Magic.Controls.TabControl.HideTabsModes.HideAlways;
}
else
{
this.HideTabsMode = Crownwood.Magic.Controls.TabControl.HideTabsModes.ShowAlways;
}
if (TabPages.Contains(pageSelect))
{
SelectedTab = pageSelect;
}
if (SelectedTab != null)
{
InitPageWithObjetCourant(SelectedTab);
}
}
finally
{
this.ResumeDrawing();
}
m_bIsInitializing = false;
}
public CResultAErreur Execute(int nIdSession, Hashtable valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee contexte = new CContexteDonnee(nIdSession, true, false))
{
try
{
CHandlerEvenementServeur.SuspendGestionnaire(true);
contexte.EnableTraitementsAvantSauvegarde = false;
CListeObjetsDonnees lstInterventions = new CListeObjetsDonnees(contexte, typeof(CIntervention));
//*** DEBUG ***
//lstInterventions.Filtre = new CFiltreData(
// CIntervention.c_champId + " > @1 ",
// 8500);
int compteur = lstInterventions.CountNoLoad;
// FIN DEBUG
lstInterventions.ReadDependances("PhaseTicket.Ticket.RelationsChampsCustom");
lstInterventions.ReadDependances("RelationsIntervenants");
foreach (CIntervention inter in lstInterventions)
{
compteur--;
CPhaseTicket phase = inter.PhaseTicket;
if (phase != null)
{
// Copier les compte rendu pour OTA depuis l'intervention vers le ticket
CTicket ticketLié = phase.Ticket;
// 113 = Id du champ [Compte rendu d'Intervention modifié]
string strCompteRendu = (string)inter.GetValeurChamp(113);
// 114 = Id du champ [Compte rendu résumé pour OTA]
ticketLié.SetValeurChamp(144, strCompteRendu);
// Affecter le technicien sur les Phases de ticket
CActeur acteur = null;
if (phase.GetValeurChamp(146) == null)
{
foreach (CIntervention_Intervenant rel in inter.RelationsIntervenants)
{
acteur = rel.Intervenant;
// 146 = Id du champ [Technicien affecté] sur Phase
if (acteur != null)
{
phase.SetValeurChamp(146, acteur);
break;
}
}
}
}
}
result = contexte.SaveAll(true);
if (!result)
{
result.EmpileErreur("Erreur de sauvegarde des données");
return(result);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
CHandlerEvenementServeur.SuspendGestionnaire(false);
}
}
return(result);
}
//------------------------------------------------------------------------------------------
public void ReadArbre(CListeObjetsDonnees listeSource, CListeObjetsDonnees.CArbreProps arbre, List <string> lstPaquetsALire)
{
string strIdChamp = "";
string strPropriete = "";
string strCle = "";
if (listeSource.Count == 0)
{
return;
}
bool bFromEntiteToChamp = false;
if (!CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(arbre.ProprietePrincipale, ref strCle, ref strPropriete))
{
return;
}
if (!CInfoRelationComposantFiltreEntiteToChampEntite.DecomposeNomPropriete(strPropriete, ref strIdChamp, ref bFromEntiteToChamp))
{
//c'est une relation vers des valeurs de champ qui pointent sur cette valeur.
//Ignore, et traite tout dans le composant suivant qui est un Entité to champ à l'envers
listeSource.ReadDependances(arbre);
return;
}
//On a affaire à une liste source qui contient des valeurs qui sont pointées
//par des valeurs de champs, et on veut les éléments qui pointent sur ces valeurs de champs
CChampCustom champ = new CChampCustom(listeSource.ContexteDonnee);
CDbKey dbKeyChamp = CDbKey.CreateFromStringValue(strIdChamp);
if (!champ.ReadIfExists(dbKeyChamp))
{
return;
}
//Vérifie que la liste source est bien du type de données du champ custom
if (champ.TypeDonnee.TypeDotNetNatif != listeSource.TypeObjets)
{
return;
}
IObjetDonneeAIdNumerique obj = listeSource[0] as IObjetDonneeAIdNumerique;
if (obj == null)
{
return;
}
string strChampId = obj.GetChampId();
if (lstPaquetsALire == null)
{
lstPaquetsALire = listeSource.GetPaquetsPourLectureFils(strChampId, null);
}
//Trouve le type des éléments à champs
Type typeElementsFinaux = champ.Role.TypeAssocie;
//Trouve le type des relations aux elementAchamp_ChampCustom
IObjetDonneeAChamps elt = Activator.CreateInstance(typeElementsFinaux, new object[] { listeSource.ContexteDonnee }) as IObjetDonneeAChamps;
if (elt == null)
{
return;
}
string strNomTableRelToChamp = elt.GetNomTableRelationToChamps();
Type tpRelToChamp = CContexteDonnee.GetTypeForTable(strNomTableRelToChamp);
if (tpRelToChamp == null)
{
return;
}
foreach (string strPaquet in lstPaquetsALire)
{
CListeObjetsDonnees lst = new CListeObjetsDonnees(listeSource.ContexteDonnee, typeElementsFinaux);
//TESTDBKEYTODO
string strChampCustomId = dbKeyChamp.IsNumericalId() ? CChampCustom.c_champId : CObjetDonnee.c_champIdUniversel;
lst.Filtre = new CFiltreDataAvance(
CContexteDonnee.GetNomTableForType(typeElementsFinaux),
strNomTableRelToChamp + "." + strChampCustomId + "=@1 and " +
strNomTableRelToChamp + "." + CRelationElementAChamp_ChampCustom.c_champValeurInt + " in " +
strPaquet,
dbKeyChamp.GetValeurInDb());
lst.AssureLectureFaite();
lst.ReadDependances(arbre);
}
}
private CResultAErreur ImputeDureeSurActivite(CFractionIntervention fraction)
{
CResultAErreur result = CResultAErreur.True;
if (fraction.DateDebut == null ||
fraction.DateFin == null)
{
return(result);
}
if (fraction.TempsDeTravail == null)
{
return(result);
}
Hashtable tableToDelete = new Hashtable();
//Stocke la liste des relations qui étaient présentes avant le travail
//et les note comme étant à supprimer
foreach (CIntervention_ActiviteActeur rel in fraction.RelationsActivite)
{
tableToDelete[rel] = true;
}
CTypeActiviteActeur typeActivite = fraction.Intervention.TypeIntervention.TypeActiviteActeur;
bool bAvecSite = typeActivite.SiteObligatoire;
if (typeActivite != null)
{
//Evalue les valeurs des champs custom pour l'activite
CParametreRemplissageActiviteParIntervention parametreRemplissage = fraction.Intervention.TypeIntervention.ParametreRemplissageActivite;
Dictionary <CChampCustom, object> valeursChamps = new Dictionary <CChampCustom, object>();
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(fraction);
if (parametreRemplissage != null)
{
foreach (CRemplisssageChampActiviteActeur remplissage in parametreRemplissage.ListeRemplissage)
{
CChampCustom champ = new CChampCustom(fraction.ContexteDonnee);
if (champ.ReadIfExists(remplissage.IdChampCustom))
{
C2iExpression formule = remplissage.Formule;
if (formule != null)
{
result = formule.Eval(ctxEval);
if (result)
{
valeursChamps[champ] = result.Data;
}
}
}
}
}
foreach (CIntervention_Intervenant relIntervenant in fraction.Intervention.RelationsIntervenants)
{
DateTime dt = ((DateTime)fraction.DateDebut).Date;
//Attention, si on est sur une fraction sur plusieurs jours, le
//pb est que la durée saisie (retenue pour l'intervention) peut
//ne pas être égale aux différents jours d'imputation,
//on réparti donc la durée de manière homogène sur les différents
//Jour en faisant un prorata de chaque jour
double fDureeAImputer = (double)fraction.TempsDeTravail;
double fDureeReelle = (double)fraction.DureeReelle;
while (dt < (DateTime)fraction.DateFin && fDureeAImputer > 0)
{
//Cherche pour l'intervention ses activités du bon type
CFiltreData filtre = new CFiltreDataAvance(CActiviteActeur.c_nomTable,
CTypeActiviteActeur.c_champId + "=@1 and " +
CActiviteActeur.c_champDate + ">=@2 and " +
CActiviteActeur.c_champDate + "<@3 and " +
"Has(" + CIntervention_ActiviteActeur.c_nomTable + "." +
CIntervention_ActiviteActeur.c_champId + ") and " +
CActeur.c_champId + "=@4",
typeActivite.Id,
dt,
dt.AddDays(1),
relIntervenant.Intervenant.Id);
if (bAvecSite)
{
filtre = CFiltreData.GetAndFiltre(filtre,
new CFiltreData(CSite.c_champId + "=@1",
fraction.Intervention.Site.Id));
}
CListeObjetsDonnees listeActivites = new CListeObjetsDonnees(fraction.ContexteDonnee, typeof(CActiviteActeur));
listeActivites.Filtre = filtre;
listeActivites.ReadDependances("RelationsInterventions");
CActiviteActeur activiteRetenue = null;
CIntervention_ActiviteActeur relRetenue = null;
foreach (CActiviteActeur activite in listeActivites)
{
bool bPrendre = true;
foreach (KeyValuePair <CChampCustom, object> chpValeur in valeursChamps)
{
object valDeAct = activite.GetValeurChamp(chpValeur.Key.Id);
if (valDeAct == null && chpValeur.Value != null)
{
bPrendre = false;
break;
}
else if (chpValeur.Value == null && valDeAct != null)
{
bPrendre = false;
break;
}
else if (chpValeur.Value != null && !chpValeur.Value.Equals(valDeAct))
{
bPrendre = false;
break;
}
}
if (bPrendre)
{
activiteRetenue = activite;
relRetenue = null;
foreach (CIntervention_ActiviteActeur relInter in activiteRetenue.RelationsInterventions)
{
//Si l'activité est directement liée à cette fraction, prend celle ci de préférence
if (relInter.FractionIntervention.Id == fraction.Id)
{
relRetenue = relInter;
break;
}
}
}
}
if (activiteRetenue == null)
{
//Création de l'activite
activiteRetenue = new CActiviteActeur(fraction.ContexteDonnee);
activiteRetenue.CreateNewInCurrentContexte();
activiteRetenue.TypeActiviteActeur = typeActivite;
activiteRetenue.Acteur = relIntervenant.Intervenant;
activiteRetenue.Date = dt;
activiteRetenue.Duree = 0;
if (bAvecSite)
{
activiteRetenue.Site = fraction.Intervention.Site;
}
foreach (KeyValuePair <CChampCustom, object> valChamp in valeursChamps)
{
activiteRetenue.SetValeurChamp(valChamp.Key.Id, valChamp.Value);
}
}
if (relRetenue == null)
{
//Création de la relation à l'interventation
relRetenue = new CIntervention_ActiviteActeur(fraction.ContexteDonnee);
relRetenue.ActiviteActeur = activiteRetenue;
relRetenue.DureeImputee = 0;
relRetenue.FractionIntervention = fraction;
}
//Note que cette relation ne doit pas être supprimée
tableToDelete[relRetenue] = false;
double fDureeForThis = 0;
if (dt == fraction.DateFin.Value.Date)
{
fDureeForThis = fDureeAImputer; //On affecte le reste
}
else
{
if (dt == fraction.DateDebut.Value.Date)
{
//On est sur le premier jour,
//Utilise comme référence le temps qui sépare la date
//de début de minuit
TimeSpan sp = dt.AddDays(1) - fraction.DateDebut.Value;
double fRatio = sp.TotalHours / fDureeReelle;
fDureeForThis = fRatio * fraction.TempsDeTravail.Value;
}
else
{
fDureeForThis = 24.0 / fDureeReelle * fraction.TempsDeTravail.Value;
}
//Arrondi la durée calculé à la minute
fDureeForThis = (int)fDureeForThis + (int)((fDureeForThis - (int)fDureeForThis) * 60.0 + .5) / 60.0;
}
fDureeAImputer -= fDureeForThis;
if (relRetenue.DureeImputee != fDureeForThis)
{
//Impute la durée de la fraction sur l'activité
relRetenue.ActiviteActeur.Duree -= relRetenue.DureeImputee;
relRetenue.DureeImputee = (double)fDureeForThis;
relRetenue.ActiviteActeur.Duree += fDureeForThis;
}
dt = dt.AddDays(1);
}
}
}
foreach (DictionaryEntry entry in tableToDelete)
{
if ((bool)entry.Value)
{
//Supprime la relation
CIntervention_ActiviteActeur relToDelete = (CIntervention_ActiviteActeur)entry.Key;
if (relToDelete.Row.RowState != DataRowState.Deleted)
{
CActiviteActeur activiteAncienne = relToDelete.ActiviteActeur;
//SC 10/3/2014 : La désimputation du temps de l'activité se fait dans CIntervention_activiteActeurServeur.TraitementAvantSauvegardee
//activiteAncienne.Duree -= relToDelete.DureeImputee;
result = relToDelete.Delete(true);
/*if ( result && activiteAncienne.Duree == 0 )
* result = activiteAncienne.Delete();
* if ( !result )
* return result;*/
}
}
}
return(result);
}
//------------------------------------------------------------------------
public int[] GetIdsRessourcesLevant(int nIdContrainte, CFiltreDataAvance filtreParam)
{
Hashtable tblIdsRessourcesLevant = new Hashtable();
using (CContexteDonnee contexteDonnee = new CContexteDonnee(IdSession, true, false))
{
CContrainte contrainte = new CContrainte(contexteDonnee);
if (!contrainte.ReadIfExists(nIdContrainte))
{
throw new Exception(I.T("Constraint Id @1 doesn't exist|197", nIdContrainte.ToString()));
}
// Liste des ressources levants de façon explicite (Relation directe)
CListeObjetsDonnees listeRelationRessourceFiltre = contrainte.RelationRessourceListe;
// Applique un filtre prédéfini par l'utilisateur de cette fonction
CFiltreDataAvance filtreTmp = null;
if (filtreParam != null)
{
filtreTmp = (CFiltreDataAvance)filtreParam.GetClone();
filtreTmp.ChangeTableDeBase(CRelationContrainte_Ressource.c_nomTable, CRessourceMaterielle.c_nomTable);
listeRelationRessourceFiltre.Filtre = filtreTmp;
}
foreach (CRelationContrainte_Ressource rel in listeRelationRessourceFiltre)
{
tblIdsRessourcesLevant[rel.Ressource.Id] = true;
}
if (contrainte.TypeContrainte != null)
{
// Construit une filtre avancé sur les attributs de la contrainte
CFiltreData filtreAttributsRessources = contrainte.GetFiltreForRechercheRessourcesSurAttributs();
// Liste de toutes les resssources de la base
CListeObjetsDonnees lstRessources = new CListeObjetsDonnees(contexteDonnee, typeof(CRessourceMaterielle));
// Applique le filtre d'attributs à la liste
filtreAttributsRessources = CFiltreData.GetAndFiltre(filtreAttributsRessources, filtreParam);
lstRessources.Filtre = filtreAttributsRessources;
// On obtient la liste des ressource ayant au moins un attribut en commun avec la Contrainte
// Vérifie le résultat de la recherche en fonction des options
// Si la ressource doit avoir au moins un des attributs de la contrainte
//Toutes les ressources trouvées sont bonnes !
if (!contrainte.TypeContrainte.OptionTousAttributsRessourceLevant)
{
foreach (CRessourceMaterielle res in lstRessources)
{
tblIdsRessourcesLevant[res.Id] = true;
}
}
else
{
CResultAErreur result = lstRessources.ReadDependances("AttributsListe");
if (!result)
{
throw new CExceptionErreur(result.Erreur);
}
// Sinon la ressource doit avoir tous les attributs de la contrainte
CFiltreData filtreTousLesAttributs = contrainte.GetFiltreSurAttributsRessource();
// Recherche dans la liste des resources possibles
foreach (CRessourceMaterielle res in lstRessources)
{
CListeObjetsDonnees attributsRessource = res.AttributsListe;
attributsRessource.InterditLectureInDB = true;
attributsRessource.Filtre = filtreTousLesAttributs;
string strRessource = res.Libelle;
int nNbAttribs = attributsRessource.Count;
nNbAttribs = contrainte.AttributsListe.Count;
// La ressource doit avoir tous les attributs de la contrainte
if (attributsRessource.Count == contrainte.AttributsListe.Count)
{
tblIdsRessourcesLevant[res.Id] = true;
}
}
}
}
List <int> lstRetour = new List <int>();
foreach (int nId in tblIdsRessourcesLevant.Keys)
{
lstRetour.Add(nId);
}
return(lstRetour.ToArray());
}
}
