//----------------------------------------------------------------------------------
public CResultAErreur CreateTableSimpleInDataset(C2iTableExport tableExport, CContexteDonnee contexteDest, Type typeParent)
{
CResultAErreur result = CResultAErreur.True;
PropertyInfo property = typeParent.GetProperty(tableExport.ChampOrigine.NomProprieteSansCleTypeChamp);
if (property == null)
{
result.EmpileErreur(I.T("The property @1 was not found in the @2 type|105", tableExport.ChampOrigine.NomPropriete, typeParent.ToString()));
return(result);
}
Object[] attribs = property.GetCustomAttributes(typeof(RelationAttribute), true);
Type typeObjet = null;
DataTable tableDestination = null;
if (attribs.Length != 0)
{
RelationAttribute relParente = (RelationAttribute)attribs[0];
tableDestination = contexteDest.GetTableSafe(relParente.TableMere);
typeObjet = CContexteDonnee.GetTypeForTable(relParente.TableMere);
}
else
{
attribs = property.GetCustomAttributes(typeof(RelationFilleAttribute), true);
if (attribs.Length != 0)
{
RelationFilleAttribute relFille = (RelationFilleAttribute)attribs[0];
tableDestination = contexteDest.GetTableSafe(CContexteDonnee.GetNomTableForType(relFille.TypeFille));
typeObjet = relFille.TypeFille;
}
else
{
result.EmpileErreur(I.T("The property @1 cannot be integrated into a simple export|106", tableExport.ChampOrigine.NomPropriete));
return(result);
}
}
foreach (C2iChampExport champ in tableExport.Champs)
//Crée les colonnes calculées
{
result = CreateChampInTable(champ, tableDestination);
if (!result)
{
result.EmpileErreur(I.T("Error during field @1 creation|104", champ.NomChamp));
return(result);
}
}
foreach (C2iTableExport tableFille in tableExport.TablesFilles)
{
result &= CreateTableSimpleInDataset(tableFille, contexteDest, typeObjet);
if (!result)
{
return(result);
}
}
return(result);
}
//----------------------------------------------------------
public CResultAErreur AnnuleModificationPrevisionnelle(CVersionDonneesObjet versionObjet)
{
CContexteDonnee contexte = versionObjet.ContexteDonnee;
CResultAErreur result = CResultAErreur.True;
int nIdObjet = versionObjet.IdElement;
Type typeObjet = versionObjet.TypeElement;
CVersionDonnees versionPrev = versionObjet.VersionDonnees;
int nIdVersion = versionPrev.Id;
//Vérifie que l'utilisateur peut travailler avec cette version
result = versionPrev.EnregistreEvenement(CVersionDonnees.c_eventBeforeUtiliser, true);
if (!result)
{
return(result);
}
contexte.SetVersionDeTravail(-1, false);
//Suppression de l'objet associé
string strPrimKey = contexte.GetTableSafe(CContexteDonnee.GetNomTableForType(typeObjet)).PrimaryKey[0].ColumnName;
CListeObjetsDonnees listeTmp = new CListeObjetsDonnees(contexte, typeObjet);
listeTmp.Filtre = new CFiltreData(
CSc2iDataConst.c_champIdVersion + "=@1 and " +
"(" + CSc2iDataConst.c_champOriginalId + "=@2 or " +
strPrimKey + "=@2)",
nIdVersion,
nIdObjet);
listeTmp.Filtre.IgnorerVersionDeContexte = true;
result = CObjetDonneeAIdNumerique.Delete(listeTmp);
if (!result)
{
return(result);
}
//Suppression de la version objet
result = versionObjet.Delete();
if (!result)
{
return(result);
}
//Force la modification de l'objet pour mettre à jour les versions suivantes
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)Activator.CreateInstance(typeObjet, new object[] { contexte });
if (objet.ReadIfExists(nIdObjet))
{
//Passe dans la version de l'objet
result = contexte.SetVersionDeTravail(objet.IdVersionDatabase, false);
if (!result)
{
return(result);
}
objet.Row.Row.SetModified();
}
return(result);
}
private void m_lnkDemarrer_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
CResultAErreur result = CResultAErreur.True;
try
{
C2iStructureImport structure = m_panelStructure.GetStructureFinale();
if (structure.Mappages.Select(m => m.IsCle).Count() == 0)
{
if (MessageBox.Show(I.T("Warning, You didn't select any identification field. Continue ?|20052"),
"",
MessageBoxButtons.YesNo) == DialogResult.No)
{
return;
}
}
string strFichier = m_panelStructure.NomFichier;
using (CContexteDonnee ctx = new CContexteDonnee(CSc2iWin32DataClient.ContexteCourant.IdSession, true, false))
{
ctx.SetVersionDeTravail(CSc2iWin32DataClient.ContexteCourant.IdVersionDeTravail, false);
using (CWaitCursor waiter = new CWaitCursor())
{
result = structure.Importer(strFichier, ctx);
}
if (result)
{
DataTable table = ctx.GetTableSafe(CContexteDonnee.GetNomTableForType(structure.TypeCible));
int nNbUpdate = structure.NbUpdated;
int nNbCreate = structure.NbCreated;
if (CFormAlerte.Afficher(I.T("This opération will create @1 and update @2 elements. Do you confirm this operation ?|20050",
nNbCreate.ToString(),
nNbUpdate.ToString()), EFormAlerteType.Question) == DialogResult.Yes)
{
result = ctx.SaveAll(true);
if (result)
{
CFormAlerte.Afficher(I.T("Import ended with success|20051"), EFormAlerteType.Info);
}
}
}
}
}
catch (Exception ex)
{
result.EmpileErreur(new CErreurException(ex));
}
if (!result)
{
CFormAfficheErreur.Show(result.Erreur);
}
}
//-------------------------------------------------------------------
internal static HashSet <DataRow> GetTableAgentsAMettreAJourToSnmp(CContexteDonnee ctx, bool bCreateSiNull)
{
DataTable table = ctx.Tables[CAgentSnmp.c_nomTable];
if (table == null)
{
if (!bCreateSiNull)
{
return(null);
}
ctx.GetTableSafe(CAgentSnmp.c_nomTable);
}
HashSet <DataRow> rows = table.ExtendedProperties[c_cleDataAgentsAMettreAjour] as HashSet <DataRow>;
if (rows == null && bCreateSiNull)
{
rows = new HashSet <DataRow>();
table.ExtendedProperties[c_cleDataAgentsAMettreAjour] = rows;
}
return(rows);
}
public CFiltreData GetFiltreForType(Type tp)
{
CFiltreData filtre = null;
if (
m_ArbreModules.SelectedNode != null &&
m_chkAppliquerFiltre.Checked &&
m_contexte != null &&
typeof(IObjetDonneeAIdNumerique).IsAssignableFrom(tp))
{
CModuleParametrage module = m_ArbreModules.SelectedNode.Tag as CModuleParametrage;
if (module != null)
{
CListeObjetsDonnees lst = new CListeObjetsDonnees(m_contexte, typeof(CRelationElement_ModuleParametrage));
lst.Filtre = new CFiltreDataAvance(
CRelationElement_ModuleParametrage.c_nomTable,
CRelationElement_ModuleParametrage.c_champTypeElement + "=@1 and " +
CModuleParametrage.c_nomTable + "." + CModuleParametrage.c_champCodeSystemeComplet + " like @2",
tp.ToString(),
module.CodeSystemeComplet + "%");
if (lst.Count != 0)
{
StringBuilder bl = new StringBuilder();
foreach (CRelationElement_ModuleParametrage rel in lst)
{
bl.Append(rel.IdElement);
bl.Append(';');
}
bl.Remove(bl.Length - 1, 1);
DataTable table = m_contexte.GetTableSafe(CContexteDonnee.GetNomTableForType(tp));
filtre = new CFiltreDataAvance(
CContexteDonnee.GetNomTableForType(tp),
table.PrimaryKey[0].ColumnName + " in {" +
bl.ToString() + "}");
}
}
}
return(filtre);
}
//----------------------------------------------------------
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 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);
}
//////////////////////////////////////////////////////////////////
private static void SynchroSchemaToSpv(
CContexteDonnee contexte,
Hashtable tableData,
ref CResultAErreur result)
{
if (!result)
{
return;
}
//Empèche de passer plusieurs fois
if (tableData.ContainsKey(typeof(CSynchroniseurSchemaEtGraphe)))
{
return;
}
//Pour empecher de passer plusieurs fois
tableData[typeof(CSynchroniseurSchemaEtGraphe)] = true;
//S'assure que les liens sont biens créés et que leurs schémas aussi !
CSpvLiaiServeur.PropagerCLienReseau(contexte, tableData, ref result);
if (!result)
{
return;
}
//Crée les services correspondants aux schémas modifiés
//Toute modification d'un schéma est une modification du schéma auquel il appartient
CListeObjetsDonnees lstSchemas = new CListeObjetsDonnees(contexte, typeof(CSchemaReseau), false);
lstSchemas.InterditLectureInDB = true;
foreach (CSchemaReseau schema in lstSchemas.ToArrayList())
{
CSchemaReseau tmp = schema;
while (tmp != null && tmp.Row.RowState == DataRowState.Modified)
{
tmp = tmp.SchemaParent;
if (tmp != null)
{
tmp.ForceChangementSyncSession();
}
}
}
DataTable table = contexte.Tables[CSchemaReseau.c_nomTable];
if (table == null)
{
//S'il n'y a pas de schéma, mais qu'il y a des éléments de schéma,
//force la vérification des schémas
if (contexte.Tables.Contains(CElementDeSchemaReseau.c_nomTable))
{
table = contexte.GetTableSafe(CSchemaReseau.c_nomTable);
}
}
if (table != null)
{
#region Recherche des schémas modifiés
ArrayList lst = new ArrayList(table.Rows);
//Cherche les schémas à vérifier
Dictionary <DataRow, bool> dicSchemasAVerifier = new Dictionary <DataRow, bool>();
foreach (DataRow row in lst)
{
if (row.RowState == DataRowState.Modified || row.RowState == DataRowState.Added)
{
dicSchemasAVerifier[row] = true;
}
}
DataTable tableElts = contexte.Tables[CElementDeSchemaReseau.c_nomTable];
if (tableElts != null)
{
lst = new ArrayList(tableElts.Rows);
foreach (DataRow row in lst)
{
if (row.RowState == DataRowState.Added || row.RowState == DataRowState.Modified || row.RowState == DataRowState.Deleted)
{
CElementDeSchemaReseau elt = new CElementDeSchemaReseau(row);
if (row.RowState == DataRowState.Deleted)
{
elt.VersionToReturn = DataRowVersion.Original;
}
CSchemaReseau schema = elt.SchemaReseau;
if (schema != null && schema.IsValide())
{
dicSchemasAVerifier[schema.Row] = true;
}
while (schema != null && schema.IsValide() && schema.SchemaParent != null)
{
dicSchemasAVerifier[schema.SchemaParent.Row] = true;
schema = schema.SchemaParent;
}
}
}
}
#endregion
//Passe sur tous les schémas modifiés
foreach (DataRow row in dicSchemasAVerifier.Keys)
{
#region Création du service, création des cablages
CSchemaReseau schema = new CSchemaReseau(row);
//Synchronisation du service avec le schéma
CSpvSchemaReseau spvSchema = CSpvSchemaReseau.GetObjetSpvFromObjetTimosAvecCreation(schema);
//Si le schéma correspond à un lien, force la modification de ce lien
//Pour passer dans le traitement avant sauvegarde du lien
if (schema.LienReseau != null)
{
if (schema.LienReseau.Row.RowState == DataRowState.Unchanged)
{
schema.LienReseau.ForceChangementSyncSession();//Force la modification du lien pour qu'il soit resynchronisé
}
}
#endregion
}
}
//Pour tous les schémas qui ont des éléments modifiés, s'assure que les
//Graphes des services concernés sont à jour
//Id de schéma -> true
Dictionary <int, bool> schemasAGrapheObsolete = new Dictionary <int, bool>();
table = contexte.Tables[CElementDeSchemaReseau.c_nomTable];
if (table != null)
{
ArrayList lstRows = new ArrayList(table.Rows);
foreach (DataRow row in lstRows)
{
if (row.RowState == DataRowState.Added || row.RowState == DataRowState.Deleted)
{
CElementDeSchemaReseau elt = new CElementDeSchemaReseau(row);
DataRowVersion version = DataRowVersion.Current;
if (row.RowState == DataRowState.Deleted)
{
version = DataRowVersion.Original;
}
schemasAGrapheObsolete[(int)row[CElementDeSchemaReseau.c_champIdSchemaReseauAuquelJappartiens, version]] = true;
}
}
}
table = contexte.Tables[CSchemaReseau.c_nomTable];
if (table != null)
{
ArrayList lstRows = new ArrayList(table.Rows);
foreach (DataRow row in lstRows)
{
if (row.RowState == DataRowState.Added || row.RowState == DataRowState.Modified)
{
schemasAGrapheObsolete[(int)row[CSchemaReseau.c_champId]] = true;
}
}
}
CBaseGraphesReseau baseGraphes = new CBaseGraphesReseau();
foreach (int nIdSchema in schemasAGrapheObsolete.Keys)
{
CSchemaReseau schema = new CSchemaReseau(contexte);
if (
schema.ReadIfExists(nIdSchema) &&
schema.IsValide() &&
(schema.SchemaParent == null || schema.SiteApparenance != null)) //Ne calcule pas les graphes des schémas fils, ils sont déjà integrés dans le graphe du schéma parent!
{
CSpvSchemaReseau spvSchema = CSpvSchemaReseau.GetObjetSpvFromObjetTimosAvecCreation(schema);
if (spvSchema != null)
{
result = spvSchema.RecalculeArbreOperationnelInContexte(baseGraphes);
if (!result)
{
return;
}
}
}
}
}
//----------------------------------------------------------------------------------
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);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
List <Type> lstTypesAVerifier = new List <Type>();
//Trouve tous les types héritant de CMappableTimos
foreach (Assembly ass in sc2i.common.CGestionnaireAssemblies.GetAssemblies())
{
foreach (Type tp in ass.GetTypes())
{
if (typeof(IObjetSPVAvecObjetTimos).IsAssignableFrom(tp))
{
lstTypesAVerifier.Add(tp);
}
}
}
List <string> lstTablesDansOrdre = new List <string>();
using (CContexteDonnee ctxTmp = new CContexteDonnee(contexte.IdSession, true, false))
{
foreach (Type tp in lstTypesAVerifier)
{
string strTable = CContexteDonnee.GetNomTableForType(tp);
if (strTable != null)
{
ctxTmp.GetTableSafe(strTable);
}
}
foreach (DataTable table in ctxTmp.GetTablesOrderInsert())
{
lstTablesDansOrdre.Add(table.TableName);
}
}
foreach (string strNomTable in lstTablesDansOrdre)
{
Type tp = CContexteDonnee.GetTypeForTable(strNomTable);
Type tpParent = tp;
Type[] generics = new Type[0];
while (tpParent != null && generics.Length == 0)
{
if (tpParent.IsGenericType && tpParent.GetGenericTypeDefinition() == typeof(CMappableAvecTimos <,>))
{
generics = tpParent.GetGenericArguments();
}
tpParent = tpParent.BaseType;
}
if (generics.Length == 0)
{
continue;
}
IObjetSPVAvecObjetTimos obj = Activator.CreateInstance(tp, new object[] { contexte.ContexteDonnee }) as IObjetSPVAvecObjetTimos;
Type typeTimos = obj.GetTypeObjetsTimos();
//Lit tous les objets TIMOS
CListeObjetsDonnees lstObjetsTimos = new CListeObjetsDonnees(contexte.ContexteDonnee, typeTimos);
lstObjetsTimos.AssureLectureFaite();
CListeObjetsDonnees lstObjetsSpv = new CListeObjetsDonnees(contexte.ContexteDonnee, obj.GetType());
lstObjetsSpv.AssureLectureFaite();
string strIdObjetTimosInObjetSpv = obj.GetChampIdObjetTimos();
Type tpMappable = typeof(CMappeurTimos <,>).MakeGenericType(generics);
IMappeurTimosNonGenerique mappeur = Activator.CreateInstance(tpMappable) as IMappeurTimosNonGenerique;
foreach (CObjetDonneeAIdNumerique objTimos in (CObjetDonneeAIdNumerique[])lstObjetsTimos.ToArray(typeof(CObjetDonneeAIdNumerique)))
{
CObjetDonneeAIdNumerique objSpv = Activator.CreateInstance(tp, new object[] { contexte.ContexteDonnee }) as CObjetDonneeAIdNumerique;
if (!objSpv.ReadIfExists(new CFiltreData(strIdObjetTimosInObjetSpv + "=@1",
objTimos.Id), false))
{
mappeur.GetObjetSpvFromObjetTimosAvecCreationSansGenerique(objTimos);
}
}
}
return(result);
}
public CResultAErreur Execute(int nIdSession, System.Collections.Hashtable valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee contexte = new CContexteDonnee(nIdSession, true, false))
{
CSessionClient session = CSessionClient.GetSessionForIdSession(nIdSession);
session.BeginTrans();
try
{
CHandlerEvenementServeur.SuspendGestionnaire(true);
IDatabaseConnexion connexion = CSc2iDataServer.GetInstance().GetDatabaseConnexion(nIdSession, typeof(CVersionDonneesObjetServeur));
//Supprime les versions
string strRequete = "delete from " + CVersionDonneesObjetOperation.c_nomTable;
result = connexion.RunStatement(strRequete);
if (!result)
{
return(result);
}
strRequete = "delete from " + CVersionDonneesObjet.c_nomTable;
result = connexion.RunStatement(strRequete);
if (!result)
{
return(result);
}
foreach (CInfoRelation info in CContexteDonnee.GetListeRelationsTable(CVersionDonnees.c_nomTable))
{
if (info.TableParente == CVersionDonnees.c_nomTable)
{
strRequete = "update " + info.TableFille + " set " +
info.ChampsFille[0] + "=null where " +
info.ChampsFille[0] + " is not null";
result = connexion.RunStatement(strRequete);
if (!result)
{
return(result);
}
}
}
strRequete = "delete from " + CVersionDonnees.c_nomTable;
result = connexion.RunStatement(strRequete);
if (!result)
{
return(result);
}
contexte.SetVersionDeTravail(-1, false);
//Charge toutes les tables
List <Type> typesAChamps = new List <Type>();
foreach (Type tp in CContexteDonnee.GetAllTypes())
{
contexte.GetTableSafe(CContexteDonnee.GetNomTableForType(tp));
if (typeof(IObjetDonneeAChamps).IsAssignableFrom(tp))
{
typesAChamps.Add(tp);
}
}
/*Problème sur les champs custom : parfois (c'est rare, mais ça arrive
* les valeurs de champs ne sont pas supprimées alors que l'entité est bien
* supprimée. On ne sait pas pourquoi, mais les lignes suivantes
* règlent le problème*/
foreach (Type tp in typesAChamps)
{
string strNomTable = CContexteDonnee.GetNomTableForType(tp);
IObjetDonneeAChamps elt = (IObjetDonneeAChamps)Activator.CreateInstance(tp, new object[] { contexte });
string strTableValeurs = elt.GetNomTableRelationToChamps();
strRequete = "Update " + strTableValeurs + " set " +
CSc2iDataConst.c_champIsDeleted + "=1 where " +
elt.GetChampId() + " in (select " + elt.GetChampId() + " from " +
strNomTable + " where " + CSc2iDataConst.c_champIsDeleted + "=1)";
result = connexion.RunStatement(strRequete);
if (!result)
{
return(result);
}
}
ArrayList lstTables = CContexteDonnee.GetTableOrderDelete(contexte);
DataTable tableChampsCustomEnDernier = null;
foreach (DataTable table in lstTables)
{
/* J'ai un problème avec la table Champs Custom
* La requête suivante ne passe pas même directement dans SQL Server
* DELETE FROM CUSTOM_FIELD WHERE (SC2I_VERSION IS NOT NULL) OR (SC2I_DELETED = 1)
* Si je ne traite pas cette table, la purge se passe bien
* */
if (table.TableName == CChampCustom.c_nomTable)
{
tableChampsCustomEnDernier = table;
continue;
}
if (table.Columns.Contains(CSc2iDataConst.c_champIdVersion))
{
strRequete = "delete from " + table.TableName + " where " +
CSc2iDataConst.c_champIdVersion + " is not null or " +
CSc2iDataConst.c_champIsDeleted + "=1";
result = connexion.RunStatement(strRequete);
if (!result)
{
return(result);
}
}
}
//if (tableChampsCustomEnDernier != null)
//{
// if (tableChampsCustomEnDernier.Columns.Contains(CSc2iDataConst.c_champIdVersion))
// {
// strRequete = "delete from " + tableChampsCustomEnDernier.TableName + " where " +
// CSc2iDataConst.c_champIdVersion + " is not null or " +
// CSc2iDataConst.c_champIsDeleted + "=1";
// result = connexion.RunStatement(strRequete);
// if (!result)
// return result;
// }
//}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
CHandlerEvenementServeur.SuspendGestionnaire(false);
if (!result)
{
session.RollbackTrans();
}
else
{
result = session.CommitTrans();
}
}
}
return(result);
}