internal CResultAErreur Execute(CObjetDonneeAIdNumerique cible)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(MacroObjet.Macro);
CResultAErreur result = FormuleValeur.Eval(ctx);
if (result)
{
try
{
if (!m_champ.IsReadOnly)
{
CInterpreteurProprieteDynamique.SetValue(cible, m_champ, result.Data);
}
else//Peut être un champ forçable pour les macros
{
CDefinitionProprieteDynamiqueDotNet defDotNet = m_champ as CDefinitionProprieteDynamiqueDotNet;
if (defDotNet != null)
{
PropertyInfo info = info = cible.GetType().GetProperty(defDotNet.NomProprieteSansCleTypeChamp);
if (info != null)
{
object[] attrs = info.GetCustomAttributes(typeof(TiagRelationAttribute), true);
if (attrs != null && attrs.Length > 0)
{
TiagRelationAttribute att = (TiagRelationAttribute)attrs[0];
MethodInfo meth = cible.GetType().GetMethod(att.NomMethodeSetClesParentes);
if (meth != null)
{
object[] lstCles = null;
CObjetDonnee obj = result.Data as CObjetDonnee;
if (obj == null)
{
lstCles = new object[1];
}
else
{
lstCles = obj.GetValeursCles();
}
meth.Invoke(cible, new object[] { lstCles });
}
}
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur("#Error while affecting property " + m_champ.Nom);
}
}
return(result);
}
//-------------------------------------------------------------------
private CResultAErreur EditerObjetNomme(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
CNommageEntite nommage = objet as CNommageEntite;
if (nommage != null)
{
CObjetDonneeAIdNumerique objetNomme = nommage.GetObjetNomme();
if (objetNomme != null)
{
CReferenceTypeForm refForm = CFormFinder.GetRefFormToEdit(objetNomme.GetType());
if (refForm != null)
{
IFormNavigable form = refForm.GetForm((CObjetDonneeAIdNumeriqueAuto)objetNomme) as IFormNavigable;
if (form != null)
{
CTimosApp.Navigateur.AffichePage(form);
}
}
}
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
//Evalue l'élément cible
object obj = Process.GetValeurChamp(IdVariableElement);
if (obj != null)
{
if (!(obj is CObjetDonneeAIdNumerique))
{
result.EmpileErreur(I.T("The element for which to start the actions isn't correct|163"));
return(result);
}
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)obj;
IDeclencheurEvenementsStatiques declencheur = (IDeclencheurEvenementsStatiques)C2iFactory.GetNewObjetForSession("CDeclencheurEvenementsStatiques", typeof(IDeclencheurEvenementsStatiques), objet.ContexteDonnee.IdSession);
if (declencheur != null)
{
result = declencheur.DeclencheEvenementStatiques(objet.GetType(), objet.DbKey);
}
if (!result)
{
return(result);
}
}
return(result);
}
//-------------------------------------------------------------------------
public void ShowMenuAjout(Point pt)
{
if (!m_lnkAjouter.Visible)
{
return;
}
CObjetDonneeAIdNumerique element = m_elementsAAgenda[0];
//cherche les entrées qui collent avec des acteurs
CListeObjetsDonnees liste = new CListeObjetsDonnees(element.ContexteDonnee, typeof(CTypeEntreeAgenda));
CFiltreDataAvance filtre = new CFiltreDataAvance(CTypeEntreeAgenda.c_nomTable,
CRelationTypeEntreeAgenda_TypeElementAAgenda.c_nomTable + "." +
CRelationTypeEntreeAgenda_TypeElementAAgenda.c_champTypeElement + "=@1 and " +
CRelationTypeEntreeAgenda_TypeElementAAgenda.c_nomTable + "." +
CRelationTypeEntreeAgenda_TypeElementAAgenda.c_champLienMaitre + "=@2",
element.GetType().ToString(),
true);
liste.Filtre = filtre;
if (liste.Count == 0)
{
CFormAlerte.Afficher(I.T("No Agenda entry type can be applied on this element type|30080"), EFormAlerteType.Exclamation);
return;
}
m_menuAjouterAgenda.MenuItems.Clear();
foreach (CTypeEntreeAgenda typeEntree in liste)
{
CMenuItemATypeEntreeAgenda item = new CMenuItemATypeEntreeAgenda(typeEntree);
item.Text = typeEntree.Libelle;
item.Click += new EventHandler(OnMenuAjouterAgenda);
m_menuAjouterAgenda.MenuItems.Add(item);
}
pt = PointToClient(pt);
m_menuAjouterAgenda.Show(this, pt);
}
/// <summary>
/// Remplit les zones de base liées à ce type pour une entrée de Agenda
/// </summary>
/// <param name="entree"></param>
/// <param name="element"></param>
/// <returns></returns>
public CResultAErreur InitEntreeManuelleFor(CEntreeAgenda entree, CObjetDonneeAIdNumerique element)
{
CResultAErreur result = CResultAErreur.True;
if (entree == null)
{
result.EmpileErreur(I.T("Fill an empty Diary Entry is impossible|345"));
return(result);
}
if (element == null)
{
result.EmpileErreur(I.T("Entry creation on null element is impossible|346"));
return(result);
}
entree.TypeEntree = this;
foreach (CRelationTypeEntreeAgenda_TypeElementAAgenda relation in RelationsTypeElementsAAgenda)
{
if (relation.TypeElements == element.GetType() && relation.LienMaitre)
{
CRelationEntreeAgenda_ElementAAgenda newRel = new CRelationEntreeAgenda_ElementAAgenda(entree.ContexteDonnee);
newRel.CreateNewInCurrentContexte();
newRel.RelationTypeEntree_TypeElement = relation;
newRel.ElementLie = element;
newRel.EntreeAgenda = entree;
return(result);
}
}
result.EmpileErreur(I.T("No relation on @1 type exists for Diary Entry Type @2|347", element.GetType() + Libelle));
return(result);
}
//------------------------------------------------------------------------------------------------
private CCaracteristiqueEntite[] GetDocumentsAttendus()
{
if (m_objetEdite == null)
{
return(null);
}
CObjetDonneeAIdNumerique objet = m_objetEdite as CObjetDonneeAIdNumerique;
if (objet != null)
{
string strIdsDocumentsAttendus = CTimosWebAppRegistre.IdsTypesCaracteristiquesDocumentsAttendus;
CFiltreData filtre;
if (strIdsDocumentsAttendus.Length == 0)
{
filtre = new CFiltreDataImpossible();
}
else
{
filtre = new CFiltreData(CCaracteristiqueEntite.c_champTypeElement + "=@1 and " +
CCaracteristiqueEntite.c_champIdElementLie + "=@2 and " + CTypeCaracteristiqueEntite.c_champId + " IN (" + strIdsDocumentsAttendus + ")",
objet.GetType().ToString(),
objet.Id);
}
CListeObjetsDonnees lst = new CListeObjetsDonnees(objet.ContexteDonnee, typeof(CCaracteristiqueEntite), filtre);
int combien = lst.Count;
return(lst.ToArray <CCaracteristiqueEntite>());
}
return(null);
}
//--------------------------------------------------------------
private void FillListe()
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(m_objet.ContexteDonnee, typeof(CVersionDonneesObjet));
CFiltreData filtre = new CFiltreDataAvance(CVersionDonneesObjet.c_nomTable,
CVersionDonnees.c_nomTable + "." +
CVersionDonnees.c_champTypeVersion + "=@1",
(int)CTypeVersion.TypeVersion.Archive);
if (m_bInclureEtiquettes)
{
filtre = CFiltreData.GetOrFiltre(filtre,
new CFiltreDataAvance(
CVersionDonneesObjet.c_nomTable,
CVersionDonnees.c_nomTable + "." +
CVersionDonnees.c_champTypeVersion + "=@1",
(int)CTypeVersion.TypeVersion.Etiquette));
}
if (m_modeFiltre == ModeFiltre.VoirPourElement)
{
filtre = CFiltreData.GetAndFiltre(filtre,
new CFiltreData(
CVersionDonneesObjet.c_champIdElement + "=@1 and " +
CVersionDonneesObjet.c_champTypeElement + "=@2",
m_objet.Id,
m_objet.GetType().ToString()));
}
liste.Filtre = filtre;
m_panelListe.InitFromListeObjets(liste,
typeof(CVersionDonneesObjet),
null,
null,
"");
}
//---------------------------------------------
public void AddSelectedEntity(CObjetDonneeAIdNumerique objet)
{
if (objet != null && (objet.GetType() == TypeEntiteAssocie || TypeEntiteAssocie == null))
{
TypeEntiteAssocie = objet.GetType();
//Vérifie que l'entité n'est pas déjà associée
CListeObjetsDonnees lst = RelationsElementsSelectionnes;
lst.Filtre = new CFiltreData(CRelationBesoinQuantite_Element.c_champIdElement + "=@1",
objet.Id);
if (lst.Count == 0)
{
CRelationBesoinQuantite_Element rel = new CRelationBesoinQuantite_Element(ContexteDonnee);
rel.CreateNewInCurrentContexte();
rel.BesoinQuantite = this;
rel.Element = objet;
}
}
}
//------------------------------------------------------------------
public static CListeObjetsDonnees GetListeRelationsForElement(CObjetDonneeAIdNumerique objet)
{
CFiltreData filtre = new CFiltreData(
c_champTypeElement + "=@1 and " +
c_champIdElement + "= @2",
objet.GetType().ToString(),
objet.Id);
CListeObjetsDonnees liste = new CListeObjetsDonnees(objet.ContexteDonnee, typeof(CRelationElement_EO), filtre);
return(liste);
}
//-------------------------------------------------------------------------
private void m_lnkAjouter_LinkClicked(object sender, EventArgs e)
{
if (m_objet != null)
{
CNommageEntite nom = new CNommageEntite(m_contexteLocal);
nom.CreateNewInCurrentContexte();
nom.TypeEntite = m_objet.GetType();
nom.CleEntite = m_objet.DbKey;
AjouterControlSaisieNommage(nom, m_nIndex++);
}
}
public void AddElement(CObjetDonneeAIdNumerique objet)
{
Type tp = objet.GetType();
Dictionary <int, CObjetDonneeAIdNumerique> dic = null;
if (!m_dic.TryGetValue(tp, out dic))
{
dic = new Dictionary <int, CObjetDonneeAIdNumerique>();
m_dic[tp] = dic;
}
dic[objet.Id] = objet;
}
//------------------------------------------------------------------
public static CListeObjetsDonnees GetEntitesOrganisationnellesDirectementLiees(CObjetDonneeAIdNumerique objet)
{
CFiltreData filtre = new CFiltreData(
CRelationElement_ModuleParametrage.c_champTypeElement + "=@1 and " +
CRelationElement_ModuleParametrage.c_champIdElement + "=@2",
objet.GetType().ToString(),
objet.Id);
CListeObjetsDonnees liste = new CListeObjetsDonnees(objet.ContexteDonnee, typeof(CRelationElement_ModuleParametrage));
liste.Filtre = filtre;
return(liste.GetDependances("EntiteOrganisationnelle"));
}
public void SetObjetAssocie(CObjetDonneeAIdNumerique objet)
{
if (objet == null)
{
KeyObjetAssocie = null;
TypeObjetAssocie = null;
}
else
{
KeyObjetAssocie = objet.DbKey;
TypeObjetAssocie = objet.GetType();
}
}
public void RemoveElement(CObjetDonneeAIdNumerique objet)
{
if (objet != null && objet.GetType() == TypeElements)
{
CListeObjetsDonnees lst = RelationsEntites;
lst.Filtre = new CFiltreData(CRelationListeEntites_Entite.c_champIdElement + "=@1",
objet.Id);
if (lst.Count > 0)
{
CObjetDonneeAIdNumerique.Delete(lst, true);
}
}
}
public void EmpilerVersionElement(CObjetDonneeAIdNumerique obj)
{
if (m_bInit && !CanEmpileVersionElement(obj))
{
return;
}
if (obj != null)
{
if (TypeElement != null && TypeElement != obj.GetType())
{
return;
}
if (TypeElement == null)
{
TypeElement = obj.GetType();
}
}
if (!PresentVersionSource)
{
IdVersionDonneeSource = IdVersionDonneeCible;
IdObjetSource = IdObjetCible;
}
IdVersionDonneeCible = obj == null ? null : obj.ContexteDonnee.IdVersionDeTravail;
IdObjetCible = obj == null ? null : (int?)obj.Id;
if (!m_bInit)
{
m_pileVersionsObjs = new List <CObjetDonneeAIdNumerique>();
}
m_pileVersionsObjs.Add(obj);
m_bInit = true;
}
//-----------------------------------------------------------
private void CFormFormuleRapide_Load(object sender, EventArgs e)
{
sc2i.win32.common.CWin32Traducteur.Translate(this);
m_lblEntite.Text = m_objet.DescriptionElement;
Type tp = m_objet.GetType();
m_wndAideFormule.FournisseurProprietes = new CFournisseurPropDynStd(true);
m_wndAideFormule.ObjetInterroge = tp;
m_txtFormule.Init(m_wndAideFormule.FournisseurProprietes, m_wndAideFormule.ObjetInterroge);
ArrayList tableauChaines = (m_tableLastFormuleDuType[tp]) as ArrayList;
if (tableauChaines != null && tableauChaines.Count > 0)
{
m_nLastIndex = tableauChaines.Count - 1;
m_txtFormule.Text = (string)tableauChaines[m_nLastIndex];
}
else
{
m_txtFormule.Text = "\"\"";
}
}
/// ///////////////////////////////////////////////////////////////////////
public static CListeObjetsDonnees GetListeDossiersForElement(CObjetDonneeAIdNumerique objet)
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(objet.ContexteDonnee, typeof(CDossierSuivi));
if (objet == null)
{
liste.Filtre = new CFiltreDataImpossible();
return(liste);
}
liste.Filtre = new CFiltreData(c_champTypeElementLie + "=@1 and " +
c_champIdElementLie + "=@2",
objet.GetType().ToString(),
objet.Id);
return(liste);
}
public void AddElement(CObjetDonneeAIdNumerique objet)
{
if (DataFiltre.Donnees == null && objet != null && objet.GetType() == TypeElements)
{
//Cherche si l'élément n'est pas déjà présent
CListeObjetsDonnees lst = RelationsEntites;
lst.Filtre = new CFiltreData(CRelationListeEntites_Entite.c_champIdElement + "=@1",
objet.Id);
if (lst.Count == 0)
{
CRelationListeEntites_Entite rel = new CRelationListeEntites_Entite(ContexteDonnee);
rel.CreateNewInCurrentContexte();
rel.ListeEntites = this;
rel.ElementLie = objet;
}
}
}
public void FillListe()
{
CFiltreDataAvance filtre = new CFiltreDataAvance(CVersionDonnees.c_nomTable,
CVersionDonneesObjet.c_nomTable + "." +
CVersionDonneesObjet.c_champIdElement + "=@1 and " +
CVersionDonneesObjet.c_champTypeElement + "=@2",
m_objet.Id,
m_objet.GetType().ToString());
CListeObjetsDonnees liste = new CListeObjetsDonnees(m_objet.ContexteDonnee,
typeof(CVersionDonnees));
m_panelListeVersions.InitFromListeObjets(liste,
typeof(CVersionDonneesObjet),
null,
null,
"");
}
void m_panelModulesParametrage_OnListElementsItemDoubleClick(object sender, EventArgs e)
{
// Affiche l'élement dans Timos
CObjetDonneeAIdNumerique element = sender as CObjetDonneeAIdNumerique;
if (element != null)
{
CReferenceTypeForm referenceForm = CFormFinder.GetRefFormToEdit(element.GetType());
if (referenceForm != null)
{
IFormNavigable form = referenceForm.GetForm((CObjetDonneeAIdNumeriqueAuto)element) as IFormNavigable;
if (form != null)
{
CTimosApp.Navigateur.AffichePage(form);
}
}
}
}
//----------------------------------
private bool FillMacroValeurWithValue(CMacroObjetValeur mv, object data, Dictionary <CObjetDonneeAIdNumerique, CMacroObjet> dicObjetToMacroObjet)
{
C2iExpression formule = null;
string strIdVariableRef = "";
CObjetDonneeAIdNumerique obj = data as CObjetDonneeAIdNumerique;
if (obj != null)
{
CMacroObjet mr = null;
if (dicObjetToMacroObjet.TryGetValue(obj, out mr))
{
strIdVariableRef = mr.IdVariableAssociee;
}
else
{
CMacroObjet macroObjet = new CMacroObjet(Macro);
macroObjet.TypeObjet = obj.GetType();
macroObjet.TypeOperation = new CTypeOperationSurObjet(CTypeOperationSurObjet.TypeOperation.Aucune);
macroObjet.DesignationObjet = obj.DescriptionElement;
macroObjet.IdObjet = obj.Id;
Macro.AddObjet(macroObjet);
dicObjetToMacroObjet[obj] = macroObjet;
macroObjet.CreateVariable(obj);
strIdVariableRef = macroObjet.IdVariableAssociee;
}
}
if (strIdVariableRef == "")
{
formule = GetFormuleValeur(data);
}
if (formule == null && strIdVariableRef == "")
{
return(false);
}
if (strIdVariableRef != "")
{
CVariableDynamique variable = Macro.GetVariable(strIdVariableRef);
formule = new C2iExpressionChamp(new CDefinitionProprieteDynamiqueVariableDynamique(variable));
}
mv.FormuleValeur = formule;
return(true);
}
//------------------------------------------------------------------
private void CArbreElementsModule_DragDrop(object sender, DragEventArgs e)
{
List <CReferenceObjetDonnee> lst = new List <CReferenceObjetDonnee>();
CReferenceObjetDonnee[] refs = e.Data.GetData(typeof(CReferenceObjetDonnee[])) as CReferenceObjetDonnee[];
if (refs != null)
{
lst.AddRange(refs);
}
else
{
CReferenceObjetDonnee refSeule = e.Data.GetData(typeof(CReferenceObjetDonnee)) as CReferenceObjetDonnee;
if (refSeule != null)
{
lst.Add(refSeule);
}
}
foreach (CReferenceObjetDonnee data in lst)
{
// Créer ici un nouvelle relation Element_ModuleParametrage, si elle n'éxiste pas déjà
CObjetDonneeAIdNumerique element = data.GetObjet(m_contexte) as CObjetDonneeAIdNumerique;
if (element != null && m_moduleAffiche != null)
{
CRelationElement_ModuleParametrage newRelation = new CRelationElement_ModuleParametrage(m_contexte);
if (!newRelation.ReadIfExists(new CFiltreData(
CModuleParametrage.c_champId + " = @1 and " +
CRelationElement_ModuleParametrage.c_champTypeElement + " = @2 and " +
CRelationElement_ModuleParametrage.c_champIdElement + " = @3",
m_moduleAffiche.Id,
element.GetType().ToString(),
element.Id)))
{
// La relation n'éxiste pas il faut la créer
newRelation.CreateNewInCurrentContexte();
newRelation.ElementLie = element;
newRelation.ModuleParametrage = m_moduleAffiche;
InitForModule(m_moduleAffiche, m_contexte);
}
}
}
}
//-------------------------------------------------------------------
private CRelationElementComportement GetRelationForObjet(CObjetDonneeAIdNumerique objet)
{
if (objet == null)
{
return(null);
}
CRelationElementComportement relation = new CRelationElementComportement(objet.ContexteDonnee);
if (relation.ReadIfExists(
new CFiltreData(
CRelationElementComportement.c_champTypeElement + "=@1 and " +
CRelationElementComportement.c_champIdElement + "=@2 and " +
c_champId + "=@3",
objet.GetType().ToString(),
objet.Id,
Id)))
{
return(relation);
}
return(null);
}
/// <summary>
/// REtourne le CValeurVariable s'il existe
/// </summary>
/// <param name="strNomVariable"></param>
/// <param name="objet"></param>
/// <returns></returns>
public static CValeurVariableSurObjet GetValeurFor(string strNomVariable, CObjetDonneeAIdNumerique objet)
{
if (objet == null)
{
return(null);
}
CFiltreData filtre = new CFiltreData(
c_champTypeElementLie + "=@1 and " +
c_champIdElementLie + "=@2 and " +
c_champNomVariable + "=@3",
objet.GetType().ToString(),
objet.Id.ToString(),
strNomVariable);
CValeurVariableSurObjet valeur = new CValeurVariableSurObjet(objet.ContexteDonnee);
if (valeur.ReadIfExists(filtre))
{
return(valeur);
}
return(null);
}
public CResultAErreur SetValue(object objet, string strPropriete, object valeur)
{
CResultAErreur result = CResultAErreur.True;
RelationTypeIdAttribute relation = null;
CObjetDonneeAIdNumerique objetTypeId = objet as CObjetDonneeAIdNumerique;
if (objetTypeId == null)
{
return(result);
}
CObjetDonneeAIdNumerique objetValeur = objet as CObjetDonneeAIdNumerique;
if (objetValeur == null)
{
return(result);
}
foreach (RelationTypeIdAttribute relTest in CContexteDonnee.RelationsTypeIds)
{
if (relTest.IdRelation == strPropriete)
{
relation = relTest;
break;
}
}
if (relation == null)
{
result.EmpileErreur(I.T("Relation @1 doesn't exists|20030", strPropriete));
return(result);
}
try
{
objetTypeId.Row[relation.ChampId] = objetValeur.Id;
objetTypeId.Row[relation.ChampType] = objetValeur.GetType().ToString();
}
catch
{
}
return(result);
}
/// /////////////////////////////////////////////////////////////
public CListeObjetsDonnees GetDonneesCumuleesForObjet(CObjetDonneeAIdNumerique objet)
{
//Trouve le champ du paramètre qui est lié au type de l'objet lié
CParametreDonneeCumulee parametre = Parametre;
int nCle = 0;
string strChampCle = "";
foreach (CCleDonneeCumulee cle in parametre.ChampsCle)
{
if (cle.TypeLie != null && cle.TypeLie == objet.GetType())
{
strChampCle = CDonneeCumulee.GetNomChampCle(nCle);
break;
}
else
{
nCle++;
}
}
CListeObjetsDonnees listeVide = new CListeObjetsDonnees(objet.ContexteDonnee, typeof(CDonneeCumulee));
listeVide.Filtre = new CFiltreDataImpossible();
if (strChampCle == "")
{
return(listeVide);
}
CFiltreData filtre = new CFiltreData(
CTypeDonneeCumulee.c_champId + "=@1 and " +
strChampCle + "=@2",
this.Id,
objet.Id.ToString());
CListeObjetsDonnees liste = new CListeObjetsDonnees(objet.ContexteDonnee, typeof(CDonneeCumulee));
liste.Filtre = filtre;
return(liste);
}
private void m_lnk_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
if (m_entite.ElementAccessible)
{
CObjetDonneeAIdNumerique obj = m_entite.Entite;
//Type typeForm = CFormFinder.GetTypeFormToEdit(m_entite.Entite.GetType());
//if (typeForm != null)
//{
// CFormEditionStandard form = (CFormEditionStandard)Activator.CreateInstance(
// typeForm,
// new object[] { obj });
// CSc2iWin32DataNavigation.Navigateur.AffichePage(form);
//}
CReferenceTypeForm refTypeForm = CFormFinder.GetRefFormToEdit(obj.GetType());
if (refTypeForm != null)
{
CFormEditionStandard form = refTypeForm.GetForm((CObjetDonneeAIdNumeriqueAuto)obj) as CFormEditionStandard;
if (form != null)
{
CSc2iWin32DataNavigation.Navigateur.AffichePage(form);
}
}
}
}
/// ////////////////////////////////////////////////
public static CSynchronismeDonnees CreateSynchronisme(
CContexteDonnee contexteCreation,
CObjetDonneeAIdNumerique objetSource,
CObjetDonneeAIdNumerique objetDest,
string strChampSource,
string strChampDest,
C2iExpression expressionSurSource,
C2iExpression expressionSurDest)
{
CSynchronismeDonnees synchro = new CSynchronismeDonnees(contexteCreation);
CFiltreData filtre = new CFiltreData(
c_champTypeSource + "=@1 and " +
c_champTypeDest + "=@2 and " +
c_champIdSource + "=@3 and " +
c_champIdDest + "=@4 and " +
c_champChampSource + "=@5 and " +
c_champChampDest + "=@6",
objetSource.GetType().ToString(),
objetDest.GetType().ToString(),
objetSource.Id,
objetDest.Id,
strChampSource,
strChampDest);
if (!synchro.ReadIfExists(filtre))
{
synchro.CreateNewInCurrentContexte();
synchro.ObjetSource = objetSource;
synchro.ObjetDest = objetDest;
synchro.ChampSource = strChampSource;
synchro.ChampDest = strChampDest;
}
synchro.ConditionSurSource = expressionSurSource;
synchro.ConditionSurDest = expressionSurDest;
return(synchro);
}
public static CResultAErreur DoTraitementExterneAvantSauvegarde(CContexteDonnee contexte, Hashtable tableData)
{
CResultAErreur result = CResultAErreur.True;
Type tp;
ArrayList lst = new ArrayList(contexte.Tables);
foreach (DataTable table in lst)
{
tp = null;
ArrayList listeChampsDate = (ArrayList)m_tableChampsDate[table.TableName];
#region récupération des champs date
if (listeChampsDate == null)
{
listeChampsDate = new ArrayList();
//Premier passage, cherche les champs date
foreach (DataColumn col in table.Columns)
{
if (col.DataType == typeof(DateTime) ||
col.DataType == typeof(CDateTimeEx) ||
col.DataType == typeof(DateTime?))
{
listeChampsDate.Add(col.ColumnName);
}
}
m_tableChampsDate[table.TableName] = listeChampsDate;
}
#endregion
if (listeChampsDate.Count > 0 && table.PrimaryKey.Length == 1)
{
Hashtable tablesQuiOntChange = new Hashtable();
//NomChamp->Méthode set associée
Hashtable tableChampToMethode = new Hashtable();
string strCle = table.PrimaryKey[0].ColumnName;
ArrayList lstRows = new ArrayList(table.Rows);
if (tp == null)
{
tp = CContexteDonnee.GetTypeForTable(table.TableName);
}
//Travaille par paquets de 500
for (int nRowLot = 0; nRowLot < lstRows.Count; nRowLot += 500)
{
int nMin = Math.Min(lstRows.Count, nRowLot + 500);
StringBuilder bl = new StringBuilder();
for (int nRow = nRowLot; nRow < nMin; nRow++)
{
DataRow rowTest = (DataRow)lstRows[nRow];
if (rowTest.RowState == DataRowState.Modified)
{
bl.Append(rowTest[strCle]);
bl.Append(",");
}
}
string strIds = bl.ToString();
if (strIds.Length > 0)
{
Type typeMainElementAChamp = null;
if (typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(tp))
{
CRelationElementAChamp_ChampCustom relation = (CRelationElementAChamp_ChampCustom)Activator.CreateInstance(tp, new object[] { contexte });
typeMainElementAChamp = relation.GetTypeElementAChamps();
}
strIds = strIds.Substring(0, strIds.Length - 1);
CFiltreData filtrePrinc = new CFiltreData(
CSynchronismeDonnees.c_champIdSource + " in (" + strIds + ") and " +
CSynchronismeDonnees.c_champTypeSource + "=@1",
typeMainElementAChamp == null?tp.ToString():typeMainElementAChamp.ToString());
CListeObjetsDonnees listeSynchro = new CListeObjetsDonnees(contexte, typeof(CSynchronismeDonnees), filtrePrinc);
listeSynchro.AssureLectureFaite();
listeSynchro.InterditLectureInDB = true;
CFiltreData filtreChercheMesSynchros = new CFiltreData(
CSynchronismeDonnees.c_champIdSource + "=@1", 0);
CFiltreData filtreChercheMesSynchrosChamp = new CFiltreData(
CSynchronismeDonnees.c_champIdSource + "=@1 and " +
CSynchronismeDonnees.c_champChampSource + "=@2",
0, "");
if (listeSynchro.Count > 0)
{
foreach (DataRow row in lstRows)
{
if (row.RowState == DataRowState.Modified)
{
int nCleElement = (int)row[strCle];
filtreChercheMesSynchros.Parametres[0] = nCleElement;
listeSynchro.Filtre = filtreChercheMesSynchros;
if (listeSynchro.Count > 0)
{
foreach (string strChamp in listeChampsDate)
{
if (row[strChamp, DataRowVersion.Original] != DBNull.Value &&
row[strChamp, DataRowVersion.Current] != DBNull.Value)
{
string strIdChampSynchronisme = strChamp;
DateTime dtOrg, dtNew;
dtOrg = (DateTime)row[strChamp, DataRowVersion.Original];
dtNew = (DateTime)row[strChamp, DataRowVersion.Current];
if (!dtNew.Equals(dtOrg))
{
//La colonne a change. Cherche tous les synchronismes liés à cet élément
//Si c'est un champ custom, on cherche un synchro sur le type
//contenant le champ custom
if (typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(tp))
{
CRelationElementAChamp_ChampCustom relation = (CRelationElementAChamp_ChampCustom)contexte.GetNewObjetForRow(row);
strIdChampSynchronisme = CSynchronismeDonnees.c_idChampCustom + row[CChampCustom.c_champId];
nCleElement = relation.ElementAChamps.Id;
}
if (tp != null && tp.IsSubclassOf(typeof(CObjetDonneeAIdNumerique)))
{
filtreChercheMesSynchrosChamp.Parametres[0] = nCleElement;
filtreChercheMesSynchrosChamp.Parametres[1] = strIdChampSynchronisme;
listeSynchro.Filtre = filtreChercheMesSynchrosChamp;
if (listeSynchro.Count > 0)
{
TimeSpan sp = (DateTime)row[strChamp, DataRowVersion.Current] -
(DateTime)row[strChamp, DataRowVersion.Original];
foreach (CSynchronismeDonnees synchro in listeSynchro)
{
CObjetDonneeAIdNumerique objetDest = synchro.ObjetDest;
if (objetDest != null)
{
string strChampDest = synchro.ChampDest;
//La donnée n'est synchronisée que si elle est
//égale à sa valeur d'origine
if (synchro.ChampDest.IndexOf(CSynchronismeDonnees.c_idChampCustom) == 0)
{
//C'est un champ custom.
if (objetDest is IElementAChamps)
{
CListeObjetsDonnees listeRels = ((IElementAChamps)objetDest).RelationsChampsCustom;
int nIdChamp = Int32.Parse(synchro.ChampDest.Substring(
CSynchronismeDonnees.c_idChampCustom.Length));
listeRels.Filtre = new CFiltreData(CChampCustom.c_champId + "=@1",
nIdChamp);
if (listeRels.Count != 0)
{
objetDest = (CObjetDonneeAIdNumerique)listeRels[0];
strChampDest = CRelationElementAChamp_ChampCustom.c_champValeurDate;
}
else
{
objetDest = null;
}
}
else
{
objetDest = null;
}
}
if (objetDest != null && objetDest.Row[strChampDest] != DBNull.Value)
{
object valeurOld = null;
object valeurCourante = objetDest.Row[strChampDest, DataRowVersion.Current];
if (objetDest.Row.HasVersion(DataRowVersion.Original))
{
valeurOld = objetDest.Row[strChampDest, DataRowVersion.Original];
}
if (objetDest.Row.RowState != DataRowState.Deleted &&
(objetDest.Row.RowState != DataRowState.Modified ||
valeurCourante.Equals(valeurOld)))
{
MethodInfo method = (MethodInfo)tableChampToMethode[strChampDest];
if (method == null)
///Cherche la méthode associée au champ
{
CStructureTable structure = CStructureTable.GetStructure(objetDest.GetType());
foreach (CInfoChampTable champ in structure.Champs)
{
if (champ.NomChamp == strChampDest)
{
PropertyInfo prop = objetDest.GetType().GetProperty(champ.Propriete);
if (prop != null)
{
method = prop.GetSetMethod(true);
tableChampToMethode[strChampDest] = method;
}
break;
}
}
}
DateTime dt = (DateTime)objetDest.Row[strChampDest];
dt = dt.Add(sp);
if (method == null)
{
objetDest.Row[strChampDest] = dt;
}
else
{
method.Invoke(objetDest, new object[] { dt });
}
tablesQuiOntChange[objetDest.GetNomTable()] = true;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
foreach (string strNomTable in tablesQuiOntChange.Keys)
{
result += contexte.GetTableLoader(strNomTable).TraitementAvantSauvegarde(contexte);
if (!result)
{
break;
}
}
}
}
return(result);
}
//////////////////////////////////////////////////////////////////////
public override CResultAErreur TraitementAvantSauvegarde(CContexteDonnee contexte)
{
CResultAErreur result = base.TraitementAvantSauvegarde(contexte);
if (!result)
{
return(result);
}
DataTable table = contexte.Tables[GetNomTable()];
if (table == null)
{
return(result);
}
ArrayList lst = new ArrayList(table.Rows);
Dictionary <IElementAEO, bool> tableElementsToUpdate = new Dictionary <IElementAEO, bool>();
foreach (DataRow row in lst)
{
if (
row.RowState == DataRowState.Modified ||
row.RowState == DataRowState.Added)
{
CRelationElement_EO rel = new CRelationElement_EO(row);
CObjetDonneeAIdNumerique objet = rel.ElementLie;
if (objet != null)
{
if (objet is IElementAEO)
{
tableElementsToUpdate[(IElementAEO)objet] = true;
// Vérifie les Exception de Type pour le Type d'EO
if (rel.EntiteOrganisationnelle != null &&
rel.EntiteOrganisationnelle.TypeEntite != null &&
rel.EntiteOrganisationnelle.TypeEntite.HasExceptionForType(objet.GetType()))
{
result.EmpileErreur(I.T("@1 cannot be affected to Organizational Entity @2. There is an Exception on this Type|10011",
((IElementAEO)objet).DescriptionElement, rel.EntiteOrganisationnelle.Libelle));
return(result);
}
}
}
}
else if (row.RowState == DataRowState.Deleted)
{
CRelationElement_EO rel = new CRelationElement_EO(row);
rel.VersionToReturn = DataRowVersion.Original;
CObjetDonneeAIdNumerique objet = rel.ElementLie;
if (objet != null && objet.IsValide() && objet is IElementAEO && (!(rel.Row[CSc2iDataConst.c_champIsDeleted] is bool) || (bool)rel.Row[CSc2iDataConst.c_champIsDeleted] != true))
{
tableElementsToUpdate[(IElementAEO)objet] = true;
}
}
}
//Met à jour les eos des éléments qui ont bougé
foreach (IElementAEO element in tableElementsToUpdate.Keys)
{
result = CUtilElementAEO.UpdateEOSInCurrentContext(element);
if (!result)
{
return(result);
}
}
return(result);
}
