/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
if (m_expressionElementAAssocier == null)
{
result.EmpileErreur(I.T("Not element to be associated|110"));
return(result);
}
result = m_expressionElementAAssocier.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error in element to be associated formula|111"));
return(result);
}
if (result.Data != null)
{
if (!(result.Data is CObjetDonneeAIdNumerique))
{
result.EmpileErreur(I.T("The element to be associated formula doesn't return a work entity|112"));
return(result);
}
CComportementGenerique comportement = new CComportementGenerique(contexte.ContexteDonnee);
if (!comportement.ReadIfExists(m_dbKeyComportement))
{
result.EmpileErreur(I.T("The @1 behavior doesn't exist|113", m_dbKeyComportement.ToString()));
return(result);
}
comportement.AddComportementToObjet((CObjetDonneeAIdNumerique)result.Data);
}
return(result);
}
/// //////////////////////////////////////////////////////////////
protected override sc2i.common.CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
IDeclencheurActionSurServeur declencheur = (IDeclencheurActionSurServeur)C2iFactory.GetNewObjetForSession("CDeclencheurActionSurServeur", typeof(IDeclencheurActionSurServeur), contexte.IdSession);
if (declencheur == null)
{
result.EmpileErreur(I.T("Release action allocation server fail|187"));
return(result);
}
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
Hashtable valeursParametres = new Hashtable();
foreach (DictionaryEntry entry in m_tableValeursParametres)
{
string strProp = (string)entry.Key;
C2iExpression expression = (C2iExpression)entry.Value;
//Cherche la propriété
result = expression.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during @1 value evaluation|188", entry.Key.ToString()));
return(result);
}
valeursParametres[entry.Key] = result.Data;
}
return(declencheur.ExecuteAction(m_strCodeActionServeur, valeursParametres));
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
if (FormuleDateLimite == null)
{
result.EmpileErreur(I.T("You have to specify a limit date|20008"));
return(result);
}
result = FormuleDateLimite.Eval(contexteEval);
if (!result)
{
return(result);
}
if (!(result.Data is DateTime))
{
result.EmpileErreur(I.T("Bad limit date|20009"));
return(result);
}
result = CVersionDonnees.Purger((DateTime)result.Data, contexte.IdSession);
return(result);
}
//------------------------------------------------------------
public CResultAErreur GetValue(object objet, string strPropriete)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression contexte = new CContexteEvaluationExpression(objet);
if (objet is CObjetDonnee)
{
contexte.AttacheObjet(typeof(CContexteDonnee), ((CObjetDonnee)objet).ContexteDonnee);
}
Type tpAnalyse = null;
if (objet != null)
{
tpAnalyse = objet.GetType();
}
CContexteAnalyse2iExpression ctx = new CContexteAnalyse2iExpression(new CFournisseurPropDynStd(), tpAnalyse);
CAnalyseurSyntaxiqueExpression analyseur = new CAnalyseurSyntaxiqueExpression(ctx);
result = analyseur.AnalyseChaine(strPropriete);
if (!result)
{
return(result);
}
C2iExpression formule = (C2iExpression)result.Data;
result = formule.Eval(contexte);
if (result)
{
return(result);
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
if (m_expressionElementADissocier == null)
{
result.EmpileErreur(I.T("No element to be dissociated|169"));
return(result);
}
result = m_expressionElementADissocier.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error in the elements to be dissociated formula|170"));
return(result);
}
if (result.Data != null)
{
if (!(result.Data is CObjetDonneeAIdNumerique))
{
result.EmpileErreur(I.T("The element to be dissociated formula must be return a work entity|167"));
return(result);
}
CComportementGenerique comportement = new CComportementGenerique(contexte.ContexteDonnee);
if (!comportement.ReadIfExists(m_dbKeyComportement))
{
return(result);
}
comportement.RemoveComportementFromObjet((CObjetDonneeAIdNumerique)result.Data);
}
return(result);
}
/// ////////////////////////////////////////////////////////
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 object GetValue(object objet)
{
if (m_formule == null)
{
return(null);
}
if (m_contexteEval == null)
{
m_contexteEval = new CContexteEvaluationExpression(objet);
m_contexteEval.UseOptimiseurs = true;
}
else
{
m_contexteEval.ChangeSource(objet);
}
if (objet is CObjetDonnee)
{
m_contexteEval.AttacheObjet(typeof(CContexteDonnee), ((CObjetDonnee)objet).ContexteDonnee);
}
CResultAErreur result = m_formule.Eval(m_contexteEval);
if (result)
{
return(result.Data);
}
return(null);
}
/// /////////////////////////////////////////////////////////////////////////////////////
private static CResultAErreur ExecuteActionFormulairePopup(CActionSur2iLinkFormulairePopup actionPopup, object sender, object objetCible)
{
CResultAErreur result = CResultAErreur.True;
C2iExpression formuleElement = actionPopup.FormuleElementEdite;
IObjetDonnee elementEdite = null;
if (formuleElement != null)
{
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(objetCible);
ctxEval.AttacheObjet(typeof(CContexteDonnee), CSc2iWin32DataClient.ContexteCourant);
result = formuleElement.Eval(ctxEval);
if (!result)
{
result.EmpileErreur(I.T("Element evaluation error|30084"));
return(result);
}
if (result.Data == null)
{
result.EmpileErreur(I.T("Not avaliable|30082"));
return(result);
}
elementEdite = result.Data as IObjetDonnee;
}
else
{
elementEdite = objetCible as IObjetDonnee;
}
if (elementEdite != null)
{
Point pt = Cursor.Position;
bool bModeEdition = false;
if (sender != null)
{
pt = ((Control)sender).Location;
Form frm = ((Control)sender).FindForm();
if (frm != null && frm is CFormEditionStandard)
{
bModeEdition = ((CFormEditionStandard)frm).ModeEdition;
}
}
CFormExecuteActionFormulairePopup.Popup(
pt,
actionPopup,
elementEdite,
bModeEdition);
}
else
{
result.EmpileErreur(I.T("Popup form element is not a valid object|20882"));
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CObjetDonneeAIdNumeriqueAuto objet = (CObjetDonneeAIdNumeriqueAuto)Activator.CreateInstance(m_typeEntiteACreer, new object[] { contexte.ContexteDonnee });
objet.CreateNewInCurrentContexte();
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
foreach (DictionaryEntry entry in m_tableValeursProprietes)
{
string strProp = (string)entry.Key;
C2iExpression expression = (C2iExpression)entry.Value;
//Cherche la propriété
PropertyInfo info = m_typeEntiteACreer.GetProperty(strProp);
string strNomConvivial = strProp;
object[] attr = info.GetCustomAttributes(typeof(DynamicFieldAttribute), true);
if (attr.Length > 0)
{
strNomConvivial = ((DynamicFieldAttribute)attr[0]).NomConvivial;
}
MethodInfo methode = info.GetSetMethod();
if (methode != null)
{
//Evalue la valeur
result = expression.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during the @1 value evaluation|140", strNomConvivial));
return(result);
}
try
{
methode.Invoke(objet, new object[] { result.Data });
}
catch (Exception e)
{
result.EmpileErreur(I.T("Error during the assignment of @1 property|141", strNomConvivial));
result.EmpileErreur(e.Message);
return(result);
}
}
}
if (VariableResultat != null)
{
Process.SetValeurChamp(VariableResultat, objet);
}
CLienAction[] liens = GetLiensSortantHorsErreur();
if (liens.Length > 0)
{
result.Data = liens[0];
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
//Evalue l'objet source
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = FormuleSource.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error in object source formula|255"));
return(result);
}
//Pas d'objet source, pas grave
if (result.Data == null)
{
return(result);
}
if (!(result.Data is CObjetDonneeAIdNumerique))
{
result.EmpileErreur(I.T("The source object formula must return a work entity|257"));
return(result);
}
CObjetDonneeAIdNumerique objetSource = (CObjetDonneeAIdNumerique)result.Data;
result = FormuleDest.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error in target object formula|256"));
return(result);
}
//Pas d'objet dest, pas grave
if (result.Data == null)
{
return(result);
}
if (!(result.Data is CObjetDonneeAIdNumerique))
{
result.EmpileErreur(I.T("The target object formula must return a work entity|254"));
return(result);
}
CObjetDonneeAIdNumerique objetDest = (CObjetDonneeAIdNumerique)result.Data;
CSynchronismeDonnees.CreateSynchronisme(
contexte.ContexteDonnee,
objetSource,
objetDest,
ChampSource,
ChampDest,
FormuleConditionSource,
FormuleConditionDest);
return(result);
}
//--------------------------------------------------------
public override CResultAErreur GetValue(DataRow rowSource, CContexteImportDonnee contexteImport)
{
CResultAErreur result = CResultAErreur.True;
if (Formule != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(rowSource);
ctx.AttacheObjet(typeof(CContexteDonnee), contexteImport.ContexteDonnee);
result = Formule.Eval(ctx);
}
return(result);
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
CInterrogateurSnmp agent = ctx.GetObjetAttache(typeof(CInterrogateurSnmp)) as CInterrogateurSnmp;
if (agent == null)
{
agent = new CInterrogateurSnmp();
ctx.AttacheObjet(typeof(CInterrogateurSnmp), agent);
}
result.Data = agent;
return(result);
}
/// ///////////////////////////////////////////
public object GetValeur(IElementAVariablesDynamiquesAvecContexteDonnee elementInterroge)
{
if (Expression == null)
{
return(null);
}
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(elementInterroge);
ctx.AttacheObjet(typeof(CContexteDonnee), elementInterroge.ContexteDonnee);
CResultAErreur result = Expression.Eval(ctx);
if (!result)
{
return(null);
}
return(result.Data);
}
//--------------------------------------
public CResultAErreur AffecteProprietes(
object elementToModif,
object sourceElement,
IFournisseurProprietesDynamiques fournisseurProprietes)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(sourceElement);
CResultAErreur resTmp;
foreach (KeyValuePair <CDefinitionProprieteDynamique, C2iExpression> aff in m_dicAffectations)
{
if (aff.Value != null)
{
resTmp = aff.Value.Eval(ctx);
if (!resTmp)
{
result += resTmp;
}
else
{
resTmp = CInterpreteurProprieteDynamique.SetValue(elementToModif, aff.Key.NomPropriete, resTmp.Data);
if (!resTmp)
{
result += resTmp;
}
}
}
}
if (m_formuleGlobale != null)
{
CDefinitionMultiSourceForExpression def = new CDefinitionMultiSourceForExpression(sourceElement,
new CSourceSupplementaire("NewElement", elementToModif));
ctx = new CContexteEvaluationExpression(def);
if (elementToModif is IAllocateurSupprimeurElements)
{
ctx.AttacheObjet(typeof(IAllocateurSupprimeurElements), elementToModif);
}
resTmp = m_formuleGlobale.Eval(ctx);
if (!resTmp)
{
result += resTmp;
}
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
//Calcule le message
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = FormuleMessage.Eval(contexteEval);
if (!result)
{
return(result);
}
else
{
result.EmpileErreur(result.Data.ToString());
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
string strCodeAttente = "";
if (FormuleCodeAttente != null)
{
result = FormuleCodeAttente.Eval(contexteEval);
if (!result || result.Data == null)
{
strCodeAttente = "";
}
else
{
strCodeAttente = result.Data.ToString();
}
}
//Si le code d'attente n'est pas null et qu'il y a déjà une attente,
//il faut la supprimer
if (strCodeAttente != null && strCodeAttente.Trim() != "")
{
CFiltreData filtre = new CFiltreData(CBesoinInterventionProcess.c_champCodeAttente + "=@1",
strCodeAttente);
CListeObjetsDonnees listeToDelete = new CListeObjetsDonnees(contexte.ContexteDonnee, typeof(CBesoinInterventionProcess));
listeToDelete.Filtre = filtre;
if (listeToDelete.Count != 0)
{
CObjetDonneeAIdNumerique.Delete(listeToDelete);
}
}
CLienAction[] liens = GetLiensSortantHorsErreur();
if (liens.Length > 0)
{
result.Data = liens[0];
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
//Calcule la nouvelle valeur
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = ExpressionValeur.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during @1 formula evaluation|216", ExpressionValeur.ToString()));
return(result);
}
object nouvelleValeur = result.Data;
IDatabaseRegistre registre = (IDatabaseRegistre)C2iFactory.GetNew2iObjetServeur(typeof(IDatabaseRegistre), contexte.IdSession);
registre.SetValeur(m_strCleRegistre, nouvelleValeur == null?"":nouvelleValeur.ToString());
return(result);
}
/// //////////////////////////////////////////////////
public object Calcule(object objetEvalue, CFournisseurPropDynStd fournisseur)
{
if (objetEvalue == null)
{
return(null);
}
if (fournisseur == null)
{
fournisseur = new CFournisseurPropDynStd();
}
CContexteEvaluationExpression contexte = new CContexteEvaluationExpression(objetEvalue);
contexte.AttacheObjet(typeof(CContexteDonnee), ContexteDonnee);
CResultAErreur result = Formule.Eval(contexte);
contexte.DetacheObjet(typeof(CContexteDonnee));
if (result)
{
return(result.Data);
}
return(null);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
result = VerifieDonnees();
if (!result)
{
return(result);
}
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = ExpressionCondition.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during the condition formula evaluation|135"));
return(result);
}
if (!(result.Data is bool))
{
result.EmpileErreur(I.T("The confition formula doesn't return a boolean|136"));
return(result);
}
bool bResult = (bool)result.Data;
foreach (CLienFromCondition lien in GetLiensSortantHorsErreur())
{
if (lien.IsSiOui && bResult)
{
result.Data = lien;
}
if (!lien.IsSiOui && !bResult)
{
result.Data = lien;
}
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
object elementToModif = Process.GetValeurChamp(VariableAModifier.IdVariable);
if (elementToModif == null)
{
return(result);
}
if (elementToModif is CObjetDonneeAIdNumerique)
{
//Calcule la nouvelle valeur
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = ExpressionValeur.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during @1 formula evaluation|216", ExpressionValeur.ToString()));
return(result);
}
string strNouvelleValeur = result.Data == null ? "" : result.Data.ToString();
//Trouve la variable
CVariableSurObjet variable = new CVariableSurObjet(contexte.ContexteDonnee);
if (!variable.ReadIfExists(m_nIdVariableSurObjet))
{
result.EmpileErreur(I.T("The variable doesn't exist|233"));
}
else
{
CValeurVariableSurObjet.SetValeur(
variable.Nom,
(CObjetDonneeAIdNumerique)elementToModif,
strNouvelleValeur);
}
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
result = contexte.ContexteDonnee.SaveAll(true);
if (!result)
{
return(result);
}
//Calcule la version
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = FormuleVersion.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during the version formula evaluation|307"));
return(result);
}
int?nIdVersion = null;
if (result.Data is int)
{
nIdVersion = (int)result.Data;
}
if (result.Data is CVersionDonnees)
{
nIdVersion = ((CVersionDonnees)result.Data).Id;
}
result = contexte.ContexteDonnee.SetVersionDeTravail(nIdVersion, true);
if (!result)
{
return(result);
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
//Calcule le fichier ou l'url
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = FormuleLibelle.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during the Label evaluation|20002"));
return(result);
}
CVersionDonnees version = new CVersionDonnees(contexte.ContexteDonnee);
version.CreateNew();
version.CodeTypeVersion = (int)CTypeVersion.TypeVersion.Etiquette;
version.Libelle = (string)result.Data;
version.Date = DateTime.Now;
result = version.CommitEdit();
if (!result)
{
return(result);
}
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (!(lien is CLienUtilisateurAbsent))
{
result.Data = lien;
return(result);
}
}
result.Data = null;
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
//Calcule l'élément à supprimer
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = ExpressionEntiteASupprimer.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during @1 formula evaluation|216", ExpressionEntiteASupprimer.ToString()));
return(result);
}
if (result.Data is IEnumerable &&
(!(result.Data is CListeObjetsDonnees) || m_bPurgeAdmin))
{
StringBuilder bl = new StringBuilder();
Type tp = null;
string strChampId = "";
List <int> lstIds = new List <int>();
foreach (object obj in ((IEnumerable)result.Data))
{
CObjetDonneeAIdNumerique objId = obj as CObjetDonneeAIdNumerique;
if (objId == null)
{
result.EmpileErreur(I.T("Can not delete element of this type|20030"));
return(result);
}
if (tp == null)
{
tp = objId.GetType();
strChampId = objId.GetChampId();
}
if (objId.GetType() != tp)
{
result.EmpileErreur(I.T("Can not delete a list of different object types|20031"));
return(result);
}
bl.Append(objId.Id);
lstIds.Add(objId.Id);
bl.Append(",");
}
if (m_bPurgeAdmin)
{
result = PurgeEntites(contexte.IdSession, tp, lstIds.ToArray());
}
else
{
if (bl.Length == 0)
{
return(result);
}
bl.Remove(bl.Length - 1, 1);
CListeObjetsDonnees lst = new CListeObjetsDonnees(contexte.ContexteDonnee, tp);
lst.Filtre = new CFiltreData(strChampId + " in (" + bl.ToString() + ")");
if (DeleteFillesEnCascade)
{
result = CObjetDonneeAIdNumerique.DeleteAvecCascadeSansControleDoncIlFautEtreSurDeSoi(lst, true);
}
else
{
result = CObjetDonneeAIdNumerique.Delete(lst, true);
}
}
return(result);
}
if (result.Data is CListeObjetsDonnees)
{
result = CObjetDonneeAIdNumerique.Delete(result.Data as CListeObjetsDonnees, true);
return(result);
}
CObjetDonneeAIdNumerique objetASupprimer = (CObjetDonneeAIdNumerique)result.Data;
ArrayList lstVariablesAVider = new ArrayList();
//CHerche les variables qui contiennent l'objet à supprimer
foreach (CVariableDynamique variable in contexte.Branche.Process.ListeVariables)
{
object val = contexte.Branche.Process.GetValeurChamp(variable);
if (val != null && val.Equals(objetASupprimer))
{
lstVariablesAVider.Add(variable);
}
}
if (m_bPurgeAdmin)
{
result = PurgeEntites(contexte.IdSession, objetASupprimer.GetType(), new int[] { objetASupprimer.Id });
}
else
{
// Traite la suppression de tous les éléments filles en cascade.
if (DeleteFillesEnCascade)
{
result = objetASupprimer.DeleteAvecCascadeSansControleDoncIlFautEtreSurDeSoi(true);
}
else
{
result = objetASupprimer.Delete(true);
}
}
if (result)
{
foreach (CVariableDynamique variable in lstVariablesAVider)
{
Process.SetValeurChamp(variable, null);
}
}
return(result);
}
/// ////////////////////////////////////////////////////////////
public static void OnNewContexteEvaluationExpression(CContexteEvaluationExpression ctx)
{
ctx.AttacheObjet(typeof(CContexteDonnee), ContexteCourant);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
//Calcule le message
string strMessage = "";
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = FormuleMessage.Eval(contexteEval);
if (!result)
{
result = CResultAErreur.True;
strMessage = FormuleMessage.GetString();
}
else
{
strMessage = result.Data == null?"":result.Data.ToString();
}
string strCodeAttente = "";
if (FormuleCodeAttente != null)
{
result = FormuleCodeAttente.Eval(contexteEval);
if (!result || result.Data == null)
{
strCodeAttente = "";
}
else
{
strCodeAttente = result.Data.ToString();
}
}
//TESTDBKEYOK (SC)
CDbKey keyUtilisateur = contexte.Branche.KeyUtilisateur;
if (m_formuleIdUtilisateur != null)
{
//TESTDBKEYOK
result = m_formuleIdUtilisateur.Eval(contexteEval);
if (result)
{
if (result.Data is int)
{
keyUtilisateur = CUtilInfosUtilisateur.GetKeyUtilisateurFromId((int)result.Data);
}
if (result.Data is string)
{
keyUtilisateur = CDbKey.CreateFromStringValue((string)result.Data);
}
if (result.Data is CDbKey)
{
keyUtilisateur = (CDbKey)result.Data;
}
if (keyUtilisateur != null)
{
contexte.Branche.KeyUtilisateur = keyUtilisateur;
}
}
}
//Si le code d'attente n'est pas null et qu'il y a déjà une attente,
//il faut la supprimer
if (strCodeAttente != null && strCodeAttente.Trim() != "")
{
CFiltreData filtre = new CFiltreData(
CBesoinInterventionProcess.c_champCodeAttente + "=@1",
strCodeAttente);
CListeObjetsDonnees listeToDelete = new CListeObjetsDonnees(contexte.ContexteDonnee, typeof(CBesoinInterventionProcess));
listeToDelete.Filtre = filtre;
if (listeToDelete.Count != 0)
{
CObjetDonneeAIdNumerique.Delete(listeToDelete);
}
}
CBesoinInterventionProcess intervention = new CBesoinInterventionProcess(contexte.ContexteDonnee);
intervention.CreateNewInCurrentContexte();
intervention.ProcessEnExecution = contexte.ProcessEnExecution;
//TESTDBKEYOK
intervention.KeyUtilisateur = keyUtilisateur;
intervention.DateDemande = DateTime.Now;
intervention.CodeAttente = strCodeAttente;
intervention.Libelle = strMessage;
CLienAction[] liens = GetLiensSortantHorsErreur();
if (liens.Length == 1)
{
intervention.IdAction = liens[0].ActionArrivee.IdObjetProcess;
}
else
{
intervention.IdAction = -1;
}
//Mise du process en pause !
result.Data = new CMetteurDeProcessEnPause( );
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);
}
/// //////////////////////////////////////////////////////////////////
protected static CResultAErreur ExecuteActionAfficherEntite(CActionSur2iLinkAfficherEntite action, object objetCible)
{
CResultAErreur result = CResultAErreur.True;
C2iExpression formuleElement = action.FormuleElement;
if (formuleElement == null)
{
result.EmpileErreur(I.T("Link parameter error : entitty formula is null|30083"));
return(result);
}
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(objetCible);
ctxEval.AttacheObjet(typeof(CContexteDonnee), CSc2iWin32DataClient.ContexteCourant);
result = formuleElement.Eval(ctxEval);
if (!result)
{
result.EmpileErreur(I.T("Element evaluation error|30084"));
return(result);
}
if (result.Data == null)
{
result.EmpileErreur(I.T("Not avaliable|30082"));
return(result);
}
object objetEdite = result.Data;
//Type tp = CFormFinder.GetTypeFormToEdit ( result.Data.GetType() );
string strCodeFormulaire = "";
if (action.FormuleCodeFormulaire != null)
{
result = action.FormuleCodeFormulaire.Eval(ctxEval);
if (result && result.Data != null)
{
strCodeFormulaire = result.Data.ToString();
}
}
CReferenceTypeForm refTypeForm = null;
if (strCodeFormulaire == "")
{
refTypeForm = CFormFinder.GetRefFormToEdit(objetEdite.GetType());
}
else
{
refTypeForm = CFormFinder.GetRefFormToEdit(objetEdite.GetType(), strCodeFormulaire);
}
try
{
if (refTypeForm != null)
{
//CFormEditionStandard form = ( CFormEditionStandard )Activator.CreateInstance ( tp, new object[]{result.Data} );
CFormEditionStandard form = refTypeForm.GetForm((CObjetDonneeAIdNumeriqueAuto)objetEdite) as CFormEditionStandard;
if (action.FormuleContexte != null)
{
result = action.FormuleContexte.Eval(ctxEval);
if (!result)
{
result.EmpileErreur(I.T("Form context evaluation error|30080"));
return(result);
}
if (result.Data != null)
{
form.ContexteUtilisation = result.Data.ToString();
}
}
if (action.FormuleTitre != null)
{
result = action.FormuleTitre.Eval(ctxEval);
if (!result)
{
result.EmpileErreur(I.T("Form title evaluation error|30081"));
return(result);
}
/*if ( result.Data != null )
* form.TitreForce = result.Data.ToString();*/
}
CTimosApp.Navigateur.AffichePage(form);
}
else
{
result.EmpileErreur(I.T("Not avaliable|30082"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// //////////////////////////////////////////////////////////////////
protected static CResultAErreur ExecuteActionListe(CActionSur2iLinkAfficherListe action, object objetCible)
{
CResultAErreur result = CResultAErreur.True;
CFiltreDynamique filtre = action.Filtre;
if (filtre == null || filtre.TypeElements == null)
{
result.EmpileErreur(I.T("Link parameter error : filter is null|30077"));
return(result);
}
if (objetCible != null)
{
CObjetPourSousProprietes objetPourSousProp = null;
objetPourSousProp = new CObjetPourSousProprietes(objetCible);
IVariableDynamique variable = CActionSur2iLinkAfficherListe.AssureVariableElementCible(filtre, objetPourSousProp);
/*if ( variable.TypeDonnee.TypeDotNetNatif != objetCible.GetType() )
* {
* result.EmpileErreur(I.T("Expected type in the filter does not correspond to object type|30078"));
* return result;
* }*/
if (variable != null)
{
filtre.SetValeurChamp(variable.IdVariable, objetCible);
}
}
result = filtre.GetFiltreData();
if (!result)
{
result.EmpileErreur(I.T("Filter error|30079"));
return(result);
}
CFiltreData filtreData = (CFiltreData)result.Data;
Type tp = CFormFinder.GetTypeFormToList(filtre.TypeElements);
try
{
if (tp != null || tp.IsSubclassOf(typeof(CFormListeStandard)))
{
CFormListeStandard form = ( CFormListeStandard )Activator.CreateInstance(tp, new object[0]);
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(objetCible);
ctxEval.AttacheObjet(typeof(CContexteDonnee), CSc2iWin32DataClient.ContexteCourant);
if (action.FormuleContexte != null)
{
result = action.FormuleContexte.Eval(ctxEval);
if (!result)
{
result.EmpileErreur(I.T("Form context evaluation error|30080"));
return(result);
}
if (result.Data != null)
{
form.ContexteUtilisation = result.Data.ToString();
}
}
if (action.FormuleTitre != null)
{
result = action.FormuleTitre.Eval(ctxEval);
if (!result)
{
result.EmpileErreur(I.T("Form title evaluation error|30081"));
return(result);
}
if (result.Data != null)
{
form.TitreForce = result.Data.ToString();
}
}
form.FiltreDeBase = filtreData;
form.AffectationsPourNouveauxElements = action.Affectations;
form.ObjetReferencePourAffectationsInitiales = objetCible;
form.BoutonAjouterVisible = action.ShowBoutonAjouter;
form.BoutonModifierVisible = action.ShowBoutonDetail;
form.BoutonSupprimerVisible = action.ShowBoutonSupprimer;
if (action.IdFiltreDynamiqueAUtiliser >= 0)
{
CFiltreDynamiqueInDb filtretoUse = new CFiltreDynamiqueInDb(CContexteDonneeSysteme.GetInstance());
if (filtretoUse.ReadIfExists(action.IdFiltreDynamiqueAUtiliser))
{
CFiltreDynamique filtreDyn = filtretoUse.Filtre;
if (filtreDyn != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(objetCible);
foreach (CFormuleNommee formule in action.ValeursVariablesFiltre)
{
if (formule.Formule != null)
{
CResultAErreur res = formule.Formule.Eval(ctx);
if (res)
{
try
{
string strId = formule.Id;
filtreDyn.SetValeurChamp(strId, res.Data);
}
catch { }
}
}
}
form.FiltrePrefere = filtreDyn;
}
}
}
if (action.ActionSurDetail != null)
{
CExecuteurActionSurPanelListeSpeedStandard executeur = new CExecuteurActionSurPanelListeSpeedStandard(action.ActionSurDetail, form);
form.SetModifierElementDelegate(new CPanelListeSpeedStandard.ModifierElementDelegate(executeur.ExecuteAction));
}
CTimosApp.Navigateur.AffichePage(form);
}
else
{
result.EmpileErreur(I.T("Not avaliable|30082"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(Process);
ctxEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
string strImprimanteClient = "";
string strImprimanteServeur = "";
if (FormuleImprimanteClient != null)
{
result = FormuleImprimanteClient.Eval(ctxEval);
if (!result)
{
result.EmpileErreur(I.T("Error during the client printer evaluation|127"));
return(result);
}
strImprimanteClient = result.Data.ToString();
}
if (FormuleImprimanteServeur != null)
{
result = FormuleImprimanteServeur.Eval(ctxEval);
if (!result)
{
result.EmpileErreur(I.T("Error during the server printer evaluation|128"));
return(result);
}
strImprimanteServeur = result.Data.ToString();
}
CConfigurationsImpression config;
if (contexte.Branche.ConfigurationImpression != null)
{
config = (CConfigurationsImpression)CCloner2iSerializable.Clone(contexte.Branche.ConfigurationImpression);
}
else
{
config = new CConfigurationsImpression();
}
if (strImprimanteClient != "")
{
config.NomImprimanteSurClient = strImprimanteClient;
}
if (strImprimanteServeur != "")
{
config.NomImprimanteSurServeur = strImprimanteServeur;
}
contexte.Branche.ConfigurationImpression = config;
CSessionClient session = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (session != null)
{
session.ConfigurationsImpression = config;
}
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);
}