/// //////////////////////////////////////////////////
public CResultAErreur RepriseProcess(int nIdProcessEnExecution,
int nIdAction,
IIndicateurProgression indicateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Register(indicateur);
CResultAErreur result = CResultAErreur.True;
///Stef, 290808 : ouvre une session spécifique pour le process
///Pour pouvoir gérer le changement d'utilisateur proprement
CSousSessionClient session = CSousSessionClient.GetNewSousSession(IdSession);
session.OpenSession(new CAuthentificationSessionSousSession(IdSession), "Continue process " + nIdProcessEnExecution, ETypeApplicationCliente.Process);
CSessionClient sessionOriginale = CSessionClient.GetSessionForIdSession(IdSession);
//TESTDBKEYTODO
if (sessionOriginale.GetInfoUtilisateur() != null)
{
session.ChangeUtilisateur(sessionOriginale.GetInfoUtilisateur().KeyUtilisateur);
}
try
{
//Stef 08/12/2007 : le contexte ne reçoit plus les notifications
using (CContexteDonnee contexteDonnee = new CContexteDonnee(session.IdSession, true, false))
{
CProcessEnExecutionInDb processEnExecution = new CProcessEnExecutionInDb(contexteDonnee);
if (!processEnExecution.ReadIfExists(nIdProcessEnExecution))
{
result.EmpileErreur(I.T("Current action @1 doesn't exist|30012", nIdProcessEnExecution.ToString()));
return(result);
}
result = contexteDonnee.SetVersionDeTravail(processEnExecution.IdVersionExecution, true);
if (!result)
{
return(result);
}
CBrancheProcess branche = processEnExecution.BrancheEnCours;
CContexteExecutionAction contexteExecution = new CContexteExecutionAction(
processEnExecution, branche, branche.Process.GetValeurChamp(CProcess.c_strIdVariableElement), contexteDonnee, indicateur);
CAction action = branche.Process.GetActionFromId(nIdAction);
if (action == null)
{
result.EmpileErreur(I.T("Impossible to resume the processing : the action @1 doesn't exist|30013", nIdAction.ToString()));
return(result);
}
bool bTrans = false;
if (branche.Process.ModeTransactionnel)
{
session.BeginTrans();
bTrans = true;
}
try
{
result = branche.ExecuteAction(action, contexteExecution, true);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
if (bTrans)
{
if (result)
{
result = session.CommitTrans();
if (result)
{
contexteExecution.OnEndProcess();
}
}
else
{
session.RollbackTrans();
}
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
try
{
session.CloseSession();
}
catch { }
}
return(result);
}
}
//--------------------------------------------------------------------
private void m_lnkEditerModificationsPrevisionnelles_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
if (m_gestionnaireModeEdition.ModeEdition)
{
Intervention.VersionDonneesAAppliquer = (CVersionDonnees)m_txtSelectVersionLiee.ElementSelectionne;
}
if (Intervention.VersionDonneesAAppliquer == null)
{
if (!m_gestionnaireModeEdition.ModeEdition)
{
CFormAlerte.Afficher(I.T("No planified modification for that intervention|1359"), EFormAlerteType.Erreur);
return;
}
//Si nouvelle inter, il faut la valider
if (CFormAlerte.Afficher(I.T("You have to save your intervention before associate it to planified modification. Would you like to save now ?|1356"),
EFormAlerteType.Question) == DialogResult.No)
{
return;
}
if (SaveRequired != null)
{
CancelEventArgs args = new CancelEventArgs();
args.Cancel = false;
SaveRequired(this, args);
if (args.Cancel)
{
return;
}
}
else
{
CFormAlerte.Afficher("Error", EFormAlerteType.Erreur);
return;
}
CResultAErreur result = CResultAErreur.True;
//Création de la version
CVersionDonnees version = CFormCreateVersionPourIntervention.GetVersionForInter(Intervention);
if (version != null)
{
if (version.IsNew())
{
result = version.CommitEdit();
if (!result)
{
CFormAlerte.Afficher(I.T("Error while creating data version|1357"), EFormAlerteType.Erreur);
return;
}
}
//Affectation de la version à l'intervention
CIntervention intervention = Intervention;
bool bStartEdit = intervention.ContexteDonnee.IsEnEdition;
if (!bStartEdit)
{
intervention.BeginEdit();
}
intervention.VersionDonneesAAppliquer = version;
if (!bStartEdit)
{
result = intervention.CommitEdit();
}
if (!result)
{
intervention.CancelEdit();
CFormAlerte.Afficher(I.T("Error while affecting version do intervention|1358"), EFormAlerteType.Erreur);
}
InitChamps(intervention);
}
}
//La version de données est maintenant normallement associée à l'intervention
CSite site = Intervention.Site;
if (site == null)
{
return;
}
if (Intervention.VersionDonneesAAppliquer == null)
{
return;
}
//Crée un contexte dans la version
using (CContexteDonnee contexte = new CContexteDonnee(Intervention.ContexteDonnee.IdSession, true, false))
{
CResultAErreur result = contexte.SetVersionDeTravail(Intervention.VersionDonneesAAppliquer.Id, true);
if (!result)
{
CFormAfficheErreur.Show(result.Erreur);
return;
}
site = (CSite)site.GetObjetInContexte(contexte);
CFormNavigateurPopup.Show(new CFormEditionSite(site));
}
}
/// //////////////////////////////////////////////////
///LE data du result contient la valeur de retour
public CResultAErreur StartProcess(CValise2iSerializable valiseProcess,
CReferenceObjetDonnee refCible,
int?nIdVersion,
IIndicateurProgression indicateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Register(indicateur);
CResultAErreur result = CResultAErreur.True;
//Stef 08/12/2007 : le contexte ne reçoit plus les notifications
using (CContexteDonnee contexteDeSession = new CContexteDonnee(IdSession, true, false))
{
result = valiseProcess.GetObjet(typeof(CContexteDonnee), contexteDeSession);
if (!result)
{
result.EmpileErreur(I.T("Error while recovering process|30014"));
return(result);
}
CProcess leProcessAExecuter = (CProcess)result.Data;
CObjetDonneeAIdNumerique objetCible = null;
///Stef, 290808 : ouvre une session spécifique pour le process
///Pour pouvoir gérer le changement d'utilisateur proprement
CSousSessionClient session = CSousSessionClient.GetNewSousSession(contexteDeSession.IdSession);
session.OpenSession(new CAuthentificationSessionSousSession(contexteDeSession.IdSession), leProcessAExecuter.Libelle, ETypeApplicationCliente.Process);
CSessionClient sessionOriginale = CSessionClient.GetSessionForIdSession(contexteDeSession.IdSession);
if (sessionOriginale.GetInfoUtilisateur() != null)
{
session.ChangeUtilisateur(sessionOriginale.GetInfoUtilisateur().KeyUtilisateur);
}
try
{
//Charge les éléments pour la nouvelle session;
//Stef 08/12/2007 : le contexte ne reçoit plus les notifications
//Stef le 9/2/2011, si, le contexte reçoit les notifications,
//sinon, si un sous process modifie quelque chose, on ne le sait pas
//et on a des problèmes de violation d'accès concurentiel
using (CContexteDonnee contexte = new CContexteDonnee(session.IdSession, true, true))
{
result = contexte.SetVersionDeTravail(nIdVersion, true);
if (!result)
{
return(result);
}
if (refCible != null)
{
objetCible = (CObjetDonneeAIdNumerique)refCible.GetObjet(contexte);
if (objetCible == null)
{
///Stef 26/1//2009 : si l'objet n'existe pas, c'est qu'il n'y a rien à déclencher.
///cela résoud un problème : si un process avant celui-ci a supprimé le targetElement
///il ne faut pas lancer ce process là !
//result.EmpileErreur(I.T("Target object @1 does not exist|30015",refCible.ToString()));
return(result);
}
}
result = ExecuteProcess(
session,
objetCible,
leProcessAExecuter,
contexte, false,
indicateur);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
try
{
session.CloseSession();
}
catch { }
}
}
return(result);
}
}
/// //////////////////////////////////////////////////
public CResultAErreur StartProcessMultiples(CValise2iSerializable valiseProcess,
CReferenceObjetDonnee[] refsCible,
int?nIdVersion,
IIndicateurProgression indicateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Register(indicateur);
CResultAErreur result = CResultAErreur.True;
//Stef 08/12/2007 : le contexte ne reçoit plus les notifications
using (CContexteDonnee contexteDeSession = new CContexteDonnee(IdSession, true, false))
{
result = valiseProcess.GetObjet(typeof(CContexteDonnee), contexteDeSession);
if (!result)
{
result.EmpileErreur(I.T("Error while process recovering|30014"));
return(result);
}
CProcess leProcessAExecuter = (CProcess)result.Data;
CObjetDonneeAIdNumerique objetCible = null;
///Stef, 290808 : ouvre une session spécifique pour le process
///Pour pouvoir gérer le changement d'utilisateur proprement
CSousSessionClient session = CSousSessionClient.GetNewSousSession(contexteDeSession.IdSession);
session.OpenSession(new CAuthentificationSessionSousSession(contexteDeSession.IdSession), leProcessAExecuter.Libelle, ETypeApplicationCliente.Process);
CSessionClient sessionOriginale = CSessionClient.GetSessionForIdSession(contexteDeSession.IdSession);
//TESTDBKEYOK
if (sessionOriginale.GetInfoUtilisateur() != null)
{
session.ChangeUtilisateur(sessionOriginale.GetInfoUtilisateur().KeyUtilisateur);
}
try
{
//Charge les éléments pour la nouvelle session;
//Stef 08/12/2007 : le contexte ne reçoit plus les notifications
using (CContexteDonnee contexte = new CContexteDonnee(session.IdSession, true, false))
{
result = contexte.SetVersionDeTravail(nIdVersion, true);
if (!result)
{
return(result);
}
if (leProcessAExecuter.SurTableauDeTypeCible)
{
ArrayList lst = new ArrayList();
foreach (CReferenceObjetDonnee refCibleTmp in refsCible)
{
object tmp = refCibleTmp.GetObjet(contexte);
if (tmp != null)
{
lst.Add(tmp);
}
}
return(ExecuteProcess(session, lst, leProcessAExecuter, contexte, false, indicateur));
}
try
{
if (!leProcessAExecuter.ModeAsynchrone)
{
session.BeginTrans(IsolationLevel.ReadCommitted);
}
foreach (CReferenceObjetDonnee refCible in refsCible)
{
bool bShouldStart = true;
if (refCible != null)
{
objetCible = (CObjetDonneeAIdNumerique)refCible.GetObjet(contexte);
if (objetCible == null)
{
///Stef 26/1//2009 : si l'objet n'existe pas, c'est qu'il n'y a rien à déclenché.
///cela résoud un problème : si un process avant celui-ci a supprimé le targetElement
///il ne faut pas lancer ce process là !
/*result.EmpileErreur(I.T("Target object @1 does not exist|30015", refCible.ToString()));
* return result;*/
bShouldStart = false;
}
}
if (bShouldStart)
{
result = ExecuteProcess(
session,
objetCible,
leProcessAExecuter,
contexte, true, indicateur);
if (!result)
{
result.EmpileErreur(I.T("Execution error on element @1|30016", objetCible.DescriptionElement));
return(result);
}
}
}
if (result)
{
result = contexte.SaveAll(true);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
if (result)
{
result = session.CommitTrans();
}
if (!result)
{
session.RollbackTrans();
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
try
{
session.CloseSession();
}
catch
{
}
}
return(result);
}
}
}
/// ///////////////////////////////////////////////////////////////
public CResultAErreur CreateValise(CObjetDonneeAIdNumeriqueAuto objet, DataSet ds)
{
int nIdSession = objet.ContexteDonnee.IdSession;
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee contextePourChargementComplet = new CContexteDonnee(nIdSession, true, false))
{
result = contextePourChargementComplet.SetVersionDeTravail(objet.ContexteDonnee.IdVersionDeTravail, true);
if (!result)
{
return(result);
}
CObjetDonneeAIdNumeriqueAuto source = (CObjetDonneeAIdNumeriqueAuto)Activator.CreateInstance(objet.GetType(), new object[] { contextePourChargementComplet });
if (!source.ReadIfExists(objet.Id))
{
result.EmpileErreur(I.T("Impossible to read the object @1 again|173", objet.Id.ToString()));
return(result);
}
ReadObjetEtDependances(source);
//Toutes les données sont lues, il n'y a plus qu'à les copier dans le dataset valise
foreach (DataTable tableSource in contextePourChargementComplet.Tables)
{
ds.Merge(tableSource);
//Crée les colonnes byte[] en place des CDonneeBinaireInRow
DataTable newTable = ds.Tables[tableSource.TableName];
if (tableSource.PrimaryKey.Length != 0)
{
foreach (DataColumn col in tableSource.Columns)
{
if (col.DataType == typeof(CDonneeBinaireInRow))
{
newTable.Columns.Remove(col.ColumnName);
DataColumn newCol = new DataColumn(col.ColumnName, typeof(string));
newCol.AllowDBNull = true;
newTable.Columns.Add(col.ColumnName);
foreach (DataRow rowSource in tableSource.Rows)
{
ArrayList keys = new ArrayList();
foreach (DataColumn primKey in tableSource.PrimaryKey)
{
keys.Add(rowSource[primKey]);
}
DataRow rowDest = newTable.Rows.Find(keys.ToArray());
if (rowDest != null)
{
CDonneeBinaireInRow donnee = new CDonneeBinaireInRow(objet.ContexteDonnee.IdSession, rowSource, col.ColumnName);
byte[] dataBinaire = donnee.Donnees;
CStringSerializer serializer = new CStringSerializer(ModeSerialisation.Ecriture);
serializer.TraiteByteArray(ref dataBinaire);
rowDest[col.ColumnName] = serializer.String;
}
}
}
}
}
}
foreach (DataRelation relation in contextePourChargementComplet.Relations)
{
DataColumn colParente, colFille;
colParente = ds.Tables[relation.ParentTable.TableName].Columns[relation.ParentColumns[0].ColumnName];
colFille = ds.Tables[relation.ChildTable.TableName].Columns[relation.ChildColumns[0].ColumnName];
DataRelation rel = ds.Relations.Add(
relation.RelationName,
colParente,
colFille,
true);
rel.ChildKeyConstraint.UpdateRule = Rule.Cascade;
}
}
return(result);
}
//----------------------------------------------------------------------------------
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 CResultAErreurType <CSessionImport> DoSmartImport(
DataTable tableSource,
CConfigMappagesSmartImport config,
COptionExecutionSmartImport options,
IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
CSessionImport sessionImport = new CSessionImport();
sessionImport.TableSource = tableSource;
sessionImport.ConfigMappage = config;
CResultAErreurType <CSessionImport> resSession = new CResultAErreurType <CSessionImport>();
resSession.DataType = sessionImport;
int nTaillePaquet = options.TaillePaquets == null ? tableSource.Rows.Count : options.TaillePaquets.Value;
int nStartLigne = options.StartLine == null ? 0 : options.StartLine.Value;
int nEndLigne = options.EndLine == null ? tableSource.Rows.Count - 1 : Math.Min(options.EndLine.Value, tableSource.Rows.Count - 1);
int nNbToDo = nEndLigne - nStartLigne + 1;
int nNbDone = 0;
int?nIdVersionDonnees = null;
if (options.UtiliserVersionDonnee)
{
using (CContexteDonnee ctx = new CContexteDonnee(IdSession, true, false))
{
CVersionDonnees version = new CVersionDonnees(ctx);
version.CreateNew();
version.TypeVersion = new CTypeVersion(CTypeVersion.TypeVersion.Previsionnelle);
version.Libelle = I.T("Import data @1|20013", DateTime.Now.ToString("G"));
result = version.CommitEdit();
if (!result)
{
resSession.EmpileErreur(result.Erreur);
return(resSession);
}
nIdVersionDonnees = version.Id;
}
}
if (nStartLigne > 0)
{
sessionImport.AddLog(new CLigneLogImport(ETypeLigneLogImport.Info,
null,
"",
0,
nStartLigne - 1,
"Lines 0 to " + (nStartLigne - 1) + " are ignored"));
sessionImport.SetNonImportees(0, nStartLigne - 1);
}
if (nEndLigne < tableSource.Rows.Count - 1)
{
sessionImport.AddLog(new CLigneLogImport(ETypeLigneLogImport.Info,
null,
"",
nEndLigne + 1,
tableSource.Rows.Count - 1,
"Lines " + (nEndLigne + 1) + " to " + (tableSource.Rows.Count - 1) + " are ignored"));
sessionImport.SetNonImportees(nEndLigne + 1, tableSource.Rows.Count - 1);
}
//Ajoute dans la liste des lignes non importées, les lignes ignorées
using (C2iSponsor sponsor = new C2iSponsor())
{
if (indicateur != null)
{
sponsor.Register(indicateur);
indicateur.SetBornesSegment(0, nNbToDo);
}
try
{
while (nStartLigne <= nEndLigne)
{
using (CContexteDonnee ctxDonnees = new CContexteDonnee(IdSession, true, false))
{
if (m_nIdSession != null)
{
ctxDonnees.SetVersionDeTravail(nIdVersionDonnees, false);
}
CContexteImportDonnee ctxImport = new CContexteImportDonnee(ctxDonnees);
ctxImport.BestEffort = options.BestEffort;
ctxImport.StartLine = nStartLigne;
ctxImport.EndLine = Math.Min(nStartLigne + nTaillePaquet - 1, tableSource.Rows.Count - 1);
if (ctxImport.EndLine > nEndLigne)
{
ctxImport.EndLine = nEndLigne;
}
if (indicateur != null)
{
indicateur.PushSegment(nNbDone, nNbDone + ctxImport.EndLine.Value - ctxImport.StartLine.Value);
}
result = config.ImportTable(
tableSource,
ctxImport,
indicateur);
sessionImport.AddLogs(ctxImport.Logs);
if (indicateur != null)
{
indicateur.PopSegment();
}
if (result)
{
if (indicateur != null)
{
indicateur.SetInfo(I.T("Saving|20012"));
}
result = ctxDonnees.SaveAll(true);
if (!result)
{
sessionImport.SetNonImportees(ctxImport.StartLine.Value,
ctxImport.EndLine.Value);
sessionImport.AddLog(new CLigneLogImport(
ETypeLigneLogImport.Error,
null,
"",
ctxImport.StartLine.Value,
ctxImport.EndLine.Value,
"Error saving lines " + ctxImport.StartLine.Value + " to " + ctxImport.EndLine.Value + " " +
result.Erreur.ToString()));
}
if (!result && !ctxImport.BestEffort)
{
return(resSession);
}
if (result)
{
sessionImport.SetImportees(ctxImport.StartLine.Value,
ctxImport.EndLine.Value);
}
}
else
{
sessionImport.SetNonImportees(ctxImport.StartLine.Value,
ctxImport.EndLine.Value);
}
if (!result && !options.BestEffort)
{
return(resSession);
}
nStartLigne += nTaillePaquet;
nNbDone += nTaillePaquet;
if (indicateur != null)
{
indicateur.SetValue(nNbDone);
}
}
}
}
catch (Exception e)
{
resSession.EmpileErreur(new CErreurException(e));
}
finally
{
if (!result && !options.BestEffort)
{
resSession.EmpileErreur(result.Erreur);
}
}
return(resSession);
}
}
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);
}
/// //////////////////////////////////////////////////////////////
public CResultAErreur Supprimer(ArrayList listeElementsASupprimer)
{
using (CWaitCursor waiter = new CWaitCursor())
{
CResultAErreur result = CResultAErreur.True;
if (listeElementsASupprimer.Count <= 0)
{
return(result);
}
string strListeIds = "";
CObjetDonneeAIdNumeriqueAuto objetPourSuppressionGlobale = null;
//Crée une liste de tous les ids éléments à supprimer
try
{
foreach (CObjetDonneeAIdNumeriqueAuto objet in listeElementsASupprimer)
{
strListeIds += objet.Id.ToString() + ",";
if (objetPourSuppressionGlobale == null)
{
objetPourSuppressionGlobale = objet;
}
}
strListeIds = strListeIds.Substring(0, strListeIds.Length - 1);
using (CContexteDonnee contexteToDelete = new CContexteDonnee(objetPourSuppressionGlobale.ContexteDonnee.IdSession, true, false))
{
result = contexteToDelete.SetVersionDeTravail(objetPourSuppressionGlobale.ContexteDonnee.IdVersionDeTravail, true);
if (!result)
{
return(result);
}
contexteToDelete.BeginModeDeconnecte();
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexteToDelete,
objetPourSuppressionGlobale.GetType(), false);
liste.Filtre = new CFiltreData(
objetPourSuppressionGlobale.GetChampId() + " in (" +
strListeIds + ")");
result = CObjetDonneeAIdNumeriqueAuto.Delete(liste);
if (!result)
{
contexteToDelete.CancelModifsEtEndModeDeconnecte();
result.EmpileErreur(I.T("Error while deleting element|30032"));
return(result);
}
else
{
result = contexteToDelete.CommitModifsDeconnecte();
}
}
}
catch
{
foreach (CObjetDonnee objet in listeElementsASupprimer)
{
result = objet.Delete();
if (!result)
{
CSc2iWin32DataClient.ContexteCourant.CancelModifsEtEndModeDeconnecte();
result.EmpileErreur(I.T("Error while deleting element|30032"));
break;
}
}
if (result)
{
result = CSc2iWin32DataClient.ContexteCourant.CommitModifsDeconnecte();
}
}
return(result);
}
}