public CInfoElementImport(CObjetDonnee element)
{
TypeElement = element.GetType();
KeyElement = element.DbKey;
}
//-----------------------------------------------------------------------------------
public void OnFournisseurTermine(HashSet <CReferenceObjetDependant> setDependances)
{
lock (typeof(CLockerArbre))
{
List <TreeNode> nodesTypeToCreate = new List <TreeNode>();
Dictionary <TreeNode, List <TreeNode> > nodesObjetToCreate = new Dictionary <TreeNode, List <TreeNode> >();
Dictionary <Type, TreeNode> dicTypeToNode = new Dictionary <Type, TreeNode>();
foreach (TreeNode node in m_arbre.Nodes)
{
if (node.Tag is Type)
{
dicTypeToNode[(Type)node.Tag] = node;
}
}
m_lblProgression.SetInfo(I.T("Reading @1 element(s)|20014", setDependances.Count.ToString()));
List <CObjetDonnee> lstObjets = CReferenceObjetDonnee.GetObjets(setDependances, m_objetRacine.ContexteDonnee);
m_lblProgression.SetInfo(I.T("Adding @1 element(s)|20013", setDependances.Count.ToString()));
foreach (CObjetDonnee objet in lstObjets)
{
if (objet == null)
{
continue;
}
Type tpObjet = objet.GetType();
TreeNode nodeType = null;
if (!dicTypeToNode.TryGetValue(tpObjet, out nodeType))
{
nodeType = new TreeNode();
FillNodeType(nodeType, tpObjet);
dicTypeToNode[tpObjet] = nodeType;
nodesTypeToCreate.Add(nodeType);
}
bool bExiste = false;
if (objet != null)
{
foreach (TreeNode node in nodeType.Nodes)
{
CObjetDonnee objetEx = node.Tag as CObjetDonnee;
if (objetEx != null && objetEx.Equals(objet))
{
bExiste = true;
break;
}
}
if (!bExiste)
{
TreeNode nodeObjet = new TreeNode();
FillNodeObjet(nodeObjet, objet);
List <TreeNode> lstNodes = null;
if (!nodesObjetToCreate.TryGetValue(nodeType, out lstNodes))
{
lstNodes = new List <TreeNode>();
nodesObjetToCreate[nodeType] = lstNodes;
}
lstNodes.Add(nodeObjet);
}
}
}
Invoke((MethodInvoker) delegate
{
m_arbre.BeginUpdate();
foreach (TreeNode node in nodesTypeToCreate)
{
m_arbre.Nodes.Add(node);
}
foreach (KeyValuePair <TreeNode, List <TreeNode> > kv in nodesObjetToCreate)
{
foreach (TreeNode nodeFils in kv.Value)
{
kv.Key.Nodes.Add(nodeFils);
}
}
m_arbre.EndUpdate();
});
}
}
//--------------------------------------------------------------------------------------------------------------------
public override CResultAErreur ExecuterOperation(IDatabaseConnexion connection, IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
if (!typeof(IObjetDonneeAIdNumerique).IsAssignableFrom(m_type) || !CObjetDonnee.TypeManageIdUniversel(m_type))
{
result.EmpileErreur(m_type.ToString() + " can not have Universal Id");
}
string strNomTable = CContexteDonnee.GetNomTableForType(m_type);
CStructureTable structure = CStructureTable.GetStructure(m_type);
string strChampId = structure.ChampsId[0].NomChamp;
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.FiltreAAppliquer = new CFiltreData(CObjetDonnee.c_champIdUniversel + "=@1", "");
requete.TableInterrogee = CContexteDonnee.GetNomTableForType(m_type);
requete.ListeChamps.Add(new C2iChampDeRequete(strChampId, new CSourceDeChampDeRequete(strChampId),
typeof(int),
OperationsAgregation.None, true));
Console.WriteLine("Update Universal id on " + strNomTable);
result = requete.ExecuteRequete(connection.IdSession);
if (!result)
{
return(result);
}
string strNomTableInDb = CContexteDonnee.GetNomTableInDbForNomTable(strNomTable);
DataTable table = result.Data as DataTable;
int nNb = 0;
bool bWasInTrans = connection.IsInTrans();
if (bWasInTrans)
{
connection.CommitTrans();
}
DateTime dt = DateTime.Now;
if (table.Rows.Count > 0)
{
if (table.Rows.Count > 10000 && connection is COracleDatabaseConnexion)
{
string strQuery = "Update " + strNomTableInDb + " set " + CObjetDonnee.c_champIdUniversel +
"=CONCAT('" + strNomTableInDb + "'," + strChampId + ")";
result = connection.RunStatement(strQuery);
}
else
{
foreach (DataRow row in table.Rows)
{
string strQuery = "Update " + strNomTableInDb + " set " +
CObjetDonnee.c_champIdUniversel + "='" + CUniqueIdentifier.GetNew() + "' where " +
strChampId + "=" + row[0].ToString();
result = connection.ExecuteScalar(strQuery);
if (!result)
{
break;
}
nNb++;
if (nNb % 100 == 0)
{
TimeSpan sp = DateTime.Now - dt;
double fVal = (double)sp.TotalSeconds / (double)nNb * (double)(table.Rows.Count - nNb);
Console.WriteLine(strNomTableInDb + " " + nNb + "/" + table.Rows.Count + " reste " + fVal.ToString("0s"));
}
}
}
}
if (bWasInTrans)
{
connection.BeginTrans();
}
return(result);
/*
*
* //Trouve tous les éléments du type qui n'ont pas d'id universel
* using (CContexteDonnee ctx = new CContexteDonnee(connection.IdSession, true, false))
* {
* CListeObjetsDonnees lst = new CListeObjetsDonnees(ctx, m_type, false);
* lst.Filtre = new CFiltreData(CObjetDonnee.c_champIdUniversel + "=@1", "");
* lst.Filtre.IgnorerVersionDeContexte = true;
* lst.AppliquerFiltreAffichage = false;
*
* foreach (IObjetDonnee objet in lst.ToArrayList())
* {
* objet.Row[CObjetDonnee.c_champIdUniversel] = CUniqueIdentifier.GetNew();
* }
* string strNomTable = CContexteDonnee.GetNomTableForType(m_type);
* CObjetServeur objetServeur = CContexteDonnee.GetTableLoader(strNomTable, null, connection.IdSession) as CObjetServeur;
* int nCount = ctx.Tables[strNomTable].Rows.Count;
* DataTable tableSource = ctx.Tables[strNomTable];
*
* List<string> lstChampsExclus = new List<string>();
* HashSet<string> lstIDs = new HashSet<string>();
* CStructureTable structure = CStructureTable.GetStructure(m_type);
* foreach (CInfoChampTable info in structure.ChampsId)
* lstIDs.Add(info.NomChamp);
*
* foreach (CInfoChampTable champ in structure.Champs)
* if (champ.NomChamp != CObjetDonnee.c_champIdUniversel && !lstIDs.Contains(champ.NomChamp))
* lstChampsExclus.Add(champ.NomChamp);
*
* IDataAdapter adapter = objetServeur.GetDataAdapter(DataRowState.Modified, lstChampsExclus.ToArray());
*
* for (int nRow = 0; nRow < nCount; nRow += 5000)
* {
*
* using (DataSet dsCopie = new DataSet())
* {
* dsCopie.EnforceConstraints = false;
* DataTable tableCopie = ctx.Tables[strNomTable].Clone();
* tableCopie.BeginLoadData();
* dsCopie.Tables.Add(tableCopie);
* int nMax = Math.Min(nRow + 5000, nCount);
* DateTime dt = DateTime.Now;
* for (int n = nRow; n < nMax; n++)
* {
* tableCopie.ImportRow(tableSource.Rows[n]);
* }
* TimeSpan sp = DateTime.Now - dt;
* Console.WriteLine("Write 1" + strNomTable + " " + nRow + "/" + nCount+" "+sp.TotalSeconds.ToString());
* adapter.Update(dsCopie);
* sp = DateTime.Now - dt;
* Console.WriteLine("Write 2" + strNomTable + " " + nRow + "/" + nCount + " " + sp.TotalSeconds.ToString());
* }
* }
* }
* return result;*/
}
public CResultAErreur ExecuteAction(CObjetDonnee objet)
{
return(CExecuteurActionSur2iLink.ExecuteAction(m_controlSource, m_action, objet));
}
//---------------------------------------------------------------
public CValeursProprietes(CObjetDonnee objet)
: this(objet, false)
{
}
///////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
return(CResultAErreur.True);
}
/// <summary>
/// /////////////////////////////////////////////////////////////////////////////////
/// </summary>
/// <param name="table"></param>
/// <param name="result"></param>
///
private static CResultAErreur TraitementAvantSauvegardeExterne(CContexteDonnee contexte, Hashtable tableData)
{
CResultAErreur result = CResultAErreur.True;
///Stef 22/07/08 : l'appel à shouldDeclenche peut
///nécessiter GetValeurChamp (si conditions sur des champs). Or, si un élément n'a pas
///de valeur pour un champ, l'appli va aller chercher la valeur par défaut de ce
///champ, si le champ n'est pas chargé, l'appli va le lire. Comme on est souvent
///dans un contexte sans gestion par tables complètes, on est mal, parce que
///ça va génerer une requête par champ.
///Donc, on lit tous les champs custom avant de commencer
CListeObjetsDonnees listeChamps = new CListeObjetsDonnees(contexte, typeof(CChampCustom));
listeChamps.PreserveChanges = true; //Pour ne pas modifier les champs modifiés
listeChamps.AssureLectureFaite();
DateTime dt = DateTime.Now;
CTraitementApresSauvegarde traitement = new CTraitementApresSauvegarde( );
ArrayList lstTables = CContexteDonnee.GetTablesOrderInsert(contexte);
//Pour empêcher de regarder deux fois les évenements d'un même objet
//Type->Dictionnaire des ids vus
Dictionary <Type, Dictionary <int, bool> > elementsVus = new Dictionary <Type, Dictionary <int, bool> >();
DataRowChangeEventHandler handlerRedo = new DataRowChangeEventHandler(table_RowChanged);
Dictionary <string, Dictionary <int, bool> > listeElementsARepasser = null;
if (!m_listeElementsARepasser.TryGetValue(contexte, out listeElementsARepasser))
{
listeElementsARepasser = new Dictionary <string, Dictionary <int, bool> >();
m_listeElementsARepasser[contexte] = listeElementsARepasser;
}
bool bFirstPasse = true;
int nLimiteurPasses = 0;
while ((bFirstPasse | listeElementsARepasser.Count > 0) && nLimiteurPasses < 5)
{
nLimiteurPasses++;
foreach (DataTable table in lstTables)
{
if (table.Rows.Count > 0 && table.PrimaryKey.Length == 1)
{
string strChampCle = table.PrimaryKey[0].ColumnName;
Type tpObjets = CContexteDonnee.GetTypeForTable(table.TableName);
if (!typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpObjets))
{
continue;
}
Type typeOriginal = tpObjets;
//Lors de la modif de champs custom, l'élement parent n'est pas forcement modifié
//Mais le champ peut l'être
if (tpObjets.IsSubclassOf(typeof(CRelationElementAChamp_ChampCustom)))
{
int nLigne = 0;
bool bGoOut = false;
while (table.Rows.Count > nLigne && !bGoOut)
{
if (table.Rows[nLigne].RowState != DataRowState.Deleted)
{
CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)contexte.GetNewObjetForRow(table.Rows[nLigne]);
tpObjets = rel.ElementAChamps.GetType();
strChampCle = ((CObjetDonnee)rel.ElementAChamps).GetChampsId()[0];
bGoOut = true;
}
nLigne++;
}
}
//Les objets qui n'ont pas de relationTypeId ne peuvent pas avoir d'évenements
if (tpObjets.GetCustomAttributes(typeof(NoRelationTypeIdAttribute), true).Length > 0)
{
continue;
}
ArrayList lstEvenements = GetListeEvenementsAutoSur(tpObjets, contexte.IdVersionDeTravail);
//Id des éléments modifiés
List <int> listeIdsElementsAVerifierHandlers = new List <int>();
string strPrimaryKey = "";
if (table.PrimaryKey.Length == 1 &&
table.PrimaryKey[0].DataType == typeof(int))
{
strPrimaryKey = table.PrimaryKey[0].ColumnName;
}
Dictionary <int, bool> tableIdsVues = null;
if (!elementsVus.TryGetValue(tpObjets, out tableIdsVues))
{
tableIdsVues = new Dictionary <int, bool>();
elementsVus[tpObjets] = tableIdsVues;
}
Dictionary <int, bool> listeARepasserPourTable = null;
if (!listeElementsARepasser.TryGetValue(table.TableName, out listeARepasserPourTable))
{
listeARepasserPourTable = null;
}
List <CObjetDonnee> lstObjetsAvecEvenementsSpecifiques = new List <CObjetDonnee>();
//Stef 16/11/2012 :
//Si c'est un élément à champs, il est consideré comme modifié
//si un de ses champs custom est modifiés
//Ca a été fait parce que les handlers d'évenement n'étaient
//Pas pris en compte sur modif de champ custom
//On n'enlève pas pour autant l'ancienne méthode qui consiste
//à considérer l'élément modifié losrqu'on passe sur la table des
//valeurs de champs custom
if (typeof(IObjetDonneeAChamps).IsAssignableFrom(typeOriginal) && table.Rows.Count > 0)
{
//Regarde s'il y a des relations
IObjetDonneeAChamps objAChamp = contexte.GetNewObjetForRow(table.Rows[0]) as IObjetDonneeAChamps;
string strTableChamps = objAChamp.GetNomTableRelationToChamps();
//Trouve la relation à la table
DataTable tableChamps = contexte.Tables[strTableChamps];
if (tableChamps != null)//Si la table champs n'est pas là, c'est
//qu'elle n'a pas été modifiée !! c'est logique çà
{
DataRelation rel = null;
foreach (DataRelation relTest in tableChamps.ParentRelations)
{
if (relTest.ParentTable.TableName == table.TableName)
{
rel = relTest;
break;
}
}
if (rel != null)//On peut vérifier !
{
foreach (DataRow row in new ArrayList(table.Rows))
{
if (row.RowState == DataRowState.Unchanged)//sinon, ce n'est pas la peine
{
DataRow[] rowsChamps = row.GetChildRows(rel);
foreach (DataRow rowChamp in rowsChamps)
{
if (rowChamp.RowState != DataRowState.Unchanged)
{
//Aloue l'objet pour s'assurer que la ligne est bien pleine
CObjetDonnee objTmp = contexte.GetNewObjetForRow(row);
objTmp.AssureData();
row.SetModified();
string strOldContexte = (string)row[CObjetDonnee.c_champContexteModification];
if (strOldContexte.Length == 0)
{
row[CObjetDonnee.c_champContexteModification] = rowChamp[CObjetDonnee.c_champContexteModification,
rowChamp.RowState == DataRowState.Deleted ? DataRowVersion.Original : DataRowVersion.Current] as string;
}
break;
}
}
}
}
}
}
}
foreach (DataRow row in new ArrayList(table.Rows))
{
CObjetDonneeAIdNumerique objet = null;
if (lstEvenements.Count > 0)
{
if (row.RowState == DataRowState.Added ||
row.RowState == DataRowState.Modified ||
row.RowState == DataRowState.Deleted)
{
objet = (CObjetDonneeAIdNumerique)((CContexteDonnee)table.DataSet).GetNewObjetForRow(row);
if (objet.Row.RowState == DataRowState.Deleted)
{
objet.VersionToReturn = DataRowVersion.Original;
}
if (objet.Row.RowState != DataRowState.Deleted && EvenementAttribute.HasEventsSpecifiques(objet))
{
lstObjetsAvecEvenementsSpecifiques.Add(objet);
}
if (typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(typeOriginal))
{
CRelationElementAChamp_ChampCustom rel = objet as CRelationElementAChamp_ChampCustom;
objet = (CObjetDonneeAIdNumerique)((CRelationElementAChamp_ChampCustom)objet).ElementAChamps;
if (objet.Row.RowState == DataRowState.Unchanged)
{
objet.Row.Row.SetModified();
}
if (objet.Row.RowState == DataRowState.Deleted)
{
objet.VersionToReturn = DataRowVersion.Original;
}
if (rel.ContexteDeModification.Length != 0 &&
objet.ContexteDeModification.Length == 0)
{
objet.ContexteDeModification = rel.ContexteDeModification;
}
}
if (!tableIdsVues.ContainsKey(objet.Id) || (
listeARepasserPourTable != null && listeARepasserPourTable.ContainsKey(objet.Id)))
{
tableIdsVues[objet.Id] = true;
foreach (CEvenement evt in lstEvenements)
{
if (!traitement.ContainsCouple(evt, (CObjetDonneeAIdNumerique)objet))
{
//Attention, si c'est une valeur de champ custom, envoie la valeur,
//c'est elle qui sera testée.
CInfoDeclencheurProcess infoDeclencheur = null;
if (evt.ShouldDeclenche((CObjetDonneeAIdNumerique)objet, ref infoDeclencheur))
{
infoDeclencheur.DbKeyEvenementDeclencheur = evt.DbKey;
infoDeclencheur.Info = evt.Libelle;
traitement.AddCoupleEvenementObjet(evt, (CObjetDonneeAIdNumerique)objet, infoDeclencheur);
}
}
}
}
}
}
//Regarde les handle d'évenement sur l'objet
if (strPrimaryKey != "" && (row.RowState == DataRowState.Modified))
{
listeIdsElementsAVerifierHandlers.Add((int)row[strPrimaryKey]);
}
}
if (listeARepasserPourTable != null)
{
listeARepasserPourTable.Clear();
}
if (listeIdsElementsAVerifierHandlers.Count > 0 && bFirstPasse)
{
//traitement par paquet de 500
for (int nIndexLot = 0; nIndexLot < listeIdsElementsAVerifierHandlers.Count; nIndexLot += 500)
{
int nMin = Math.Min(nIndexLot + 500, listeIdsElementsAVerifierHandlers.Count);
StringBuilder bl = new StringBuilder();
for (int nIndex = nIndexLot; nIndex < nMin; nIndex++)
{
bl.Append(listeIdsElementsAVerifierHandlers[nIndex].ToString());
bl.Append(",");
}
string strIdsElementsAVerifierHandlers = bl.ToString().Substring(0, bl.ToString().Length - 1);
//Recherche tous les handlers d'évenement pour les objets concernés
CListeObjetsDonnees listeHandler = new CListeObjetsDonnees(contexte, typeof(CHandlerEvenement));
listeHandler.Filtre = new CFiltreData(
CHandlerEvenement.c_champIdCible + " in (" + strIdsElementsAVerifierHandlers + ") and " +
CHandlerEvenement.c_champTypeCible + "=@1 and " +
CHandlerEvenement.c_champTypeEvenement + "=@2",
tpObjets.ToString(),
(int)TypeEvenement.Modification);
listeHandler.PreserveChanges = true;
foreach (CHandlerEvenement handler in listeHandler)
{
if (handler.Row.RowState != DataRowState.Deleted)
{
CObjetDonneeAIdNumerique objetTmp = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tpObjets, new object[] { contexte });
if (objetTmp.ReadIfExists(handler.IdElementCible))
{
CInfoDeclencheurProcess infoDeclencheur = null;
if (handler.ShoulDeclenche(objetTmp, ref infoDeclencheur))
{
if (infoDeclencheur != null && handler.EvenementLie != null)
{
infoDeclencheur.Info = handler.EvenementLie.Libelle;
}
traitement.AddCoupleHandlerObjet(handler, (CObjetDonneeAIdNumerique)objetTmp, infoDeclencheur);
}
}
}
}
}
}
//Annule les évenements spécifiques, ils ont été traités !
foreach (CObjetDonnee objet in lstObjetsAvecEvenementsSpecifiques)
{
EvenementAttribute.ClearEvenements(objet);
}
}
}
//Execute ce qui peut être executé tout de suite
foreach (DataTable table in contexte.Tables)
{
table.RowChanged += handlerRedo;
}
listeElementsARepasser.Clear();
foreach (CTraitementApresSauvegarde.CCoupleDeclencheurObjet couple in traitement.CouplesEvenementOuHandlerObjet)
{
if (couple.Objet is CObjetDonneeAIdNumerique &&
couple.PeutEtreExecuteSurLePosteClient)
{
result = couple.OnDeclencheSurClient();
if (!result)
{
return(result);
}
}
}
foreach (DataTable table in contexte.Tables)
{
table.RowChanged -= handlerRedo;
}
bFirstPasse = false;
}
if (traitement.CouplesEvenementOuHandlerObjet.Count != 0)
{
tableData[c_cleDonneeListeTraitements] = traitement;
}
m_listeElementsARepasser.Remove(contexte);
return(result);
}
public CObjetDonneeResultEventArgs(CObjetDonnee objet)
: base(objet)
{
}
/// //////////////////////////////////////////////
public TreeNode GetNodeFor(CObjetDonnee objet)
{
return(GetNodeFor(Nodes, objet));
}
public CObjetDonneeEventArgs(CObjetDonnee objet)
{
m_objetDonnee = objet;
}
public CObjetDonneeCancelEventArgs(CObjetDonnee objet)
: base(objet)
{
}
//-----------------------------------------------------------
public void AlloueCombo()
{
if (m_variable == null)
{
return;
}
Type typeElement = m_variable.TypeDonnee.TypeDotNetNatif;
if (m_variable is CVariableDynamiqueSelectionObjetDonnee)
{
typeElement = ((CVariableDynamiqueSelectionObjetDonnee)m_variable).FiltreSelection.TypeElements;
}
//Combos hiérarchiques
if (typeof(IObjetDonneeAutoReference).IsAssignableFrom(typeElement) &&
typeof(IObjetHierarchiqueACodeHierarchique).IsAssignableFrom(typeElement))
{
try
{
if (!(m_combo is CComboBoxArbreObjetDonneesHierarchique) && m_combo != null)
{
m_combo.Visible = false;
m_combo.Parent.Controls.Remove(m_combo);
m_combo.Dispose();
m_combo = null;
}
CComboBoxArbreObjetDonneesHierarchique arbre;
if (m_combo is CComboBoxArbreObjetDonneesHierarchique)
{
arbre = (CComboBoxArbreObjetDonneesHierarchique)m_combo;
}
else
{
arbre = new CComboBoxArbreObjetDonneesHierarchique();
arbre.ElementSelectionneChanged += new EventHandler(arbre_ElementSelectionneChanged);
}
CFiltreData filtre = null;
Type tp = m_variable.TypeDonnee.TypeDotNetNatif;
string strChamp = DescriptionFieldAttribute.GetDescriptionField(tp, "DescriptionElement", true);
string strTextNull = "";
if (m_variable is CVariableDynamiqueSelectionObjetDonnee)
{
CVariableDynamiqueSelectionObjetDonnee varSel = (CVariableDynamiqueSelectionObjetDonnee)m_variable;
tp = ((CVariableDynamiqueSelectionObjetDonnee)m_variable).FiltreSelection.TypeElements;
CFiltreDynamique filtreDyn = varSel.FiltreSelection;
filtre = GetFiltre(filtreDyn);
strChamp = DescriptionFieldAttribute.GetDescriptionField(tp, "DescriptionElement", true);
strTextNull = varSel.TextNull;
}
if (m_variable is CChampCustom)
{
CFiltreDynamique filtreDyn = ((CChampCustom)m_variable).FiltreObjetDonnee;
filtre = GetFiltre(filtreDyn);
}
using (CContexteDonnee contexte = new CContexteDonnee(1, true, false))
{
CObjetDonnee objet = (CObjetDonnee)Activator.CreateInstance(tp, new object[] { contexte });
arbre.Init(tp,
((IObjetDonneeAutoReference)objet).ProprieteListeFils,
((IObjetDonneeAutoReference)objet).ChampParent,
strChamp,
filtre,
null
);
if (strTextNull != "")
{
arbre.TextNull = strTextNull;
}
}
m_combo = arbre;
return;
}
catch { }
}
IList lst = null;
lst = m_variable.Valeurs;
if (m_variable is CChampCustom && ((CChampCustom)m_variable).TypeDonneeChamp.TypeDonnee == TypeDonnee.tObjetDonneeAIdNumeriqueAuto &&
lst is CListeObjetsDonnees)
{
CFiltreData filtre = ((CListeObjetsDonnees)lst).Filtre;
CFiltreDynamique filtreDyn = ((CChampCustom)m_variable).FiltreObjetDonnee;
if (filtreDyn != null)
{
filtre = GetFiltre(filtreDyn);
}
((CListeObjetsDonnees)lst).Filtre = filtre;
}
else
{
lst = m_variable.Valeurs;
}
C2iComboBox combo = null;
if (lst is CListeObjetsDonnees && ((CListeObjetsDonnees)lst).TypeObjets != typeof(CValeurChampCustom))
{
CComboBoxListeObjetsDonnees cmbListe = null;
if (m_combo is CComboBoxListeObjetsDonnees)
{
cmbListe = (CComboBoxListeObjetsDonnees)m_combo;
}
else
{
if (m_combo != null)
{
m_combo.Visible = false;
m_combo.Parent.Controls.Remove(m_combo);
m_combo.Dispose();
m_combo = null;
}
cmbListe = new CComboBoxListeObjetsDonnees();
cmbListe.SelectedValueChanged += new EventHandler(cmbListe_SelectedValueChanged);
}
cmbListe.NullAutorise = true;
cmbListe.Init((CListeObjetsDonnees)lst,
DescriptionFieldAttribute.GetDescriptionField(m_variable.TypeDonnee.TypeDotNetNatif, "DescriptionElement"),
true);
combo = cmbListe;
}
else
{
if (m_combo != null && m_combo.GetType() == typeof(C2iComboBox))
{
combo = (C2iComboBox)m_combo;
}
else
{
if (m_combo != null)
{
m_combo.Visible = false;
m_combo.Parent.Controls.Remove(m_combo);
m_combo.Dispose();
m_combo = null;
}
combo = new C2iComboBox();
combo.SelectionChangeCommitted += new EventHandler(combo_SelectionChangeCommitted);
}
combo.DisplayMember = "Display";
combo.ValueMember = "Value";
combo.DataSource = lst;
}
combo.DropDownStyle = ComboBoxStyle.DropDownList;
combo.Sorted = false;
combo.IsLink = false;
if (m_combo == null)
{
combo.CreateControl();
}
m_combo = combo;
}
protected override void OnChangeElementEdite(object element)
{
if (element != null &&
WndFiltreRapide != null)
{
CFiltreData filtreData;
if (WndFiltreRapide.Filter != null)
{
CElementAVariablesDynamiques eltAVar = new CElementAVariablesDynamiques();
CVariableDynamiqueStatique var = new CVariableDynamiqueStatique(eltAVar);
var.Nom = "EditedElement";
var.IdVariable = "0";
var.SetTypeDonnee(new CTypeResultatExpression(element.GetType(), false));
eltAVar.AddVariable(var);
eltAVar.SetValeurChamp(var, element);
CFiltreDynamique filtreDyn = WndFiltreRapide.Filter;
filtreDyn.ElementAVariablesExterne = eltAVar;
filtreData = (CFiltreData)filtreDyn.GetFiltreData().Data;
}
else
{
filtreData = null;
}
Type typePropriete = null;
if (WndFiltreRapide.Property != null)
{
typePropriete = WndFiltreRapide.Property.TypeDonnee.TypeDotNetNatif;
}
else if (WndFiltreRapide.Filter != null)
{
typePropriete = WndFiltreRapide.Filter.TypeElements;
}
if (typePropriete != null)
{
string strDesc = DescriptionFieldAttribute.GetDescriptionField(typePropriete, "DescriptionElement");
C2iTextBoxFiltreRapide txtRapide = m_selectionneur as C2iTextBoxFiltreRapide;
if (txtRapide != null)
{
txtRapide.InitAvecFiltreDeBase(typePropriete, strDesc, filtreData, true);
}
else
{
CComboBoxListeObjetsDonnees cmb = m_selectionneur as CComboBoxListeObjetsDonnees;
cmb.NullAutorise = true;
cmb.TextNull = I.T("None|19");
if (cmb != null)
{
cmb.Init(
typePropriete,
filtreData,
strDesc,
true);
}
}
if (WndFiltreRapide.Property != null)
{
CObjetDonnee valeur = CInterpreteurProprieteDynamique.GetValue(EditedElement, WndFiltreRapide.Property).Data as CObjetDonnee;
m_selectionneur.ElementSelectionne = valeur;
}
}
}
}
//-----------------------------------------------------------
public CInfoImportLigne(int nNumLigne, CObjetDonnee objet)
{
m_nNumLigne = nNumLigne;
m_infoElementRoot = new CInfoElementImport(objet);
}
//----------------------------------------------------------------------------
public List <CReferenceObjetDependant> GetDependances(CEntitiesManager manager, CObjetDonnee objet)
{
List <CReferenceObjetDependant> lst = new List <CReferenceObjetDependant>();
if (objet == null)
{
return(lst);
}
CStructureTable structure = CStructureTable.GetStructure(objet.GetType());
foreach (CInfoRelation relation in structure.RelationsFilles)
{
Type tpFille = CContexteDonnee.GetTypeForTable(relation.TableFille);
if (manager.ConfigurationRecherche.IsIgnore(tpFille))
{
return(lst);
}
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.FiltreAAppliquer = CFiltreData.CreateFiltreAndSurValeurs(relation.ChampsFille, objet.GetValeursCles());
requete.TableInterrogee = relation.TableFille;
bool bHasUniversalId = tpFille.GetCustomAttribute <NoIdUniverselAttribute>(true) == null;
if (bHasUniversalId)
{
requete.ListeChamps.Add(new C2iChampDeRequete(CObjetDonnee.c_champIdUniversel,
new CSourceDeChampDeRequete(CObjetDonnee.c_champIdUniversel),
typeof(string),
OperationsAgregation.None,
true));
}
else
{
CStructureTable sFille = CStructureTable.GetStructure(tpFille);
foreach (CInfoChampTable infoChamp in sFille.ChampsId)
{
requete.ListeChamps.Add(new C2iChampDeRequete(infoChamp.NomChamp,
new CSourceDeChampDeRequete(infoChamp.NomChamp),
infoChamp.TypeDonnee,
OperationsAgregation.None,
true));
}
}
string strNomProp = relation.NomConvivial;
if (strNomProp.Length == 0)
{
strNomProp = "List of " + DynamicClassAttribute.GetNomConvivial(tpFille);
}
CResultAErreur result = requete.ExecuteRequete(objet.ContexteDonnee.IdSession);
if (result && result.Data is DataTable)
{
DataTable table = result.Data as DataTable;
foreach (DataRow row in table.Rows)
{
if (bHasUniversalId)
{
lst.Add(new CReferenceObjetDependant(strNomProp, tpFille, CDbKey.GetNewDbKeyOnUniversalIdANePasUtiliserEnDehorsDeCDbKeyAddOn((string)row[0])));
}
else
{
lst.Add(new CReferenceObjetDependant(strNomProp, tpFille,
row.ItemArray));
}
}
}
}
return(lst);
}
////////////////////////////////////////////////////////////
public override CResultAErreur Serialize(C2iSerializer serializer)
{
CResultAErreur result = CResultAErreur.True;
int nVersion = GetNumVersion();
result = serializer.TraiteVersion(ref nVersion);
if (result)
{
result = base.Serialize(serializer);
}
if (!result)
{
return(result);
}
bool bHasConteneur;
serializer.TraiteString(ref m_strNomTableFille);
int nNbChampsFille = m_strChampsFille.Length;
serializer.TraiteInt(ref nNbChampsFille);
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
foreach (string strChamp in m_strChampsFille)
{
string strTmp = strChamp;
serializer.TraiteString(ref strTmp);
}
break;
case ModeSerialisation.Lecture:
m_strChampsFille = new string[nNbChampsFille];
for (int nChamp = 0; nChamp < nNbChampsFille; nChamp++)
{
string strTmp = "";
serializer.TraiteString(ref strTmp);
m_strChampsFille[nChamp] = strTmp;
}
break;
}
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
bHasConteneur = m_objetConteneur != null;
serializer.TraiteBool(ref bHasConteneur);
if (bHasConteneur)
{
Type tp = m_objetConteneur.GetType();
serializer.TraiteType(ref tp);
object[] lstValeurs = m_objetConteneur.GetValeursCles();
int nNbValeurs = lstValeurs.Length;
serializer.TraiteInt(ref nNbValeurs);
foreach (object obj in lstValeurs)
{
object obj_tmp = obj;
serializer.TraiteObjetSimple(ref obj_tmp);
}
}
break;
case ModeSerialisation.Lecture:
bHasConteneur = false;
serializer.TraiteBool(ref bHasConteneur);
if (!bHasConteneur)
{
m_objetConteneur = null;
}
else
{
Type tp = null;
serializer.TraiteType(ref tp);
#if PDA
m_objetConteneur = (CObjetDonnee)Activator.CreateInstance(tp);
m_objetConteneur.ContexteDonnee = m_contexte;
#else
m_objetConteneur = (CObjetDonnee)Activator.CreateInstance(tp, new object[] { m_contexte });
#endif
int nNbCles = 0;
serializer.TraiteInt(ref nNbCles);
object[] lst = new object[nNbCles];
for (int nCle = 0; nCle < nNbCles; nCle++)
{
serializer.TraiteObjetSimple(ref lst[nCle]);
}
m_objetConteneur.PointeSurLigne(lst);
}
break;
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
Init(m_objetConteneur, m_strNomTableFille, m_strChampsFille, m_bAppliquerFiltreParDefaut);
}
return(result);
}
//------------------------------------
private CResultAErreur ImporteRow(DataRow row, CFiltreData filtreCle, CContexteDonnee contexteDestination)
{
CResultAErreur result = CResultAErreur.True;
Dictionary <CDefinitionProprieteDynamique, object> dicValeurs = new Dictionary <CDefinitionProprieteDynamique, object>();
List <object> lstValeurs = new List <object>();
if (filtreCle != null)
{
filtreCle.Parametres.Clear();
}
foreach (CMappageChampImport mappage in Mappages)
{
object valeur = mappage.Origine.GetValeur(row);
if (mappage.IsCle && filtreCle != null)
{
if (valeur == null)
{
result.EmpileErreur("Can not import field @1 as key, because imported value is null|20045", mappage.ProprieteDestination.Nom);
return(result);
}
filtreCle.Parametres.Add(valeur);
}
dicValeurs[mappage.ProprieteDestination] = valeur;
}
CObjetDonnee objet = Activator.CreateInstance(m_typeCible, new object[] { contexteDestination }) as CObjetDonnee;
bool bCreate = true;
//Cherche si l'objet exite
if (filtreCle != null)
{
bCreate = !objet.ReadIfExists(filtreCle, !m_bChargerTouteLaCible);
}
if (bCreate && (OptionImport & EOptionImport.Create) != EOptionImport.Create)
{
return(result);
}
if (!bCreate && (OptionImport & EOptionImport.Update) != EOptionImport.Update)
{
return(result);
}
if (bCreate)
{
objet.CreateNewInCurrentContexte(null);
}
bool bUpdate = false;
foreach (KeyValuePair <CDefinitionProprieteDynamique, object> kv in dicValeurs)
{
object val = kv.Value;
if (kv.Value is int && typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(kv.Key.TypeDonnee.TypeDotNetNatif))
{
CObjetDonneeAIdNumerique obj = Activator.CreateInstance(kv.Key.TypeDonnee.TypeDotNetNatif, new object[] { contexteDestination }) as CObjetDonneeAIdNumerique;
if (!obj.ReadIfExists((int)kv.Value, !m_bChargerTouteLaCible))
{
obj = null;
}
val = obj;
}
result = CInterpreteurProprieteDynamique.GetValue(objet, kv.Key);
if (result)
{
object valeurOrigine = result.Data;
if ((val == null && valeurOrigine != null) ||
(valeurOrigine == null && val != null) ||
(val != null && valeurOrigine != null && !val.Equals(valeurOrigine)))
{
result = CInterpreteurProprieteDynamique.SetValue(objet, kv.Key, val);
if (!result)
{
return(result);
}
bUpdate = true;
}
}
}
if (bCreate)
{
m_nNbCreated++;
}
else if (bUpdate)
{
m_nNbUpdated++;
}
return(result);
}
////////////////////////////////////////////////////////////
public CListeObjetsDonneesContenus(CObjetDonnee objetParent, string strNomTableFille, string[] strChampsFille)
: base(objetParent.ContexteDonnee, CContexteDonnee.GetTypeForTable(strNomTableFille))
{
Init(objetParent, strNomTableFille, strChampsFille, true);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CTableParametrable tb = (CTableParametrable)objet;
if (tb.Libelle == "")
{
result.EmpileErreur(I.T("Custom Table label cannot be empty|373"));
}
CListeObjetsDonnees lst = new CListeObjetsDonnees(tb.ContexteDonnee, typeof(CTableParametrable));
//Nom unique dans son parent
if (tb.ElementLie == null)
{
lst.Filtre = new CFiltreData(
CTableParametrable.c_champLibelle + " = @1 AND " + CTableParametrable.c_champId + " <> @2", tb.Libelle, tb.Id);
}
else
{
IElementATableParametrable elt = tb.ElementLie;
if (elt is CSite)
{
lst.Filtre = new CFiltreData(CTableParametrable.c_champLibelle + "=@1 and " +
CSite.c_champId + "=@2 and " +
CTableParametrable.c_champId + "<>@3",
tb.Libelle,
((CSite)elt).Id,
tb.Id);
}
if (elt is CEquipement)
{
lst.Filtre = new CFiltreData(CTableParametrable.c_champLibelle + "=@1 and " +
CEquipement.c_champId + "=@2 and " +
CTableParametrable.c_champId + "<>@3",
tb.Libelle,
((CEquipement)elt).Id,
tb.Id);
}
}
if (lst.CountNoLoad != 0)
{
result.EmpileErreur(I.T("The Custom Table '@1' already exists|374", tb.Libelle));
}
if (tb.TypeTable == null)
{
result.EmpileErreur(I.T("Custom Table '@1' must have a Custom Table Type|392", tb.Libelle));
}
if (tb.Site != null && tb.Equipement != null)
{
result.EmpileErreur(I.T("Custom Table '@1' cannot be linked to both Site (@2) Site and Equipment (@3)|393", tb.Libelle, tb.Site.Libelle, tb.Equipement.Libelle));
}
if (tb.ElementLie != null && tb.TypeTable != null)
{
bool typetablecompatible = false;
CListeObjetsDonnees lstTypesPoss = tb.ElementLie.TypesTableParametrablePossibles;
foreach (CTypeTableParametrable tt in lstTypesPoss)
{
if (tt.Equals(tb.TypeTable))
{
typetablecompatible = true;
break;
}
}
if (!typetablecompatible)
{
result.EmpileErreur(I.T("The Custom Table Type '@1' of the custom table '@2' isn't compatible with element '@3'|394", tb.TypeTable.Libelle, tb.Libelle, tb.ElementLie.DescriptionElement));
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
////////////////////////////////////////////////////////////
private void Init(
CObjetDonnee objetParent,
string strNomTableFille,
string[] strChampsFille,
bool bAppliquerFiltreParDefaut)
{
m_strNomTableFille = strNomTableFille;
m_strChampsFille = strChampsFille;
m_objetConteneur = objetParent;
if (!RemplissageProgressif)
{
objetParent.AssureDependances(strNomTableFille, strChampsFille);
}
/*Stef 26042012 : suppression de cette optimisation,
* le problème est que si on ajoute des fils, alors, le filtre ne les voit plus !
* DataTable tableFille = ContexteDonnee.GetTableSafe(strNomTableFille);
* if (!RemplissageProgressif && tableFille != null && tableFille.PrimaryKey.Length == 1 &&
* tableFille.PrimaryKey[0].DataType == typeof(int))
* {
* string strFK = ContexteDonnee.GetForeignKeyName(objetParent.GetNomTable(), strNomTableFille, strChampsFille);
* DataRow[] rows = objetParent.Row.Row.GetChildRows(strFK);
* if (rows.Length == 0)
* m_filtrePrincipal = new CFiltreDataImpossible();
* else
* {
* DataColumn colKey = tableFille.PrimaryKey[0];
* StringBuilder bl = new StringBuilder();
* foreach (DataRow row in rows)
* {
* bl.Append(row[colKey]);
* bl.Append(',');
* }
* bl.Remove(bl.Length - 1, 1);
* m_filtrePrincipal = new CFiltreData(colKey.ColumnName + " in (" + bl.ToString() + ")");
* }
* }
* else*/
m_filtrePrincipal = CFiltreData.CreateFiltreAndSurValeurs(strChampsFille, objetParent.GetValeursCles());
m_bAppliquerFiltreParDefaut = bAppliquerFiltreParDefaut;
#if PDA
CObjetDonnee objet = (CObjetDonnee)Activator.CreateInstance(CContexteDonnee.GetTypeForTable(strNomTableFille));
objet.ContexteDonnee = m_objetConteneur.ContexteDonnee;
#else
CObjetDonnee objet = (CObjetDonnee)Activator.CreateInstance(CContexteDonnee.GetTypeForTable(strNomTableFille), new object[] { m_objetConteneur.ContexteDonnee });
#endif
CFiltreData filtre = bAppliquerFiltreParDefaut?objet.FiltreStandard:null;
if (filtre != null)
{
m_filtrePrincipal = CFiltreData.GetAndFiltre(m_filtrePrincipal, filtre);
}
if (!RemplissageProgressif)
{
//Puisque les objets sont lus, il n'y a aucune raison d'aller relire cette liste depuis
//La base de données
InterditLectureInDB = true;
m_bIsToRead = false;
}
}
/*/// //////////////////////////////////////////////////////////////////
* private static void CCreateur2iFormulaire_AfterCreateControl ( Control ctrl, C2iWnd wnd, object elementEdite )
* {
* if ( wnd is C2iWndLink && ctrl is LinkLabel )
* {
* ctrl.Tag = new CInfoLinkLabel((C2iWndLink)wnd, elementEdite);
* ((LinkLabel)ctrl).LinkClicked += new LinkLabelLinkClickedEventHandler(CExecuteurActionSur2iLink_Click);
* }
* }
*
* static void CCreateur2iFormulaire_AfterChangeElementEdite(Control ctrl, C2iWnd wnd, object elementEdite)
* {
* if (wnd is C2iWndLink && ctrl is LinkLabel)
* {
* ctrl.Tag = new CInfoLinkLabel((C2iWndLink)wnd, elementEdite);
* }
* }*/
/*/// //////////////////////////////////////////////////////////////////
* private static void CExecuteurActionSur2iLink_Click ( object sender, LinkLabelLinkClickedEventArgs args )
* {
* if (sender is LinkLabel && ((LinkLabel)sender).Tag is CInfoLinkLabel)
* {
* CInfoLinkLabel info = (CInfoLinkLabel)((LinkLabel)sender).Tag;
* C2iWndLink link = info.WndLink;
* object cible = info.Cible;
* CResultAErreur result = CResultAErreur.True;
* if ( link.ActionAssociee != null )
* {
* Form frm = ((Control)sender).FindForm();
* if (cible == null)
* {
* if (frm != null && frm is IFormEditObjetDonnee)
* cible = ((IFormEditObjetDonnee)frm).GetObjetEdite();
* }
* if (frm != null && frm is CFormEditionStandard)
* {
* if (((CFormEditionStandard)frm).EtatEdition)
* {
* if (CFormAlerte.Afficher(I.T("This action will save your data. Continue ?|1253"),
* EFormAlerteType.Question) == DialogResult.No)
* return;
* if (!((CFormEditionStandard)frm).OnClickValider())
* return;
* ((CFormEditionStandard)frm).OnClickModifier();
* }
*
* }
* if ( frm != null && frm is CFormListeStandard )
* {
* if ( link.ActionAssociee.GetType() == typeof ( CActionSur2iLinkAfficheFormulaireCustom ) ||
* link.ActionAssociee.GetType() == typeof ( CActionSur2iLinkAfficherFormulaire ) ||
* link.ActionAssociee.GetType() == typeof ( CActionSur2iLinkAfficherListe ))
* cible = ((CFormListeStandard)frm).ElementSelectionne;
* else if ( link.ActionAssociee.GetType() == typeof ( CActionSur2iLinkExecuterProcess ) )
* cible = ((CFormListeStandard)frm).ElementsCoches;
* }
* result = ExecuteAction(link.ActionAssociee, cible);
* if ( !result )
* CFormAlerte.Afficher ( result.Erreur );
* }
* }
* }*/
/// <summary>
/// //////////////////////////////////////////////////////////////////
/// </summary>
/// <param name="action"></param>
/// <returns></returns>
public static CResultAErreur ExecuteAction(object sender, CActionSur2iLink action, object objetCible)
{
CResultAErreur result = CResultAErreur.True;
Form frm = null;
if (!action.AutoriserEnEdition && sender != null && sender is Control)
{
frm = ((Control)sender).FindForm();
object cible = objetCible;
if (cible == null)
{
if (frm != null && frm is IFormEditObjetDonnee)
{
cible = ((IFormEditObjetDonnee)frm).GetObjetEdite();
}
}
if (frm != null && frm is IFormEditObjetDonnee)
{
if (((IFormEditObjetDonnee)frm).EtatEdition)
{
if (CFormAlerte.Afficher(I.T("This action will save your data. Continue ?|1253"),
EFormAlerteType.Question) == DialogResult.No)
{
return(result);
}
if (!((IFormEditObjetDonnee)frm).ValiderModifications())
{
return(result);
}
CObjetDonnee obj = ((IFormEditObjetDonnee)frm).GetObjetEdite();
if (obj != null)
{
if (cible is CObjetDonnee)
{
cible = ((CObjetDonnee)cible).GetObjetInContexte(obj.ContexteDonnee);
}
}
//((CFormEditionStandard)frm).OnClickModifier();
}
}
if (frm != null && frm is CFormListeStandard)
{
if (
action.GetType() == typeof(CActionSur2iLinkAfficherFormulaire) ||
action.GetType() == typeof(CActionSur2iLinkAfficherListe))
{
cible = ((CFormListeStandard)frm).ElementSelectionne;
}
else
{
CActionSur2iLinkAfficheFormulaireCustom actionForm = action as CActionSur2iLinkAfficheFormulaireCustom;
if (actionForm != null)
{
cible = ((CFormListeStandard)frm).ElementSelectionne;
CFormulaire formulaire = new CFormulaire(CContexteDonneeSysteme.GetInstance());
if (formulaire.ReadIfExists(actionForm.IdFormulaireInDb))
{
if (formulaire.ElementEditeIsArray)
{
cible = ((CFormListeStandard)frm).ElementsCoches;
}
}
}
else if (action.GetType() == typeof(CActionSur2iLinkExecuterProcess))
{
cible = ((CFormListeStandard)frm).ElementsCoches;
}
}
}
objetCible = cible;
}
if (action is CActionSur2iLinkAfficherFormulaire)
{
return(ExecuteActionFormulaire((CActionSur2iLinkAfficherFormulaire)action, objetCible));
}
else if (action is CActionSur2iLinkAfficherListe)
{
return(ExecuteActionListe((CActionSur2iLinkAfficherListe)action, objetCible));
}
else if (action is CActionSur2iLinkExecuterProcess)
{
result = ExecuteActionProcess((CActionSur2iLinkExecuterProcess)action, objetCible);
CFormEditionStandard frmStd = frm as CFormEditionStandard;
if (frmStd != null)
{
try//La fenêtre peut être fermée par le process, donc ça peut faire des erreurs
{
frmStd.RefillDialog();
}
catch { }
}
else if (frm == CFormMain.GetInstance())
{
CFormMain.GetInstance().RefreshPanelEtapeWorkflow();
}
return(result);
}
else if (action is CActionSur2iLinkAfficheFormulaireCustom)
{
return(ExecuteActionFormulaireCustom((CActionSur2iLinkAfficheFormulaireCustom)action, objetCible));
}
else if (action is CActionSur2iLinkAfficherEntite)
{
return(ExecuteActionAfficherEntite((CActionSur2iLinkAfficherEntite)action, objetCible));
}
else if (action is CActionSur2iLinkMenuDeroulant)
{
return(ExecuteActionMenuDeroulant((CActionSur2iLinkMenuDeroulant)action, sender, objetCible));
}
else if (action is CActionSur2iLinkFormulairePopup)
{
return(ExecuteActionFormulairePopup((CActionSur2iLinkFormulairePopup)action, sender, objetCible));
}
result = CResultAErreur.True;
result.EmpileErreur(I.T("Action not managed|30076"));
return(result);
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] listeParametres)
{
CResultAErreur result = CResultAErreur.True;
try
{
if (!(listeParametres[0] is CObjetDonnee))
{
result.EmpileErreur(I.T("The first argument does not return a valid object for this operation|230"));
return(result);
}
string strChamp = listeParametres[1].ToString();
//Identifie le champ
Type tp = listeParametres[0].GetType();
CObjetDonnee objet = (CObjetDonnee)listeParametres[0];
//Est-ce une propriété ?
PropertyInfo propInteressante = tp.GetProperty(strChamp);
string strUpper = strChamp.ToUpper();;
if (propInteressante == null)
{
//Recherche sur DynamicField ou TableField;
foreach (PropertyInfo info in tp.GetProperties())
{
if (info.Name.ToUpper() == strUpper)
{
propInteressante = info;
break;
}
object[] attribs = info.GetCustomAttributes(typeof(DynamicFieldAttribute), true);
if (attribs.Length > 0)
{
if (((DynamicFieldAttribute)(attribs[0])).NomConvivial.ToUpper() == strUpper)
{
propInteressante = info;
break;
}
}
attribs = info.GetCustomAttributes(typeof(TableFieldPropertyAttribute), true);
if (attribs.Length > 0)
{
if (((TableFieldPropertyAttribute)attribs[0]).NomChamp.ToUpper() == strUpper)
{
propInteressante = info;
break;
}
}
}
}
if (propInteressante == null)
{
result.EmpileErreur(I.T("The property @1 isn't found in the @2 type|231", strChamp, objet.GetType().ToString()));
return(result);
}
DataRowVersion oldVersion = objet.VersionToReturn;
try
{
if (objet.Row.HasVersion(DataRowVersion.Original))
{
objet.VersionToReturn = System.Data.DataRowVersion.Original;
}
result.Data = propInteressante.GetGetMethod(true).Invoke(objet, null);
return(result);
}
catch
{
}
finally
{
objet.VersionToReturn = oldVersion;
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
return(result);
}
return(result);
}
private void m_btnOk_Click(object sender, EventArgs e)
{
CResultAErreur result = CResultAErreur.True;
CContexteDonnee ctx = null;
int? nIDProj = null;
CFiltreData filtreLiens = new CFiltreData();
CFiltreData filtreProjets = new CFiltreData();
CFiltreData filtreInters = new CFiltreData();
bool bFiltreLiens = false;
bool bFiltreProjets = false;
bool bFiltreInters = false;
foreach (I2iObjetGraphique objGraph in m_objsGraphiques)
{
IElementDeProjet ele = CUtilProjet.GetIElementDeProjet(objGraph);
if (!(ele is CObjetDonnee))
{
return;
}
CObjetDonnee obj = (CObjetDonnee)ele;
if (!obj.IsValide())
{
return;
}
if (ctx == null)
{
ctx = obj.ContexteDonnee;
}
if (ele.Projet == null)
{
return;
}
if (!nIDProj.HasValue)
{
nIDProj = ele.Projet.Id;
}
CFiltreData filtreBase = filtreLiens;
CFiltreData filtreTmp;
if (m_rbtnDetacher.Checked)
{
bFiltreLiens = true;
if (objGraph is IWndElementDeProjetPlanifiable)
{
((IWndElementDeProjetPlanifiable)objGraph).Detacher = true;
}
string strRqt = "";
switch (ele.TypeElementDeProjet.Code)
{
case ETypeElementDeProjet.Projet:
strRqt = CLienDeProjet.c_champPrjA + " = @1 OR " + CLienDeProjet.c_champPrjB + " = @1";
break;
case ETypeElementDeProjet.Intervention:
strRqt = CLienDeProjet.c_champInterA + " = @1 OR " + CLienDeProjet.c_champInterB + " = @1";
break;
case ETypeElementDeProjet.Lien:
strRqt = CLienDeProjet.c_champId + " =@1";
break;
default:
return;
}
ele.Projet = null;
filtreTmp = new CFiltreData(strRqt, ele.Id);
}
else
{
switch (ele.TypeElementDeProjet.Code)
{
case ETypeElementDeProjet.Intervention:
bFiltreInters = true;
filtreBase = filtreInters;
break;
case ETypeElementDeProjet.Lien:
bFiltreLiens = true;
filtreBase = filtreLiens;
break;
case ETypeElementDeProjet.Projet:
bFiltreProjets = true;
filtreBase = filtreProjets;
break;
default:
break;
}
filtreTmp = new CFiltreData(CUtilProjet.GetChampIDElement(objGraph) + " =@1", ele.Id);
}
if (filtreBase.Filtre != "")
{
filtreBase = CFiltreData.GetOrFiltre(filtreBase, filtreTmp);
}
else
{
filtreBase = filtreTmp;
}
if (m_rbtnDetacher.Checked)
{
filtreLiens = filtreBase;
}
else
{
switch (ele.TypeElementDeProjet.Code)
{
case ETypeElementDeProjet.Projet:
filtreProjets = filtreTmp;
break;
case ETypeElementDeProjet.Intervention:
filtreInters = filtreTmp;
break;
case ETypeElementDeProjet.Lien:
filtreLiens = filtreTmp;
break;
default:
break;
}
}
}
CFiltreData filtreSurProjet = new CFiltreData(CProjet.c_champId + " =@1", nIDProj.Value);
if (bFiltreLiens)
{
filtreLiens = CFiltreData.GetAndFiltre(filtreLiens, filtreSurProjet);
result = CObjetDonneeAIdNumerique.Delete(new CListeObjetsDonnees(ctx, typeof(CLienDeProjet), filtreLiens));
}
if (result && bFiltreInters)
{
filtreInters = CFiltreData.GetAndFiltre(filtreInters, filtreSurProjet);
result = CObjetDonneeAIdNumerique.Delete(new CListeObjetsDonnees(ctx, typeof(CIntervention), filtreInters));
}
if (result && bFiltreProjets)
{
filtreSurProjet = new CFiltreData(CProjet.c_champIdParent + " =@1", nIDProj);
filtreProjets = CFiltreData.GetAndFiltre(filtreProjets, filtreSurProjet);
result = CObjetDonneeAIdNumerique.Delete(new CListeObjetsDonnees(ctx, typeof(CProjet), filtreProjets));
}
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
DialogResult = DialogResult.OK;
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CSite site = (CSite)objet;
// Verifie le champ "Libelle"
if (site.Libelle == "")
{
result.EmpileErreur(I.T("The Site label cannot be empty|108"));
}
// Le champ "Libelle" doit être unique dans son parent seulement.
if (site.SiteParent != null)
{
// Liste des sites frères lst
CListeObjetsDonnees lst = site.SiteParent.SitesFils;
lst.Filtre = new CFiltreData(CSite.c_champLibelle + " = @1 AND " + CSite.c_champId + " <> @2", site.Libelle, site.Id);
if (lst.CountNoLoad != 0)
{
result.EmpileErreur(I.T("The Site '@1' already exists|370", site.Libelle));
}
}
// Vérifie le type de site
if (site.TypeSite == null)
{
result.EmpileErreur(I.T("The site type cannot be empty|106"));
}
// Verifie le type du site fils
if (site.SiteParent != null)
{
CListeObjetsDonnees liste_relations = site.SiteParent.TypeSite.RelationTypesContenus;
string strNom = site.TypeSite.Libelle;
string strParent = site.SiteParent.Libelle;
string strSiteParent = site.SiteParent.TypeSite.Libelle;
foreach (CRelationTypeSite_TypeSite rel in liste_relations)
{
strNom += " , " + rel.TypeSiteContenu.Libelle;
}
liste_relations.Filtre = new CFiltreData(CRelationTypeSite_TypeSite.c_champTypeContenuId + " = @1", site.TypeSite.Id);
if (liste_relations.CountNoLoad == 0)
{
result.EmpileErreur(I.T("The site type is not valid|107"));
}
}
// Vérifie le Code Site, peut être vide ou unique
if (site.Code != "")
{
if (!CObjetDonneeAIdNumerique.IsUnique(site, CSite.c_champCode, site.Code))
{
result.EmpileErreur(I.T("The Site Code '@1' already exist|371", site.Code));
}
}
if (result)
{
result = SObjetAFilsACoordonneeServeur.VerifieDonnees(site);
}
if (result)
{
result = site.VerifieCoordonnee();
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//----------------------------------------------------------------------------
public List <CReferenceObjetDependant> GetDependances(CEntitiesManager manager, CObjetDonnee objet)
{
List <CReferenceObjetDependant> lst = new List <CReferenceObjetDependant>();
if (objet == null)
{
return(lst);
}
if (!(objet is CObjetDonneeAIdNumerique))
{
return(lst);
}
foreach (RelationTypeIdAttribute rt in CContexteDonnee.RelationsTypeIds)
{
if (rt.IsAppliqueToType(objet.GetType()) && objet.GetType().GetCustomAttribute <NoRelationTypeIdAttribute>() == null)
{
Type tpRelId = CContexteDonnee.GetTypeForTable(rt.TableFille);
if (tpRelId != null && !manager.ConfigurationRecherche.IsIgnore(tpRelId))
{
CListeObjetsDonnees lstRT = new CListeObjetsDonnees(objet.ContexteDonnee, tpRelId);
lstRT.Filtre = new CFiltreData(rt.ChampType + "=@1 and " +
rt.ChampId + "=@2",
objet.GetType().ToString(),
((CObjetDonneeAIdNumerique)objet).Id);
foreach (CObjetDonnee objetRT in lstRT)
{
lst.Add(new CReferenceObjetDependant(rt.NomConvivialPourParent, objetRT));
}
}
}
}
return(lst);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CTypeEntiteOrganisationnelle typeEntiteOrganisationnelle = (CTypeEntiteOrganisationnelle)objet;
if (typeEntiteOrganisationnelle.Libelle == "")
{
result.EmpileErreur(I.T("Organisational Entity Type label cannot be empty|305"));
}
//Vérifie l'unicité du TypeEntiteOrganisationnelle dans son parent
if (typeEntiteOrganisationnelle.TypeParent != null)
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(objet.ContexteDonnee, typeof(CTypeEntiteOrganisationnelle));
liste.Filtre = new CFiltreData(CTypeEntiteOrganisationnelle.c_champIdParent + "=@1 and " +
CTypeEntiteOrganisationnelle.c_champLibelle + "=@2 and " +
CTypeEntiteOrganisationnelle.c_champId + "<>@3",
typeEntiteOrganisationnelle.TypeParent.Id,
typeEntiteOrganisationnelle.Libelle,
typeEntiteOrganisationnelle.Id);
if (liste.CountNoLoad > 0)
{
result.EmpileErreur(I.T("The Organisational Entity Type '@1' already exists|304", typeEntiteOrganisationnelle.Libelle));
}
}
else //Vérifie l'unicité du TypeEntiteOrganisationnelle
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(objet.ContexteDonnee, typeof(CTypeEntiteOrganisationnelle));
liste.Filtre = new CFiltreData(
CTypeEntiteOrganisationnelle.c_champLibelle + "=@1 and " +
CTypeEntiteOrganisationnelle.c_champId + "<>@2 and " +
CTypeEntiteOrganisationnelle.c_champNiveau + "=@3",
typeEntiteOrganisationnelle.Libelle,
typeEntiteOrganisationnelle.Id,
0);
if (liste.CountNoLoad > 0)
{
result.EmpileErreur(I.T("The Organisational Entity Type '@1' already exists|304", typeEntiteOrganisationnelle.Libelle));
}
}
//Vérifie que le parent n'a qu'un fils
if (typeEntiteOrganisationnelle.TypeParent != null)
{
CListeObjetsDonnees listeFils = typeEntiteOrganisationnelle.TypeParent.TypesFils;
foreach (CTypeEntiteOrganisationnelle tp in listeFils)
{
if (!tp.Equals(typeEntiteOrganisationnelle))
{
result.EmpileErreur(I.T("Impossible to assign two types of entities to the same parent|100"));
}
}
}
//Si on est en modification et que ce type d'entité
//dispose d'entite > Verification d'un changement de format de numérotation
//if (typeEntiteOrganisationnelle.Row.HasVersion(DataRowVersion.Original) && typeEntiteOrganisationnelle.HasEntitesOrganisationnelles())
//{
// bool coorObligatoire = typeEntiteOrganisationnelle.CoordonneeObligatoire;
// CFormatNumerotation frmActuel = typeEntiteOrganisationnelle.FormatNumerotation;
// typeEntiteOrganisationnelle.VersionToReturn = DataRowVersion.Original;
// if(coorObligatoire && !typeEntiteOrganisationnelle.CoordonneeObligatoire)
// result.EmpileErreur(I.T( "Impossible de rendre les coordonnées obligatoires car des entitées sont déjà affiliées"));
// if (typeEntiteOrganisationnelle.FormatNumerotation != frmActuel)
// result.EmpileErreur(I.T( "Impossible de modifier le format de numérotation car des entitées sont déjà affiliées"));
//}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CProfilElement profilElement = (CProfilElement)objet;
// Verifie le champ "Libelle"
if (profilElement.Libelle == "")
{
result.EmpileErreur(I.T("The Profile label cannot be empty|214"));
}
if (profilElement.UtiliseLeProfil(profilElement))
{
result.EmpileErreur(I.T("Cyclic reference of profiles : impossible to validate Profile|215"));
}
if (profilElement.FormuleApplication == null ||
profilElement.FormuleApplication.TypeDonnee.TypeDotNetNatif != typeof(bool))
{
result.EmpileErreur(I.T("The application condition must return a boolean|216"));
}
if (profilElement.FormuleIntegration == null ||
profilElement.FormuleIntegration.TypeDonnee.TypeDotNetNatif != typeof(bool))
{
result.EmpileErreur(I.T("The integration condition must return a boolean|217"));
}
if (profilElement.ToutesLesCorrespondancesEO.Count != 0 &&
profilElement.TypeElements != null &&
profilElement.TypeSource != null)
{
CDefinitionProprieteDynamique propEO = profilElement.ProprieteCheminToEOElement;
if (propEO == null)
{
if (!typeof(IElementAEO).IsAssignableFrom(profilElement.TypeElements))
{
result.EmpileErreur(I.T("The Organisational entities on elements of type @1 cannot be tested|218", DynamicClassAttribute.GetNomConvivial(profilElement.TypeElements)));
}
}
else
{
if (!typeof(IElementAEO).IsAssignableFrom(propEO.TypeDonnee.TypeDotNetNatif))
{
result.EmpileErreur(I.T("The Organisational entities on elements of type @1 cannot be tested|218", DynamicClassAttribute.GetNomConvivial(propEO.TypeDonnee.TypeDotNetNatif)));
}
}
C2iExpression formuleEltAEo = profilElement.FormuleElementAEOSource;
if (formuleEltAEo != null)
{
if (!typeof(IElementAEO).IsAssignableFrom(formuleEltAEo.TypeDonnee.TypeDotNetNatif))
{
result.EmpileErreur(I.T("The formula for the Source Element with Organisational Enity must return an element with an Organisational Entity|219"));
}
}
else
{
if (!typeof(IElementAEO).IsAssignableFrom(profilElement.TypeSource))
{
result.EmpileErreur(I.T("The elements @1 are not related to Organisational Entities, the Organisational Entities cannot be used on these elements|220", DynamicClassAttribute.GetNomConvivial(profilElement.TypeSource)));
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//------------------------------------------------------------------
private void m_btnFlush_Click(object sender, System.EventArgs e)
{
SelectedObject = null;
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CIntervention inter = (CIntervention)objet;
if (inter.Site == null)
{
result.EmpileErreur(I.T("The intervention must be associated to a Site|388"));
}
if (inter.TypeIntervention == null)
{
result.EmpileErreur(I.T("The Intervention type cannot be null|152"));
}
if (inter.Fractions.Count == 0)
{
//Pas de fractions, il faut au moins un préplanifieur
if (inter.DateDebutPrePlanifiee == null ||
inter.DateFinPrePlanifiee == null)
{
if (inter.UserPreplanifieur == null)
{
result.EmpileErreur(I.T("The person in charge of preplanning must be defined|209"));
}
}
else
{
if (inter.UserPlanifieur == null)
{
result.EmpileErreur(I.T("The person in charge of planning must be definde|210"));
}
}
}
if (inter.UserPlanifieur != null)
{
if (inter.TypeIntervention != null && inter.TypeIntervention.ProfilPlanifieur != null)
{
if (!inter.TypeIntervention.ProfilPlanifieur.IsInProfil(inter.UserPlanifieur, inter))
{
result.EmpileErreur(I.T("The user @1 cannot be a planner|211"), inter.UserPlanifieur.Acteur.IdentiteComplete);
}
}
}
if (inter.UserPreplanifieur != null)
{
if (inter.TypeIntervention != null && inter.TypeIntervention.ProfilPreplanifieur != null)
{
if (!inter.TypeIntervention.ProfilPreplanifieur.IsInProfil(inter.UserPreplanifieur, inter))
{
result.EmpileErreur(I.T("The user @1 cannot be a preplanner|212"), inter.UserPreplanifieur.Acteur.IdentiteComplete);
}
}
}
// Vérifie le doublons des Opérations prévisionnelles: même type d'opération et même équipement
CListeObjetsDonnees listOpe = inter.Operations;
listOpe.Filtre = new CFiltreData(CEquipement.c_champId + " is not null");
ArrayList listeAVerifier = listOpe.ToArrayList();
/* foreach (COperation ope1 in listeAVerifier)
* {
* foreach (COperation ope2 in listeAVerifier)
* {
* if (ope1.Id != ope2.Id &&
* ope1.TypeOperation.Id == ope2.TypeOperation.Id &&
* ope1.Equipement.Id == ope2.Equipement.Id)
* {
* result.EmpileErreur(I.T( "There are tow '@1' Operations on equipment '@2'|363", ope1.TypeOperation.Libelle, ope1.Equipement.Libelle));
* }
* }
* }*/
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
