/// /////////////////////////////////////////////////////////////
public static CResultAErreur StartProcessMultiples(CProcess process,
CInfoDeclencheurProcess infoDeclencheur,
CReferenceObjetDonnee[] refsCible,
int nIdSession,
int?nIdVersion,
IIndicateurProgression indicateur)
{
process.InfoDeclencheur = infoDeclencheur;
///TODO
///Problème VersionObjet
IProcessEnExecutionInDbServeur processServeur = (IProcessEnExecutionInDbServeur)CContexteDonnee.GetTableLoader(c_nomTable, null, nIdSession);
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Register(processServeur);
CAppelleurFonctionAsynchrone appelleur = new CAppelleurFonctionAsynchrone();
CResultAErreur defaultResult = CResultAErreur.True;
defaultResult.EmpileErreur(I.T("Asynchronous call error @1|20032", "StartProcessMultiples"));
return(appelleur.StartFonctionAndWaitAvecCallback(
typeof(IProcessEnExecutionInDbServeur),
processServeur,
"StartProcessMultiples",
"",
defaultResult,
new CValise2iSerializable(process),
refsCible,
nIdVersion,
indicateur) as CResultAErreur);
}
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (sessionClient != null)
{
if (sessionClient.GetInfoUtilisateur().KeyUtilisateur == contexte.Branche.KeyUtilisateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
CServiceSurClient service = sessionClient.GetServiceSurClient(c_idServiceClientMessageBox);
if (service != null)
{
sponsor.Register(service);
//Calcule le message
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = FormuleMessage.Eval(contexteEval);
if (!result)
{
result = CResultAErreur.True;
m_strMessageCache = FormuleMessage.GetString();
}
else
{
m_strMessageCache = result.Data == null ? "" : result.Data.ToString();
}
result = service.RunService(this);
if (!result)
{
return(result);
}
E2iDialogResult dResult = (E2iDialogResult)result.Data;
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienFromDialog &&
((CLienFromDialog)lien).ResultAssocie == dResult)
{
result.Data = lien;
return(result);
}
}
result.Data = null;
return(result);
}
}
}
}
//Utilisateur pas accessible
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienUtilisateurAbsent)
{
result.Data = lien;
return(result);
}
}
return(result);
}
public CProxyElementAVariables GetProxyElementAVariables(C2iSponsor sponsor)
{
CProxyElementAVariables proxy = new CProxyElementAVariables(this, ContexteDonnee, sponsor);
sponsor.Register(proxy);
return(proxy);
}
/// <summary>
/// Purge l'historique des process jusqu'à une date limite
/// </summary>
/// <param name="dt"></param>
/// <returns></returns>
public static CResultAErreur Purger(DateTime dt, int nIdSession)
{
IProcessEnExecutionInDbServeur processServeur = (IProcessEnExecutionInDbServeur)CContexteDonnee.GetTableLoader(c_nomTable, null, nIdSession);
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Register(processServeur);
return(processServeur.Purger(dt));
}
}
public void ShowFormulaire()
{
using (C2iSponsor sponsor = new C2iSponsor())
{
//sponsor.Label = "2 - Show Formulaire";
sponsor.Register(m_actionToExecute);
CFormExecuteActionFormulaire form = new CFormExecuteActionFormulaire();
m_resultAction = form.ExecuteAction(m_actionToExecute);
}
}
/// /////////////////////////////////////////////////////////////
public CResultAErreur RepriseProcess(int nIdAction, IIndicateurProgression indicateur)
{
///TODO
///Problème VersionObjet
IProcessEnExecutionInDbServeur processServeur = (IProcessEnExecutionInDbServeur)CContexteDonnee.GetTableLoader(c_nomTable, null, ContexteDonnee.IdSession);
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Register(processServeur);
return(processServeur.RepriseProcess(Id, nIdAction, indicateur));
}
}
/// //////////////////////////////////////////////////////////////////
public void Dispose()
{
m_sponsor.Unregister(m_infoUtilisateurSurServeur);
m_infoUtilisateurSurServeur = null;
m_sponsor.Dispose();
m_sponsor = null;
if (m_recepteurNotificationChangementDroit != null)
{
m_recepteurNotificationChangementDroit.Dispose();
}
m_recepteurNotificationChangementDroit = null;
}
//-----------------------------------------------------------
public void Dispose()
{
if (m_sponsor != null)
{
m_sponsor.Dispose();
}
m_sponsor = null;
if (m_listener != null)
{
m_listener.Dispose();
}
m_listener = null;
}
public int ExportUpdatePeriod = 24; // En heures
public void InitTimos()
{
CResultAErreur result = CResultAErreur.True;
string strServeurUrl = TimosServerURL;
int nTcpChannel = 0;
string strBindTo = "";
string strRadiuServerUrl = RadiusServerURL;
uint nRadiusPort = (uint)RadiusServerPort;
string strSharedKey = RadiusSharedKey;
int nUpdatePeriod = ExportUpdatePeriod;
try
{
AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal);
AuthenticationService.Init(strRadiuServerUrl, nRadiusPort, strSharedKey);
result = CSC2iMultitiersClient.Init(nTcpChannel, strServeurUrl, strBindTo);
LifetimeServices.LeaseTime = new TimeSpan(0, 5, 0);
LifetimeServices.LeaseManagerPollTime = new TimeSpan(0, 5, 0);
LifetimeServices.SponsorshipTimeout = new TimeSpan(0, 3, 0);
LifetimeServices.RenewOnCallTime = new TimeSpan(0, 8, 0);
C2iSponsor.EnableSecurite();
/*TcpChannel channel = new TcpChannel();
* ChannelServices.RegisterChannel(channel, false);*/
if (!result)
{
result.EmpileErreur("Erreur lors de l'initialisation");
}
// Configuration des Schedulers
// ATTENTION : Dans le cas de plusieurs serveurs (load balancing par exemple) il faut locker le traitement dans la commande appelée
ScheduleCommand.RunEvery(1, PeriodUnit.Hour, "TimosWebApp/ExportService.TraiteListeExports", new Dictionary <string, object>(), new DateTime(2021, 06, 01, 01, 00, 00), null);
/*/ DEBUG ONLY
* ScheduleCommand.RunEvery(1, PeriodUnit.Minute, "TimosWebApp/ExportService.UpdateAllExports", new Dictionary<string, object>(), null, null);
* //*/
}
catch (Exception e)
{
result.EmpileErreur(e.Message);
}
}
private void AskForClose()
{
CServiceSurClient service = null;
lock ( m_listeServicesToLaunch )
{
service = (CServiceSurClient)m_listeServicesToLaunch[0];
m_listeServicesToLaunch.RemoveAt(0);
}
C2iSponsor sponsor = new C2iSponsor();
sponsor.Register(service);
CResultAErreur result = service.RunService(null);
}
/// //////////////////////////////////////////////////////////
public CResultAErreur ExportData(string strChaineSerializationListeObjetDonnee, C2iStructureExport structure, IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablesDynamiquesPourFiltre, IIndicateurProgression indicateur)
{
System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.BelowNormal;
//Déserialise la liste d'objets
CStringSerializer serializer = new CStringSerializer(strChaineSerializationListeObjetDonnee, ModeSerialisation.Lecture);
C2iSponsor sponsor = new C2iSponsor();
sponsor.Register(indicateur);
CResultAErreur result = CResultAErreur.True;
try
{
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
I2iSerializable objet = null;
contexte.GestionParTablesCompletes = true;
result = serializer.TraiteObject(ref objet, contexte);
if (!result)
{
return(result);
}
if (objet == null || !(objet is CListeObjetsDonnees))
{
result.EmpileErreur(I.T("Error during the deserialization of source list|101"));
return(result);
}
CListeObjetsDonnees listeSource = (CListeObjetsDonnees)objet;
listeSource.RemplissageProgressif = false;
structure.TraiterSurServeur = false;
DataSet ds = new DataSet();
result = structure.Export(IdSession, listeSource, ref ds, elementAVariablesDynamiquesPourFiltre, indicateur);
if (result)
{
result.Data = ds;
}
return(result);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
sponsor.Unregister(indicateur);
}
return(result);
}
public CResultAErreur ExecuteAction(CActionFormulaire action)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
//sponsor.Label = "3 - Execute Action";
sponsor.Register(action.Process);
CResultAErreur result = CResultAErreur.True;
m_actionFormulaire = action;
DialogResult dialogResult = DialogResult.Cancel;
CTimosApp.Navigateur.Invoke((MethodInvoker) delegate
{
result = SafeExecuteAction(sponsor, ref result, ref dialogResult);
});
return(result);
}
}
public void ShowFormulaire()
{
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Register(m_structure);
CResultAErreur result = CResultAErreur.True;
//Fait passer le formulaire par le réseau
byte[] dataFormulaire = m_actionExport.GetDataSerialisationFormulairePourClient();
MemoryStream stream = new MemoryStream(dataFormulaire);
BinaryReader reader = new BinaryReader(stream);
CSerializerReadBinaire serializer = new CSerializerReadBinaire(reader);
serializer.AttacheObjet(typeof(IElementAVariablesDynamiquesBase), m_structure);
I2iSerializable formulaireSer = null;
result = serializer.TraiteObject(ref formulaireSer);
reader.Close();
stream.Close();
if (!result)
{
m_resultForm.EmpileErreur(I.T("Error while retrieving the form|30253"));
}
C2iWnd formulaire = (C2iWnd)formulaireSer;
CFormFormulairePopup form = new CFormFormulairePopup();
if (form.EditeElement(CTimosApp.Navigateur, formulaire, m_structure, I.T("Exporting data|10046")))
{
m_resultForm = CResultAErreur.True;
m_resultForm.Data = E2iDialogResult.OK;
}
else
{
m_resultForm.Data = E2iDialogResult.Cancel;
}
}
}
//----------------------------------------------------------------------------
public override CResultAErreur RunService(object parametre)
{
CResultAErreur result = CResultAErreur.True;
CActionFormulaire action = parametre as CActionFormulaire;
if (action == null)
{
result.EmpileErreur(I.T("Incompatible parameter type|30254"));
return(result);
}
using (C2iSponsor sponsor = new C2iSponsor())
{
m_actionToExecute = action;
sponsor.Register(m_actionToExecute);
Thread th = new Thread(new ThreadStart(ShowFormulaire));
th.SetApartmentState(ApartmentState.STA);
th.Start();
th.Join();
return(m_resultAction);
}
}
//----------------------------------------------------------------------------
public override sc2i.common.CResultAErreur RunService(object parametre)
{
CResultAErreur result = CResultAErreur.True;
CActionMessageBox action = parametre as CActionMessageBox;
if (action == null)
{
result.EmpileErreur(I.T("Parameter type incompatible with 'Message box' service|1079"));
return(result);
}
using (C2iSponsor sponsor = new C2iSponsor())
{
m_action = action;
sponsor.Register(m_action);
Thread th = new Thread(new ThreadStart(ShowDialogMessageBox));
th.SetApartmentState(ApartmentState.STA);
th.Start();
th.Join();
return(m_result);
}
}
//--------------------------------------------------------------
public CProxyElementAVariables(IElementAVariablesDynamiques element, CContexteDonnee contexteDonneeDistant, C2iSponsor sponsor)
{
m_distantElementAVariables = new CDistantElementAVariables(element, contexteDonneeDistant);
sponsor.Register(m_distantElementAVariables);
foreach (IVariableDynamique variable in element.ListeVariables)
{
m_dicVariables[variable.IdVariable] = variable;
}
}
/// <summary>
/// Stocke le résultat d'une requête pour un type de données
/// </summary>
/// <param name="nIdTypeDonnee"></param>
/// <param name="requete"></param>
/// <returns></returns>
public CResultAErreur StockeResultat(int nIdTypeDonnee, IIndicateurProgression indicateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Register(indicateur);
CResultAErreur result = CResultAErreur.True;
if (m_tableCalculsEnCours[nIdTypeDonnee] != null)
{
result.EmpileErreur(I.T("The recalculation for this cumulated data type is already in progress|143"));
return(result);
}
m_tableCalculsEnCours[nIdTypeDonnee] = true;
CSessionProcessServeurSuivi sessionSuivi = null;
try
{
//Crée une session pour le calcul
CSessionClient session = CSessionClient.GetSessionForIdSession(IdSession);
if (session == null)
{
result.EmpileErreur(I.T("Session error|144"));
return(result);
}
System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.BelowNormal;
sessionSuivi = new CSessionProcessServeurSuivi();
result = sessionSuivi.OpenSession(new CAuthentificationSessionServer(),
I.T("Recalculation of datas @1|145", nIdTypeDonnee.ToString()),
session);
if (!result)
{
result.EmpileErreur(I.T("Opening session error|146"));
return(result);
}
IdSession = sessionSuivi.IdSession;
System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.Lowest;
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
//Récupère le type de donnée
CTypeDonneeCumulee typeDonnee = new CTypeDonneeCumulee(contexte);
if (!typeDonnee.ReadIfExists(nIdTypeDonnee))
{
result.EmpileErreur(I.T("The cumulated data type @1 doesn't exist|147", nIdTypeDonnee.ToString()));
return(result);
}
if (indicateur != null)
{
indicateur.SetInfo(I.T("Existing datas recovery|148"));
indicateur.SetValue(0);
}
CParametreDonneeCumulee parametre = typeDonnee.Parametre;
//Lit les données pour ce type de donnée cumulée
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexte, typeof(CDonneeCumulee));
liste.Filtre = new CFiltreData(CTypeDonneeCumulee.c_champId + "=@1",
nIdTypeDonnee);
liste.AssureLectureFaite();
if (parametre.ViderAvantChaqueCalcul)
{
result = VideTable(nIdTypeDonnee, contexte.Tables[CDonneeCumulee.c_nomTable]);
if (!result)
{
return(result);
}
}
//Liste des champs clé à lire
ArrayList lstClesALire = new ArrayList();
//Liste des champs destination des clés
ArrayList lstDestClesALire = new ArrayList();
//Liste des valeurs décimales à lire
ArrayList lstValeursDecimalesALire = new ArrayList();
//Liste des champs destinatation des valeurs décimales
ArrayList lstDestValeursDecimalesALire = new ArrayList();
//Liste des valeurs dates à lire
ArrayList lstValeursDatesALire = new ArrayList();
//Liste des champs destinatation des valeurs dates
ArrayList lstDestValeursDatesALire = new ArrayList();
//Liste des valeurs texte à lire
ArrayList lstValeursTextesALire = new ArrayList();
//Liste des champs destinatation des valeurs texte
ArrayList lstDestValeursTextesALire = new ArrayList();
//Change les clés de la table de données pour qu'elles
//correspondent aux clés déclarées
//Pour des recherches ultérieures plus rapides
DataTable tableDonnees = contexte.Tables[CDonneeCumulee.c_nomTable];
DataColumn[] oldKey = tableDonnees.PrimaryKey;
ArrayList lstCles = new ArrayList();
for (int nCle = 0; nCle < CParametreDonneeCumulee.c_nbChampsCle; nCle++)
{
if (parametre.GetChampCle(nCle) != null &&
parametre.GetChampCle(nCle).Champ != "")
{
lstClesALire.Add(parametre.GetChampCle(nCle).Champ);
string strChampDest = CDonneeCumulee.c_baseChampCle + nCle.ToString();
lstDestClesALire.Add(strChampDest);
lstCles.Add(tableDonnees.Columns[strChampDest]);
}
}
try
{
tableDonnees.PrimaryKey = (DataColumn[])lstCles.ToArray(typeof(DataColumn));
}
catch
{
//On n'y arrive pas, on a probablement changé la requete ->On vide tout !
result = VideTable(nIdTypeDonnee, tableDonnees);
if (!result)
{
return(result);
}
tableDonnees.PrimaryKey = (DataColumn[])lstCles.ToArray(typeof(DataColumn));
}
//Repère les données à lire
for (int nChamp = 0; nChamp < CParametreDonneeCumulee.c_nbChampsValeur; nChamp++)
{
string strChamp = parametre.GetValueField(nChamp);
if (strChamp != null && strChamp != "")
{
lstValeursDecimalesALire.Add(strChamp);
lstDestValeursDecimalesALire.Add(CDonneeCumulee.c_baseChampValeur + nChamp.ToString());
}
}
for (int nChamp = 0; nChamp < CParametreDonneeCumulee.c_nbChampsDate; nChamp++)
{
string strChamp = parametre.GetDateField(nChamp);
if (strChamp != null && strChamp != "")
{
lstValeursDatesALire.Add(strChamp);
lstDestValeursDatesALire.Add(CDonneeCumulee.c_baseChampDate + nChamp.ToString());
}
}
for (int nChamp = 0; nChamp < CParametreDonneeCumulee.c_nbChampsTexte; nChamp++)
{
string strChamp = parametre.GetTextField(nChamp);
if (strChamp != null && strChamp != "")
{
lstValeursTextesALire.Add(strChamp);
lstDestValeursTextesALire.Add(CDonneeCumulee.c_baseChampTexte + nChamp.ToString());
}
}
if (indicateur != null)
{
indicateur.SetInfo(I.T("Request execution|149"));
indicateur.SetValue(10);
}
IDefinitionJeuDonnees defJeu = typeDonnee.Parametre.DefinitionDeDonnees;
IElementAVariablesDynamiquesAvecContexteDonnee eltAVariables = null;
if (defJeu is C2iRequete)
{
eltAVariables = (IElementAVariablesDynamiquesAvecContexteDonnee)defJeu;
}
else if (defJeu is CStructureExportAvecFiltre)
{
eltAVariables = ((CStructureExportAvecFiltre)defJeu).Filtre;
if (eltAVariables == null)
{
CFiltreDynamique filtre = new CFiltreDynamique(contexte);
filtre.TypeElements = defJeu.TypeDonneesEntree;
eltAVariables = filtre;
}
((CFiltreDynamique)eltAVariables).ContexteDonnee = contexte;
}
result = CParametreDonneeCumulee.GetTableSource(eltAVariables, defJeu, indicateur);
//Calcule le résultat de la requête demandée
if (!result)
{
result.EmpileErreur(I.T("Error in request|150"));
return(result);
}
//Liste des lignes trouvées dans la requête
Hashtable tableExistantes = new Hashtable();
DataTable tableSource = (DataTable)result.Data;
if (indicateur != null)
{
indicateur.SetInfo(I.T("Result Storage|151"));
indicateur.SetValue(20);
indicateur.PushSegment(20, 80);
indicateur.SetBornesSegment(0, tableSource.Rows.Count);
}
int nIndex = 0;
foreach (DataRow row in tableSource.Rows)
{
nIndex++;
if (indicateur != null && nIndex % 50 == 0)
{
indicateur.SetValue(nIndex);
}
lstCles.Clear();
for (int nCle = 0; nCle < lstClesALire.Count; nCle++)
{
lstCles.Add(row[(string)lstClesALire[nCle]]);
}
DataRow rowDest = tableDonnees.Rows.Find((object[])lstCles.ToArray(typeof(object)));
if (rowDest == null)
{
rowDest = tableDonnees.NewRow();
rowDest[CObjetDonnee.c_champIdUniversel] = CUniqueIdentifier.GetNew();
for (int nCle = 0; nCle < lstCles.Count; nCle++)
{
rowDest[(string)lstDestClesALire[nCle]] = lstCles[nCle];
}
rowDest[CTypeDonneeCumulee.c_champId] = nIdTypeDonnee;
tableDonnees.Rows.Add(rowDest);
}
// Rempli les valeurs décimales de destination
for (int nChampVal = 0; nChampVal < lstValeursDecimalesALire.Count; nChampVal++)
{
try
{
rowDest[(string)lstDestValeursDecimalesALire[nChampVal]] = Convert.ToDouble(row[(string)lstValeursDecimalesALire[nChampVal]]);
}
catch
{
rowDest[CDonneeCumulee.c_baseChampValeur + nChampVal.ToString()] = 0;
}
}
// Rempli les valeurs Dates de destination
for (int nChampVal = 0; nChampVal < lstValeursDatesALire.Count; nChampVal++)
{
try
{
rowDest[(string)lstDestValeursDatesALire[nChampVal]] = Convert.ToDateTime(row[(string)lstValeursDatesALire[nChampVal]]);
}
catch
{
rowDest[CDonneeCumulee.c_baseChampDate + nChampVal.ToString()] = DBNull.Value;
}
}
// Rempli les valeurs Texte de destination
for (int nChampVal = 0; nChampVal < lstValeursTextesALire.Count; nChampVal++)
{
try
{
rowDest[(string)lstDestValeursTextesALire[nChampVal]] = (row[(string)lstValeursTextesALire[nChampVal]]).ToString();
}
catch
{
rowDest[CDonneeCumulee.c_baseChampTexte + nChampVal.ToString()] = "";
}
}
tableExistantes[rowDest] = true;
}
//Remet la clé à la valeur initiale
tableDonnees.PrimaryKey = oldKey;
if (indicateur != null)
{
indicateur.PopSegment();
indicateur.PushSegment(80, 90);
indicateur.SetBornesSegment(0, tableDonnees.Rows.Count);
indicateur.SetInfo(I.T("Deleting of old values|152"));
}
if (!parametre.PasDeSuppression)
{
//Supprime les lignes à supprimer
ArrayList lstRows = new ArrayList(tableDonnees.Rows);
nIndex = 0;
foreach (DataRow row in lstRows)
{
if (!tableExistantes.Contains(row))
{
row.Delete();
}
nIndex++;
if (indicateur != null && nIndex % 50 == 0)
{
indicateur.SetValue(nIndex);
}
}
}
if (indicateur != null)
{
indicateur.PopSegment();
indicateur.SetInfo(I.T("Datas saving|153"));
}
contexte.EnableTraitementsAvantSauvegarde = false;
result = contexte.SaveAll(true);
if (indicateur != null)
{
indicateur.SetInfo(I.T("Finished calculation|154"));
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
return(result);
}
finally
{
if (sessionSuivi != null)
{
sessionSuivi.CloseSession();
}
m_tableCalculsEnCours.Remove(nIdTypeDonnee);
}
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);
}
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
//Si la session qui execute est une session de l'utilisateur associé à la branche,
//Tente d'afficher le EditerElement sur cette session,
//Sinon, enregistre une Intervention sur l'utilisateur
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (sessionClient != null)
{
//TESTDBKEYOK
if (sessionClient.GetInfoUtilisateur().KeyUtilisateur == contexte.Branche.KeyUtilisateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
CServiceSurClient service = sessionClient.GetServiceSurClient(c_idServiceClientEditerElement);
if (service != null)
{
sponsor.Register(service);
//Evalue l'élément à éditer
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
if (m_expressionElementAEditer == null)
{
result.EmpileErreur(I.T("Incorrect formula for Edited element|385"));
return(result);
}
result = m_expressionElementAEditer.Eval(contexteEval);
if (!result)
{
return(result);
}
CObjetDonnee objet = result.Data as CObjetDonnee;
string strCodeFormulaire = "";
if (m_expressionCodeFormulaire != null)
{
result = m_expressionCodeFormulaire.Eval(contexteEval);
if (!result)
{
return(result);
}
strCodeFormulaire = result.Data as string;
}
result = service.RunService(
new CParametreEditionElement(
contexte.IdSession,
new CReferenceObjetDonnee(objet),
DansNavigateurPrincipal,
DansNouvelOnglet,
strCodeFormulaire,
contexte.ContexteDonnee.IdVersionDeTravail));
//Fin du process
result.Data = null;
if (result)
{
foreach (CLienAction lien in this.GetLiensSortantHorsErreur())
{
if (!(lien is CLienUtilisateurAbsent))
{
result.Data = lien;
}
}
}
return(result);
}
}
}
}
//Utilisateur pas accessible
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienUtilisateurAbsent)
{
result.Data = lien;
return(result);
}
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (sessionClient != null)
{
if (sessionClient.GetInfoUtilisateur().KeyUtilisateur == contexte.Branche.KeyUtilisateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
CServiceSurClient service = sessionClient.GetServiceSurClient(c_idServiceSelectMultiForGed);
CServiceSurClient serviceGetFile = sessionClient.GetServiceSurClient(CActionCopierLocalDansGed.c_idServiceClientGetFichier);
if (service != null && serviceGetFile != null)
{
sponsor.Register(service);
sponsor.Register(serviceGetFile);
//Calcule la liste des ids de catégories à gérer
List <int> lstIds = new List <int>();
if (FormuleListeCategories != null)
{
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = FormuleListeCategories.Eval(contexteEval);
if (!result)
{
return(result);
}
IEnumerable lst = result.Data as IEnumerable;
if (lst != null)
{
foreach (object obj in lst)
{
if (obj is int)
{
lstIds.Add((int)obj);
}
if (obj is CCategorieGED)
{
lstIds.Add(((CCategorieGED)obj).Id);
}
}
}
}
result = service.RunService(lstIds);
if (result && result.Data is IEnumerable)
{
List <CDocumentGED> lstDocs = new List <CDocumentGED>();
foreach (object obj in (IEnumerable)result.Data)
{
CInfoFichierToGed info = obj as CInfoFichierToGed;
if (info != null)
{
string strContenu = info.FileFullName;
CSourceDocument sourceDoc = null;
result = serviceGetFile.RunService(strContenu);
if (!result)
{
return(result);
}
sourceDoc = result.Data as CSourceDocument;
if (sourceDoc == null)
{
result.EmpileErreur(I.T("Error while retrieving file @1|20020", strContenu));
return(result);
}
//On a notre fichier en local, création du document
string strCle = "";
string strLibelle = "";
info.ActiveProcess = contexte.Branche.Process;
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(info);
if (FormuleCle != null)
{
result = FormuleCle.Eval(ctxEval);
if (result && result.Data != null)
{
strCle = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("Document key could not be computed|30050"));
return(result);
}
}
if (FormuleLibelleDocument != null)
{
result = FormuleLibelleDocument.Eval(ctxEval);
if (result && result.Data != null)
{
strLibelle = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("Document label could not be computed|30051"));
return(result);
}
}
if (strLibelle.Length == 0)
{
strLibelle = info.FileName;
}
CObjetDonneeAIdNumerique associeA = null;
if (FormuleElementAssocie != null)
{
result = FormuleElementAssocie.Eval(ctxEval);
if (result)
{
associeA = result.Data as CObjetDonneeAIdNumerique;
}
}
CDocumentGED doc = new CDocumentGED(contexte.ContexteDonnee);
//Si la clé n'est pas nulle, cherche un document avec cette clé
if (strCle.Trim() != "")
{
CFiltreData filtre = new CFiltreData(CDocumentGED.c_champCle + "=@1", strCle);
if (!doc.ReadIfExists(filtre))
{
doc.CreateNew();
}
else
{
doc.BeginEdit();
}
}
else
{
doc.CreateNew();
}
doc.Libelle = strLibelle;
doc.Cle = strCle;
ArrayList lstToCreate = new ArrayList();
lstToCreate.Add(info.EDMCategoryId);
ArrayList lstToDelete = new ArrayList();
//Affecte les catégories
CListeObjetsDonnees listeCategoriesExistantes = CRelationDocumentGED_Categorie.GetRelationsCategoriesForDocument(doc);
foreach (CRelationDocumentGED_Categorie rel in listeCategoriesExistantes)
{
if (!lstToCreate.Contains(rel.Categorie.Id))
{
lstToDelete.Add(rel);
}
lstToCreate.Remove(rel.Categorie.Id);
}
foreach (CRelationDocumentGED_Categorie rel in lstToDelete)
{
rel.Delete();
}
foreach (int nId in lstToCreate)
{
CCategorieGED cat = new CCategorieGED(doc.ContexteDonnee);
if (cat.ReadIfExists(nId))
{
CRelationDocumentGED_Categorie rel = new CRelationDocumentGED_Categorie(doc.ContexteDonnee);
rel.CreateNewInCurrentContexte();
rel.Categorie = cat;
rel.Document = doc;
}
}
result = CDocumentGED.SaveDocument(contexte.IdSession, sourceDoc, sourceDoc.TypeReference, doc.ReferenceDoc, true);
if (!result)
{
return(result);
}
CReferenceDocument refDoc = result.Data as CReferenceDocument;
doc.ReferenceDoc = refDoc;
if (associeA != null)
{
doc.AssocieA(associeA);
}
result = doc.CommitEdit();
if (!result)
{
return(result);
}
lstDocs.Add(doc);
}
}
if (VariableResultat != null)
{
Process.SetValeurChamp(VariableResultat, lstDocs.ToArray());
}
return(result);
}
}
}
}
}
//Utilisateur pas accessible
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienUtilisateurAbsent)
{
result.Data = lien;
return(result);
}
}
return(result);
}
//Le data du result contient la valeur de retour du process
protected CResultAErreur ExecuteProcess(
CSessionClient session,
object objetCible,
CProcess leProcessAExecuter,
CContexteDonnee contexte,
bool bSauvegardeDuContexteExecutionExterne,
IIndicateurProgression indicateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Register(indicateur);
/// Stef, le 2/4/08 : pb rencontré : leProcessAExecuter peut être
/// lié à un autre CContexteDonnee que celui dans lequel on execute l'action
/// en effet, il est alloué dans un CContexteDonnee, mais un autre CContexteDonnee
/// peut être recréé pour que l'execution.
/// OR, dans ce cas, les variables calculées évaluées par le CProcess se trouvent dans
/// le contexte du process, donc, pas dans le contexte d'execution et les modifs
/// sur ces variables ne sont donc pas sauvegardées !
/// d'où la ligne suivante : leProcessAExecuter.ContexteDonnee = contexte
leProcessAExecuter.ContexteDonnee = contexte;
//Fin Stef 2/4/08
CResultAErreur result = CResultAErreur.True;
CProcessEnExecutionInDb processEnExec = new CProcessEnExecutionInDb(contexte);
processEnExec.CreateNewInCurrentContexte();
if (objetCible is CObjetDonneeAIdNumerique)
{
processEnExec.ElementLie = (CObjetDonneeAIdNumerique)objetCible;
}
else
{
processEnExec.ElementLie = null;
}
processEnExec.Libelle = leProcessAExecuter.Libelle;
processEnExec.DbKeyEvennementDeclencheur = leProcessAExecuter.InfoDeclencheur.DbKeyEvenementDeclencheur;
processEnExec.IdVersionExecution = contexte.IdVersionDeTravail;
CBrancheProcess branche = new CBrancheProcess(leProcessAExecuter);
branche.IsModeAsynchrone = leProcessAExecuter.ModeAsynchrone;
CSessionClient sessionSource = CSessionClient.GetSessionForIdSession(IdSession);
//TESTDBKEYTODO
branche.KeyUtilisateur = sessionSource.GetInfoUtilisateur().KeyUtilisateur;
branche.ConfigurationImpression = sessionSource.ConfigurationsImpression;
CContexteExecutionAction contexteExecution = new CContexteExecutionAction(
processEnExec,
branche,
objetCible,
contexte,
leProcessAExecuter.ModeAsynchrone ? null : indicateur);
contexteExecution.SauvegardeContexteExterne = bSauvegardeDuContexteExecutionExterne;
//Mode synchrone
if (!leProcessAExecuter.ModeAsynchrone)
{
bool bTrans = false;
if (!bSauvegardeDuContexteExecutionExterne && leProcessAExecuter.ModeTransactionnel)
{
contexte.SaveAll(true);//Sauve le contexte en execution avant démarrage
session.BeginTrans();
bTrans = true;
}
try
{
result = branche.ExecuteAction(leProcessAExecuter.GetActionDebut(), 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();
}
}
}
if (!result)
{
result.EmpileErreur(I.T("Erreur in @1 process|20001", leProcessAExecuter.Libelle));
}
if (leProcessAExecuter.VariableDeRetour != null)
{
result.Data = leProcessAExecuter.GetValeurChamp(leProcessAExecuter.VariableDeRetour.IdVariable);
}
return(result);
}
else
{
//Ouvre une nouvelle session pour éxecuter le process
if (leProcessAExecuter.ModeAsynchrone)
{
CSessionProcessServeurSuivi sessionAsync = new CSessionProcessServeurSuivi();
result = sessionAsync.OpenSession(new CAuthentificationSessionProcess(),
"Process " + leProcessAExecuter.Libelle,
session);
if (!result)
{
return(result);
}
session = sessionAsync;
}
contexteExecution.ChangeIdSession(session.IdSession);
contexteExecution.HasSessionPropre = true;
m_brancheToExecute = branche;
m_actionToExecute = leProcessAExecuter.GetActionDebut();
m_contexteExecutionProcess = contexteExecution;
Thread th = new Thread(new ThreadStart(DemarreProcess));
th.Start();
return(result);
}
}
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
if (FormuleDocument == null)
{
result.EmpileErreur(I.T("Incorrect document formula|363"));
return(result);
}
result = FormuleDocument.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during Document evaluation|367"));
return(result);
}
if (!(result.Data is CDocumentGED))
{
result.EmpileErreur(I.T("The document formula must return an EDM document|364"));
return(result);
}
CDocumentGED document = (CDocumentGED)result.Data;
if (FormuleNomFichier == null)
{
result.EmpileErreur(I.T("Incorrect file name formula|365"));
return(result);
}
result = FormuleNomFichier.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during the destination file name of document evaluation|368"));
return(result);
}
if (!(result.Data is string))
{
result.EmpileErreur(I.T("File name formula doesn't return a file name string|369"));
return(result);
}
string strNomFichier = result.Data.ToString();
if (strNomFichier.ToUpper().StartsWith("FTP://"))
{
string strUser = "";
string strPassword = "";
if (FormuleUser != null)
{
result = FormuleUser.Eval(contexteEval);
}
if (!result)
{
result.EmpileErreur(I.T("Error in User formula|20250"));
return(result);
}
else
{
strUser = result.Data != null?result.Data.ToString() : "";
}
if (FormulePassword != null)
{
result = FormulePassword.Eval(contexteEval);
}
if (!result)
{
result.EmpileErreur(I.T("Error in password formula|20250"));
return(result);
}
else
{
strPassword = result.Data != null?result.Data.ToString() : "";
}
return(CopyToFtp(contexte.IdSession, document, strNomFichier, strUser, strPassword));
}
else if (CopierDepuisLePosteClient)
{
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (sessionClient != null)
{
//TESTDBKEYOK
if (sessionClient.GetInfoUtilisateur().KeyUtilisateur == contexte.Branche.KeyUtilisateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
CServiceSurClient service = sessionClient.GetServiceSurClient(c_idServiceClientSetFichier);
if (service != null)
{
sponsor.Register(service);
CParametreCopierLocalDansGed parametre = new CParametreCopierLocalDansGed(
document.Id,
strNomFichier);
result = service.RunService(parametre);
return(result);
}
}
}
}
}
if (File.Exists(strNomFichier))
{
#region renommage du fichier existant
if (FormuleNomFichierRenommage != null)
{
result = FormuleNomFichierRenommage.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error in the renaming file name|370"));
return(result);
}
if (!(result.Data is string))
{
result.EmpileErreur(I.T("The renaming formula doesn't return text|371"));
return(result);
}
int nIndex = 0;
string strRename = result.Data.ToString();
string strExt = "";
nIndex = strNomFichier.LastIndexOf('.');
string strNom = strRename;
if (nIndex >= 0)
{
strNom = strRename.Substring(0, nIndex);
strExt = strRename.Substring(nIndex);
strRename = strNom;
}
nIndex = 0;
while (File.Exists(strNom + strExt))
{
nIndex++;
strNom = strRename + "_" + nIndex;
}
try
{
if (strExt != "")
{
strNom = strNom + strExt;
}
File.Copy(strNomFichier, strNom, true);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("New name : '@1'|372", strNom));
result.EmpileErreur(I.T("Error during file renaming|373"));
return(result);
}
}
#endregion
}
try
{
using (CProxyGED proxy = new CProxyGED(contexte.IdSession, document.ReferenceDoc))
{
result = proxy.CopieFichierEnLocal();
if (!result)
{
return(result);
}
//Si le fichier existe, il est renommé
File.Copy(proxy.NomFichierLocal, strNomFichier, true);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
return(result);
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
try
{
// Récupère la structure par formule ou structure propore
m_structureUtiliseeAExecution = StructureExport;
IVariableDynamique variableProcess = AssureVariableProcessDansStructure();
m_structureUtiliseeAExecution.SetValeurChamp(variableProcess.IdVariable, Process);
m_structureUtiliseeAExecution.ContexteDonnee = contexte.ContexteDonnee;
// Si la structure possede un formulaire il faut lancer le service sur le poste client
if (m_structureUtiliseeAExecution != null && m_structureUtiliseeAExecution.Formulaire != null && m_structureUtiliseeAExecution.Formulaire.Childs.Length > 0)
{
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (sessionClient != null)
{
//TESTDBKEYOK
if (sessionClient.GetInfoUtilisateur().KeyUtilisateur == contexte.Branche.KeyUtilisateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
CServiceSurClient service = sessionClient.GetServiceSurClient(c_idServiceClientExporterDonnees);
if (service != null)
{
sponsor.Register(service);
result = service.RunService(this);
E2iDialogResult dResult = (E2iDialogResult)result.Data;
if (dResult == E2iDialogResult.Cancel)
{
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienFromDialog &&
((CLienFromDialog)lien).ResultAssocie == dResult)
{
result.Data = lien;
return(result);
}
}
}
}
else
{
//Utilisateur pas accessible
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienUtilisateurAbsent)
{
result.Data = lien;
return(result);
}
}
}
}
}
}
else
{
//Utilisateur pas accessible
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienUtilisateurAbsent)
{
result.Data = lien;
return(result);
}
}
}
}
result = m_structureUtiliseeAExecution.GetDataSet(Exporteur.ExporteStructureOnly);
if (!result)
{
result.EmpileErreur(I.T("Error while exporting data|405"));
return(result);
}
DataSet ds = (DataSet)result.Data;
// Fichier d'export retourné
CFichierLocalTemporaire fichierExport = new CFichierLocalTemporaire(Exporteur.ExtensionParDefaut);
fichierExport.CreateNewFichier();
CDestinationExportFile dest = new CDestinationExportFile(fichierExport.NomFichier);
result = Exporteur.Export(ds, dest);
if (!result)
{
result.EmpileErreur(I.T("Error while creating export file|406"));
return(result);
}
#region Stockage dans la ged
CContexteEvaluationExpression contexteEvaluation = new CContexteEvaluationExpression(Process);
//On a notre fichier export, création du document
string strCle = "";
string strDescriptif = "";
string strLibelle = "";
result = ExpressionCle.Eval(contexteEvaluation);
if (result)
{
strCle = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("The document key could not be calculated|407"));
return(result);
}
result = ExpressionLibelle.Eval(contexteEvaluation);
if (result)
{
strLibelle = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("The document label could not be calculated|408"));
return(result);
}
result = ExpressionDescriptif.Eval(contexteEvaluation);
if (result)
{
strDescriptif = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("The document description could not be calculated|409"));
return(result);
}
CDocumentGED doc = new CDocumentGED(contexte.ContexteDonnee);
//Si la clé n'est pas nulle, cherche un document avec cette clé
if (strCle.Trim() != "")
{
CFiltreData filtre = new CFiltreData(CDocumentGED.c_champCle + "=@1", strCle);
if (!doc.ReadIfExists(filtre))
{
doc.CreateNew();
}
else
{
doc.BeginEdit();
}
}
else
{
doc.CreateNew();
}
doc.Libelle = strLibelle;
doc.Descriptif = strDescriptif;
doc.Cle = strCle;
ArrayList lstToCreate = (ArrayList)ListeIdsCategoriesStockage.Clone();
ArrayList lstToDelete = new ArrayList();
//Affecte les catégories
CListeObjetsDonnees listeCategoriesExistantes = CRelationDocumentGED_Categorie.GetRelationsCategoriesForDocument(doc);
foreach (CRelationDocumentGED_Categorie rel in listeCategoriesExistantes)
{
if (!lstToCreate.Contains(rel.Categorie.Id))
{
lstToDelete.Add(rel);
}
lstToCreate.Remove(rel.Categorie.Id);
}
foreach (CRelationDocumentGED_Categorie rel in lstToDelete)
{
rel.Delete();
}
foreach (int nId in lstToCreate)
{
CCategorieGED cat = new CCategorieGED(doc.ContexteDonnee);
if (cat.ReadIfExists(nId))
{
CRelationDocumentGED_Categorie rel = new CRelationDocumentGED_Categorie(doc.ContexteDonnee);
rel.CreateNewInCurrentContexte();
rel.Categorie = cat;
rel.Document = doc;
}
}
CProxyGED proxy = new CProxyGED(Process.IdSession, doc.IsNew() ? null : doc.ReferenceDoc);
proxy.AttacheToLocal(fichierExport.NomFichier);
result = proxy.UpdateGed();
if (!result)
{
return(result);
}
doc.ReferenceDoc = (CReferenceDocument)result.Data;
result = doc.CommitEdit();
fichierExport.Dispose();
if (VariableResultat != null)
{
Process.SetValeurChamp(VariableResultat, doc);
}
#endregion
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienFromDialog &&
((CLienFromDialog)lien).ResultAssocie != E2iDialogResult.Cancel)
{
result.Data = lien;
return(result);
}
}
result.Data = null;
return(result);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
}
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);
}
}
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (sessionClient != null)
{
//TESTDBKEYOK
if (sessionClient.GetInfoUtilisateur().KeyUtilisateur == contexte.Branche.KeyUtilisateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
CServiceSurClient service = sessionClient.GetServiceSurClient(c_idServiceClientGetFichier);
CParametresCopierLocalDansGed parametreService = new CParametresCopierLocalDansGed();
CFichierLocalTemporaire fichierLocal = null;
FileStream localStream = null;
if (service != null)
{
sponsor.Register(service);
//Calcule le contenu
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = ExpressionContenu.Eval(contexteEval);
if (!result)
{
return(result);
}
parametreService.NomFichierLocal = result.Data as string;
if (ExpressionUser != null && (result = ExpressionUser.Eval(contexteEval)))
{
if (result.Data != null)
{
parametreService.User = result.Data.ToString();
}
}
if (ExpressionPassword != null && (result = ExpressionPassword.Eval(contexteEval)))
{
if (result.Data != null)
{
parametreService.Password = result.Data.ToString();
}
}
CSourceDocument sourceDoc = null;
if (parametreService.NomFichierLocal.ToUpper().StartsWith("FTP://"))
{
CResultAErreurType <CFichierLocalTemporaire> resFic = GetFileFromFtp(
parametreService);
if (!resFic)
{
result.EmpileErreur(resFic.Erreur);
return(result);
}
fichierLocal = resFic.DataType;
localStream = new FileStream(fichierLocal.NomFichier, FileMode.Open, FileAccess.Read);
sourceDoc = new CSourceDocumentStream(localStream, "txt");
}
else if (!m_bCreerFichierTexteAPartirDeLaFormuleContenu)
{
result = service.RunService(parametreService);
if (!result)
{
return(result);
}
sourceDoc = result.Data as CSourceDocument;
if (sourceDoc == null)
{
result.EmpileErreur(I.T("Error while retrieving file @1|20020", parametreService.NomFichierLocal));
return(result);
}
}
else
{
fichierLocal = new CFichierLocalTemporaire("txt");
localStream = new FileStream(fichierLocal.NomFichier, FileMode.CreateNew, FileAccess.Write);
StreamWriter writer = new StreamWriter(localStream);
writer.Write(parametreService.NomFichierLocal);
writer.Close();
localStream.Close();
localStream = new FileStream(fichierLocal.NomFichier, FileMode.Open, FileAccess.Read);
sourceDoc = new CSourceDocumentStream(localStream, "txt");
}
//On a notre fichier en local, création du document
string strCle = "";
string strDescriptif = "";
string strLibelle = "";
result = ExpressionCle.Eval(contexteEval);
if (result)
{
strCle = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("Document key could not be computed|30050"));
return(result);
}
result = ExpressionLibelle.Eval(contexteEval);
if (result)
{
strLibelle = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("Document label could not be computed|30051"));
return(result);
}
result = ExpressionDescriptif.Eval(contexteEval);
if (result)
{
strDescriptif = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("Document description could not be computed|30052"));
return(result);
}
CDocumentGED doc = new CDocumentGED(contexte.ContexteDonnee);
//Si la clé n'est pas nulle, cherche un document avec cette clé
if (strCle.Trim() != "")
{
CFiltreData filtre = new CFiltreData(CDocumentGED.c_champCle + "=@1", strCle);
if (!doc.ReadIfExists(filtre))
{
doc.CreateNew();
}
else
{
doc.BeginEdit();
}
}
else
{
doc.CreateNew();
}
doc.Libelle = strLibelle;
doc.Descriptif = strDescriptif;
doc.Cle = strCle;
List <CDbKey> lstToCreate = new List <CDbKey>(ListeDbKeysCategoriesStockage);
List <CRelationDocumentGED_Categorie> lstToDelete = new List <CRelationDocumentGED_Categorie>();
//Affecte les catégories
CListeObjetsDonnees listeCategoriesExistantes = CRelationDocumentGED_Categorie.GetRelationsCategoriesForDocument(doc);
foreach (CRelationDocumentGED_Categorie rel in listeCategoriesExistantes)
{
if (!lstToCreate.Contains(rel.Categorie.DbKey))
{
lstToDelete.Add(rel);
}
lstToCreate.Remove(rel.Categorie.DbKey);
}
foreach (CRelationDocumentGED_Categorie rel in lstToDelete)
{
rel.Delete();
}
foreach (CDbKey dbKey in lstToCreate)
{
CCategorieGED cat = new CCategorieGED(doc.ContexteDonnee);
if (cat.ReadIfExists(dbKey))
{
CRelationDocumentGED_Categorie rel = new CRelationDocumentGED_Categorie(doc.ContexteDonnee);
rel.CreateNewInCurrentContexte();
rel.Categorie = cat;
rel.Document = doc;
}
}
result = CDocumentGED.SaveDocument(contexte.IdSession, sourceDoc, sourceDoc.TypeReference, doc.ReferenceDoc, true);
if (sourceDoc != null)
{
sourceDoc.Dispose();
}
if (localStream != null)
{
localStream.Dispose();
}
if (fichierLocal != null)
{
fichierLocal.Dispose();
}
if (!result)
{
return(result);
}
CReferenceDocument refDoc = result.Data as CReferenceDocument;
doc.ReferenceDoc = refDoc;
result = doc.CommitEdit();
if (!result)
{
return(result);
}
if (VariableResultat != null)
{
Process.SetValeurChamp(VariableResultat, doc);
}
return(result);
}
}
}
}
//Utilisateur pas accessible
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienUtilisateurAbsent)
{
result.Data = lien;
return(result);
}
}
return(result);
}
/// //////////////////////////////////////////////////
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);
}
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
//Si la session qui execute est une session de l'utilisateur associé à la branche,
//Tente d'afficher le formulaire sur cette session,
//Sinon, enregistre une Intervention sur l'utilisateur
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (sessionClient != null)
{
//TESTDBKEYOK
if (sessionClient.GetInfoUtilisateur().KeyUtilisateur == contexte.Branche.KeyUtilisateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Label = "Execute Action serveur";
CServiceSurClient service = sessionClient.GetServiceSurClient(c_idServiceClientFormulaire);
if (service != null)
{
sponsor.Register(service);
result = service.RunService(this);
if (!result)
{
return(result);
}
E2iDialogResult dResult = (E2iDialogResult)result.Data;
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienFromDialog &&
((CLienFromDialog)lien).ResultAssocie == dResult)
{
result.Data = lien;
return(result);
}
}
result.Data = null;
return(result);
}
else
{
//Utilisateur pas accessible
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienUtilisateurAbsent)
{
result.Data = lien;
return(result);
}
}
}
}
}
}
//Utilisateur pas accessible
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienUtilisateurAbsent)
{
result.Data = lien;
return(result);
}
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
string strCommandLine = "";
string strArguments = "";
//Calcule le fichier ou l'url
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = FormuleFichier.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during the File name or URL evaluation|236"));
return(result);
}
strCommandLine += result.Data;
// Calcul des Arguments
result = FormuleArguments.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during the Arguments evaluation|308"));
return(result);
}
strArguments += result.Data;
if (m_bSurServeur)
{
//Lance le programme depuis le serveur
System.Diagnostics.Process process = new System.Diagnostics.Process();
process.StartInfo.FileName = strCommandLine;
process.StartInfo.Arguments = strArguments;
process.StartInfo.UseShellExecute = true;
process.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Minimized;
try
{
process.Start();
if (m_bWaitForExit)
{
process.WaitForExit();
int nRetour = process.ExitCode;
CVariableDynamique variable = VariableResultat;
if (variable != null)
{
Process.SetValeurChamp(variable, nRetour);
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error in command line @1 @2|20011",
strCommandLine, strArguments));
}
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (!(lien is CLienUtilisateurAbsent))
{
result.Data = lien;
return(result);
}
}
result.Data = null;
return(result);
}
//Execution sur le client
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (sessionClient != null)
{
//TESTDBKEYOK
if (sessionClient.GetInfoUtilisateur().KeyUtilisateur == contexte.Branche.KeyUtilisateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
CServiceSurClient service = sessionClient.GetServiceSurClient(CInfoServiceClientOuvrirFichier.c_idServiceClientOuvrirFichier);
if (service != null)
{
sponsor.Register(service);
CInfoServiceClientOuvrirFichier infoService = new CInfoServiceClientOuvrirFichier(strCommandLine, strArguments, WaitForExit);
result = service.RunService(infoService);
if (!result)
{
return(result);
}
CVariableDynamique variable = VariableResultat;
if (variable != null && result.Data is int && WaitForExit)
{
Process.SetValeurChamp(variable, result.Data);
}
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (!(lien is CLienUtilisateurAbsent))
{
result.Data = lien;
return(result);
}
}
result.Data = null;
return(result);
}
}
}
}
//Utilisateur pas accessible
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienUtilisateurAbsent)
{
result.Data = lien;
return(result);
}
}
return(result);
}
/// //////////////////////////////////////////////////
///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 ExportComplexe(
int nIdSession,
IEnumerable list,
ref DataSet ds,
IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablesPourFiltres,
IIndicateurProgression indicateur)
{
if (m_cacheValeurs == null)
{
m_cacheValeurs = new CCacheValeursProprietes();
}
C2iSponsor sponsor = new C2iSponsor();
sponsor.Register(indicateur);
sponsor.Register(elementAVariablesPourFiltres);
CResultAErreur result = CResultAErreur.True;
try
{
indicateur = CConteneurIndicateurProgression.GetConteneur(indicateur);
DateTime dt = DateTime.Now;
//... Création des tables et des champs ...
bool bIsOptimisable = (list is CListeObjetsDonnees &&
typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(((CListeObjetsDonnees)list).TypeObjets)) ||
list == null;
result = CreateTableComplexeInDataset(bIsOptimisable, this.TypeSource, this.m_table, ds, null);
if (!result)
{
return(result);
}
AddTablesCalculees(ds, elementAVariablesPourFiltres);
if (list == null)
{
return(result);
}
m_cacheValeurs.CacheEnabled = true;
//ds.EnforceConstraints = false;
try
{
CInterpreteurProprieteDynamique.AssociationsSupplementaires.AssocieObjet(null, elementAVariablesPourFiltres);
CFournisseurGeneriqueProprietesDynamiques.AssocieObjetSupplementaire(null, new CObjetPourSousProprietes(elementAVariablesPourFiltres));
result = m_table.InsertDataInDataSet(list, ds, null, 0, elementAVariablesPourFiltres, m_cacheValeurs, null, true, CConteneurIndicateurProgression.GetConteneur(indicateur));
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
CInterpreteurProprieteDynamique.AssociationsSupplementaires.DissocieObjet(null, elementAVariablesPourFiltres);
CFournisseurGeneriqueProprietesDynamiques.DissocieObjetSupplementaire(null, new CObjetPourSousProprietes(elementAVariablesPourFiltres));
}
//ds.EnforceConstraints = true;
m_cacheValeurs.ResetCache();
m_cacheValeurs.CacheEnabled = false;
if (!result)
{
return(result);
}
result = m_table.EndInsertData(ds);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
sponsor.Unregister(indicateur);
sponsor.Unregister(elementAVariablesPourFiltres);
sponsor.Dispose();
}
return(result);
}
