public static CParametreFonctionDynamique EditeParametreFonction(CParametreFonctionDynamique parametre)
{
if (parametre == null)
{
return(null);
}
CFormEditVariableFormule form = new CFormEditVariableFormule();
if (parametre != null)
{
form.m_txtNom.Text = parametre.Nom;
form.m_txtType.Text = DynamicClassAttribute.GetNomConvivial(parametre.TypeResultatExpression.TypeDotNetNatif);
form.m_chkArray.Checked = parametre.TypeResultatExpression.IsArrayOfTypeNatif;
}
else
{
parametre = new CParametreFonctionDynamique();
}
form.m_parametre = parametre;
CParametreFonctionDynamique retour = null;
if (form.ShowDialog() == DialogResult.OK)
{
retour = form.m_parametre;
}
form.Dispose();
return(retour);
}
//------------------------------------------
private void InitChamps()
{
m_txtNomTable.Text = m_tableVue.NomTable;
//Indicateur de filtre
m_imageFiltre.Image = m_imagesFiltre.Images[m_tableVue.FormuleSelection == null ? 1 : 0];
m_wndListeChamps.Items.Clear();
m_wndListeChamps.BeginUpdate();
foreach (C2iChampExport champ in m_tableVue.Champs)
{
ListViewItem item = new ListViewItem();
FillItemForChamp(item, champ);
m_wndListeChamps.Items.Add(item);
}
m_wndListeChamps.EndUpdate();
m_imageFiltre.Visible = true;
if (m_tableVue.ChampOrigine is CDefinitionProprieteDynamiqueThis)
{
m_lblType.Text = DynamicClassAttribute.GetNomConvivial(m_tableVue.ChampOrigine.TypeDonnee.TypeDotNetNatif);
}
else if (m_tableVue.ChampOrigine != null)
{
m_lblType.Text = m_tableVue.ChampOrigine.Nom;
}
else
{
m_lblType.Text = "";
}
m_chkSupprimerTablesTravail.Checked = m_tableVue.SupprimerTablesTravail;
}
/// ///////////////////////////////////////
public override string ToString()
{
string strText = DynamicClassAttribute.GetNomConvivial(m_typeObjet) + "(";
if (m_keyObjet != null)
{
strText += m_keyObjet.StringValue;
}
else
{
foreach (object obj in m_cles)
{
if (obj == null)
{
strText += "null,";
}
else
{
strText += obj.ToString() + ",";
}
}
if (m_cles.Length > 0)
{
strText = strText.Substring(0, strText.Length - 1);
}
}
strText += ")";
return(strText);
}
/// <summary>
/// Retourne le symbole par défaut à utiliser pour un type d'élément
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static C2iSymbole GetSymboleParDefaut(Type typeElement, CContexteDonnee contexte)
{
int nId = GetIdSymboleParDefaut(typeElement, contexte);
C2iSymbole symboleADessiner = null;
if (nId >= 0)
{
CSymbole symbole = new CSymbole(contexte);
if (symbole.ReadIfExists(nId))
{
symboleADessiner = symbole.Symbole;
}
}
if (symboleADessiner == null)
{
symboleADessiner = new C2iSymbole();
symboleADessiner.Size = new Size(40, 40);
C2iSymboleLabel label = new C2iSymboleLabel();
label.Size = new Size(40, 40);
label.Parent = symboleADessiner;
symboleADessiner.AddChild(label);
label.Text = DynamicClassAttribute.GetNomConvivial(typeElement);
label.Position = new Point(0, 0);
}
return(symboleADessiner);
}
/// //////////////////////////////////////////
protected override void InitChamps()
{
m_wndListeTypes.BeginUpdate();
m_wndListeTypes.Items.Clear();
HashSet <Type> set = new HashSet <Type>();
foreach (Type tp in ActionNettoyageRelationsTypeId.TypesANettoyer)
{
set.Add(tp);
}
foreach (RelationTypeIdAttribute rel in CContexteDonnee.RelationsTypeIds)
{
string strNomTable = rel.TableFille;
Type tp = CContexteDonnee.GetTypeForTable(strNomTable);
if (tp != null)
{
ListViewItem item = new ListViewItem(DynamicClassAttribute.GetNomConvivial(tp));
item.Tag = tp;
item.Checked = set.Contains(tp);
m_wndListeTypes.Items.Add(item);
}
}
m_wndListeTypes.EndUpdate();
base.InitChamps();
}
//------------------------------------------
private void InitChamps()
{
m_txtNomTable.Text = m_tableCroisee.NomTable;
if (m_tableCroisee.ChampOrigine is CDefinitionProprieteDynamiqueThis)
{
m_lblType.Text = DynamicClassAttribute.GetNomConvivial(m_tableCroisee.ChampOrigine.TypeDonnee.TypeDotNetNatif);
}
else if (m_tableCroisee.ChampOrigine != null)
{
m_lblType.Text = m_tableCroisee.ChampOrigine.Nom;
}
else
{
m_lblType.Text = "";
}
m_chkSupprimerTablesTravail.Checked = m_tableCroisee.SupprimerTablesTravail;
//Crée une table bidon avec tous les champs de la table fille de cette table
DataTable tableBidon = new DataTable();
if (m_tableCroisee.TablesFilles.Length != 0)
{
foreach (IChampDeTable champ in m_tableCroisee.TablesFilles[0].Champs)
{
Type tp = champ.TypeDonnee;
if (tp.IsGenericType && tp.GetGenericTypeDefinition() == typeof(Nullable <>))
{
tp = tp.GetGenericArguments()[0];
}
DataColumn col = new DataColumn(champ.NomChamp, tp);
tableBidon.Columns.Add(col);
}
}
m_panelTableauCroise.InitChamps(tableBidon, m_tableCroisee.TableauCroise);
}
//---------------------------------------------------------------------
public void SetValeur(object objet, object valeur)
{
if (objet != null && objet is IObjetDonneeAChamps)
{
if (valeur is int)
{
if ((int)valeur >= 0)
{
CContexteDonnee contexte = ((IObjetDonneeAChamps)objet).ContexteDonnee;
CChampCustom champ = new CChampCustom(contexte);
if (champ.ReadIfExists(IdChampCustom))
{
CObjetDonneeAIdNumerique objetDonne = (CObjetDonneeAIdNumerique)Activator.CreateInstance(champ.TypeObjetDonnee, new object[] { contexte });
if (objetDonne.ReadIfExists((int)valeur))
{
CUtilElementAChamps.SetValeurChamp((IObjetDonneeAChamps)objet, m_nIdChampCustom, objetDonne);
}
else
{
throw new Exception(I.T("Object @1 @2 doesn't exist|515",
DynamicClassAttribute.GetNomConvivial(champ.TypeObjetDonnee),
valeur.ToString()));
}
}
}
}
else
{
CUtilElementAChamps.SetValeurChamp((IObjetDonneeAChamps)objet, m_nIdChampCustom, null);
}
}
}
private void InitComboBoxType(Type tp)
{
if (m_bComboInitialized)
{
return;
}
ArrayList lstTypes = new ArrayList();
if (tp != null)
{
CInfoClasseDynamique info = new CInfoClasseDynamique(tp, DynamicClassAttribute.GetNomConvivial(tp));
lstTypes.Add(info);
}
else
{
//CInfoClasseDynamique[] classes = DynamicClassAttribute.GetAllDynamicClass();
ArrayList infosClasses = new ArrayList(DynamicClassAttribute.GetAllDynamicClass());
infosClasses.Insert(0, new CInfoClasseDynamique(typeof(DBNull), I.T("None|19")));
infosClasses.Add(new CInfoClasseDynamique(typeof(string), I.T("String")));
infosClasses.Add(new CInfoClasseDynamique(typeof(double), I.T("Double")));
infosClasses.Add(new CInfoClasseDynamique(typeof(int), I.T("Int")));
infosClasses.Add(new CInfoClasseDynamique(typeof(DateTime), I.T("DateTime")));
infosClasses.Add(new CInfoClasseDynamique(typeof(bool), I.T("Boolean")));
infosClasses.Add(new CInfoClasseDynamique(typeof(object), I.T("Object")));
lstTypes.AddRange(infosClasses);
}
m_cmbTypeElements.DataSource = null;
m_cmbTypeElements.DataSource = lstTypes;
m_cmbTypeElements.ValueMember = "Classe";
m_cmbTypeElements.DisplayMember = "Nom";
m_bComboInitialized = true;
}
public CResultAErreur AlloueElement(Type tp)
{
CResultAErreur result = CResultAErreur.True;
if (typeof(CObjetDonneeAIdNumeriqueAuto).IsAssignableFrom(tp))
{
try
{
CObjetDonneeAIdNumeriqueAuto retour = Activator.CreateInstance(tp, new object[] { ContexteDonnee }) as CObjetDonneeAIdNumeriqueAuto;
if (retour != null)
{
retour.CreateNewInCurrentContexte();
}
result.Data = retour;
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
}
if (result.Data == null)
{
result.EmpileErreur(I.T("Can not allocate object @1|30005", DynamicClassAttribute.GetNomConvivial(tp)));
}
return(result);
}
//-------------------------------------------------------------------------
private void m_lnkFiltrer_LinkClicked(object sender, System.EventArgs e)
{
if (m_elementsAAgenda.Length == 0)
{
return;
}
CListeObjetsDonnees liste = new CListeObjetsDonnees(m_elementsAAgenda[0].ContexteDonnee,
typeof(CFiltreDynamiqueInDb));
liste.Filtre = new CFiltreData(
CFiltreDynamiqueInDb.c_champTypeElements + "=@1",
typeof(CRelationEntreeAgenda_ElementAAgenda).ToString());
if (liste.Count == 0)
{
CFormAlerte.Afficher(I.T("No filter exists on|30081") +
DynamicClassAttribute.GetNomConvivial(typeof(CRelationEntreeAgenda_ElementAAgenda)), EFormAlerteType.Exclamation);
return;
}
if (m_menuFiltrer.MenuItems.Count == 0)
{
CMenuItemAFiltreDynamique menu = new CMenuItemAFiltreDynamique(null);
menu.Text = "None|30082";
menu.Click += new EventHandler(OnMenuFiltrer);
m_menuFiltrer.MenuItems.Add(menu);
foreach (CFiltreDynamiqueInDb filtre in liste)
{
menu = new CMenuItemAFiltreDynamique(filtre);
menu.Text = filtre.Libelle;
menu.Click += new EventHandler(OnMenuFiltrer);
m_menuFiltrer.MenuItems.Add(menu);
}
}
m_menuFiltrer.Show(m_lnkFiltrer, new Point(0, m_lnkFiltrer.Height));
}
/// //////////////////////////////////////////
private void FillArbreProprietes()
{
m_dicIdDefToNode.Clear();
m_wndArbreProprietes.Nodes.Clear();
if (ActionClonerEntite.FormuleElementACloner == null)
{
return;
}
CTypeResultatExpression tp = ActionClonerEntite.FormuleElementACloner.TypeDonnee;
if (!(typeof(CObjetDonneeAIdNumeriqueAuto).IsAssignableFrom(tp.TypeDotNetNatif)) ||
tp.IsArrayOfTypeNatif)
{
return;
}
Type typePrincipal = tp.TypeDotNetNatif;
TreeNode node = new TreeNode(DynamicClassAttribute.GetNomConvivial(typePrincipal));
node.ImageIndex = 1;
m_wndArbreProprietes.Nodes.Add(node);
node.Tag = new CTagNode(typePrincipal,
new CDefinitionProprieteDynamiqueThis(
new CTypeResultatExpression(typePrincipal, false), true, false));
CreateChilds(node);
}
//----------------------------------------------------
private void ShowObjetCourant()
{
m_listeObjetsAnalyses.Clear();
m_listeObjetsAnalyses.Add(m_pileObjets.Peek());
m_panelTitres.SuspendDrawing();
m_panelTitres.ClearAndDisposeControls();
int nHeight = 0;
foreach (CObjetDonnee objet in m_pileObjets)
{
LinkLabel linkObjet = new LinkLabel();
linkObjet.Text = DynamicClassAttribute.GetNomConvivial(objet.GetType()) + "-" + objet.DescriptionElement;
if (nHeight == 0)
{
linkObjet.BackColor = m_arbre.BackColor;
}
m_panelTitres.Controls.Add(linkObjet);
linkObjet.Dock = DockStyle.Top;
linkObjet.Tag = objet;
linkObjet.AutoSize = true;
nHeight += linkObjet.Height;
linkObjet.SendToBack();
linkObjet.Click += linkObjet_Click;
}
m_panelTitres.Height = nHeight;
m_panelTitres.ResumeDrawing();
RemplirArbre();
}
//---------------------------------------
public void InitForModule(CModuleParametrage module, CContexteDonnee contexte)
{
CTreeViewNodeKeeper keeper = new CTreeViewNodeKeeper(this);
m_contexte = contexte;
m_moduleAffiche = module;
BeginUpdate();
Nodes.Clear();
Dictionary <string, List <CRelationElement_ModuleParametrage> > dicTypeToObjets = new Dictionary <string, List <CRelationElement_ModuleParametrage> >();
List <string> lstTypes = new List <string>();
if (m_moduleAffiche != null)
{
foreach (CRelationElement_ModuleParametrage rel in m_moduleAffiche.RelationsElements)
{
if (rel.ElementLie != null)
{
string strType = DynamicClassAttribute.GetNomConvivial(rel.ElementLie.GetType());
List <CRelationElement_ModuleParametrage> lst = null;
if (!dicTypeToObjets.TryGetValue(strType, out lst))
{
lstTypes.Add(strType);
lst = new List <CRelationElement_ModuleParametrage>();
dicTypeToObjets[strType] = lst;
}
lst.Add(rel);
}
}
lstTypes.Sort();
foreach (string strType in lstTypes)
{
TreeNode nodeType = new TreeNode(strType);
nodeType.SelectedImageIndex = 0;
nodeType.ImageIndex = 0;
nodeType.Tag = null;
Nodes.Add(nodeType);
List <CRelationElement_ModuleParametrage> lst = null;
if (dicTypeToObjets.TryGetValue(strType, out lst))
{
foreach (CRelationElement_ModuleParametrage rel in lst)
{
CObjetDonnee obj = rel.ElementLie;
string strDesc = DescriptionFieldAttribute.GetDescription(obj);
if (strDesc.Trim().Length == 0)
{
strDesc = obj.DescriptionElement;
}
TreeNode node = new TreeNode(strDesc);
node.Tag = rel;
node.ImageIndex = 1;
node.SelectedImageIndex = 1;
nodeType.Nodes.Add(node);
}
}
}
}
EndUpdate();
keeper.Apply(this);
}
//--------------------------------------------------------------------------
public CResultAErreur ReadRefsForType(Type tp)
{
CResultAErreur result = CResultAErreur.True;
if (tp == null)
{
return(result);
}
List <string> lst = new List <string>();
m_dicTypeToKeys[tp] = lst;
if (m_configuration.IsIgnore(tp))
{
return(result);
}
NoIdUniverselAttribute att = tp.GetCustomAttribute <NoIdUniverselAttribute>(true);
if (att != null)
{
return(result);
}
m_indicateurProgression.SetInfo(DynamicClassAttribute.GetNomConvivial(tp));
string strNomTable = CContexteDonnee.GetNomTableForType(tp);
//Compte les éléments dans la table
using (CContexteDonnee ctx = new CContexteDonnee(m_nIdSession, true, false))
{
CListeObjetsDonnees lstCount = new CListeObjetsDonnees(ctx, tp);
int nNb = lstCount.CountNoLoad;
if (nNb > m_configuration.LimiteNbPourRechercheReference)
{
m_setTypesIgnoresAutomatiquement.Add(tp);
return(result);
}
}
C2iRequeteAvancee r = new C2iRequeteAvancee(null);
r.TableInterrogee = strNomTable;
r.ListeChamps.Add(new C2iChampDeRequete(CObjetDonnee.c_champIdUniversel,
new CSourceDeChampDeRequete(CObjetDonnee.c_champIdUniversel),
typeof(string),
OperationsAgregation.None,
true));
result = r.ExecuteRequete(m_nIdSession);
if (result)
{
DataTable table = result.Data as DataTable;
if (table != null)
{
foreach (DataRow row in table.Rows)
{
lst.Add((string)row[0]);
m_dicKeyToTypes[(string)row[0]] = tp;
}
}
}
return(result);
}
private void InitZoneSelectionEntite()
{
if (m_entiteEditee.TypeEntiteSnmp != null && m_entiteEditee.TypeEntiteSnmp.TypeElementsSupervise != null)
{
m_typeElementAssocie = m_entiteEditee.TypeEntiteSnmp.TypeElementsSupervise;
if (m_entiteEditee.TypeEntiteSnmp.FiltreElementsSupervise != null)
{
CResultAErreur result = m_entiteEditee.TypeEntiteSnmp.FiltreElementsSupervise.GetFiltreData();
if (result)
{
m_filtreElementAssocie = result.Data as CFiltreData;
}
}
else
{
m_filtreElementAssocie = null;
}
}
if (m_typeElementAssocie == null && m_entiteEditee.ElementSupervise != null)
{
m_typeElementAssocie = m_entiteEditee.ElementSupervise.GetType();
}
if (m_typeElementAssocie == typeof(DBNull) || m_typeElementAssocie == null)
{
m_selectElementSupervise.Visible = false;
m_lblElementSupervise.Text = I.T("No associated element|20399");
}
else
{
m_selectElementSupervise.Visible = true;
m_lblElementSupervise.Text = DynamicClassAttribute.GetNomConvivial(m_typeElementAssocie);
CFiltreData filtre = null;
if (m_filtreElementAssocie != null)
{
filtre = m_filtreElementAssocie;
}
m_selectElementSupervise.InitForSelectAvecFiltreDeBase(
m_typeElementAssocie,
"Libelle",
filtre,
true);
m_selectElementSupervise.ElementSelectionne = m_entiteEditee.ElementSupervise as CObjetDonnee;
if (m_typeElementAssocie == typeof(CSite))
{
m_selectElementSupervise.ElementSelectionne = m_lastSite;
}
if (m_typeElementAssocie == typeof(CEquipementLogique))
{
m_selectElementSupervise.ElementSelectionne = m_lastEquipement;
}
if (m_typeElementAssocie == typeof(CLienReseau))
{
m_selectElementSupervise.ElementSelectionne = m_lastLien;
}
}
}
/// //////////////////////////////////////////////////////////
private void ItemFiltreClick(object sender, EventArgs e)
{
if (!(sender is CMenuItemFiltre))
{
return;
}
CFiltreDynamiqueInDb filtreInDb = ((CMenuItemFiltre)sender).Filtre;
CFiltreDynamique filtreDyn = filtreInDb.Filtre;
CFiltreData filtreData = CFormFiltreDynamic.GetFiltreData(filtreDyn);
if (filtreData == null)
{
return;
}
CListeObjetsDonnees listeSel = new CListeObjetsDonnees(CSc2iWin32DataClient.ContexteCourant, m_typeLien.TypeElements);
filtreData = CFiltreData.GetAndFiltre(filtreData, m_typeLien.FiltreDataAssocie);
listeSel.Filtre = filtreData;
try
{
if (listeSel.CountNoLoad == 0)
{
CFormAlerte.Afficher(I.T("No @1 matches the filter|30089", DynamicClassAttribute.GetNomConvivial(m_typeLien.TypeElements)), EFormAlerteType.Exclamation);
return;
}
if (CFormAlerte.Afficher(I.T("You will add @1 element(s) to the selection. Continue ?|30088", listeSel.CountNoLoad.ToString()), EFormAlerteType.Question) == DialogResult.Yes)
{
CListeObjetsDonnees listeExiste = m_entreeAgenda.RelationsElementsAgenda;
listeExiste.Filtre = new CFiltreData(CRelationTypeEntreeAgenda_TypeElementAAgenda.c_champId + "=@1",
m_typeLien.Id);
listeExiste.Filtre = CFiltreData.GetAndFiltre(listeExiste.Filtre, new CFiltreData(CRelationTypeEntreeAgenda_TypeElementAAgenda.c_champId + "=@1",
m_typeLien.Id));
using (CWaitCursor waiter = new CWaitCursor())
{
foreach (CObjetDonneeAIdNumerique objet in listeSel)
{
listeExiste.Filtre = new CFiltreData(CRelationEntreeAgenda_ElementAAgenda.c_champIdElementAAgenda + "=@1",
objet.Id);
if (listeExiste.Count == 0)
{
CRelationEntreeAgenda_ElementAAgenda rel = new CRelationEntreeAgenda_ElementAAgenda(m_entreeAgenda.ContexteDonnee);
rel.CreateNewInCurrentContexte();
rel.EntreeAgenda = m_entreeAgenda;
rel.RelationTypeEntree_TypeElement = m_typeLien;
rel.ElementLie = objet;
}
}
UpdateListe();
}
}
}
catch
{
}
}
public string ToStringConvivial()
{
string strType = DynamicClassAttribute.GetNomConvivial(m_typeDotNetNatif);
if (m_bIsArray)
{
strType += "[]";
}
return(strType);
}
//-------------------------------------------------------------
private void CFormRunFormula_Load(object sender, EventArgs e)
{
Type typeObjets = m_listeObjetsAAppliquer[0].GetType();
m_txtFormule.Init(new CFournisseurGeneriqueProprietesDynamiques(),
typeObjets);
m_lblApplyTo.Text = I.T("Apply formula to @1 @2|20092",
m_listeObjetsAAppliquer.Count().ToString(),
DynamicClassAttribute.GetNomConvivial(typeObjets));
}
public void Init(CParametreRepresentationSymbole parametreSymbole,
Type typeElement)
{
m_parametreSymbole = parametreSymbole;
m_typeElement = typeElement;
m_lblTypeElement.Text = DynamicClassAttribute.GetNomConvivial(typeElement);
if (m_parametreSymbole != null)
{
m_controleDessin.InitSymbole(m_parametreSymbole.Symbole);
}
}
private void m_arbre_AfterSelect(object sender, System.Windows.Forms.TreeViewEventArgs e)
{
if (e.Node.Parent == null || !(e.Node.Parent.Tag is CDefinitionProprieteDynamique))
{
m_lblTable.Text = DynamicClassAttribute.GetNomConvivial(m_typePrincipal);
}
else
{
m_lblTable.Text = ((CDefinitionProprieteDynamique)e.Node.Parent.Tag).NomProprieteSansCleTypeChamp;
}
}
//-------------------------------------------------------------------------
public static Type SelectType(Point pt, List <Type> listeTypes, string strTitre)
{
List <CInfoClasseDynamique> lst = new List <CInfoClasseDynamique>();
foreach (Type tp in listeTypes)
{
CInfoClasseDynamique info = new CInfoClasseDynamique(tp, DynamicClassAttribute.GetNomConvivial(tp));
lst.Add(info);
}
return(SelectType(pt, lst, strTitre));
}
public static string GetLibelleTypeRessource(Type tp)
{
if (tp == typeof(timos.acteurs.CActeur))
{
return(I.T("Operator|202"));
}
else if (tp == typeof(CRessourceMaterielle))
{
return(I.T("Resource|203"));
}
return(DynamicClassAttribute.GetNomConvivial(tp));
}
private void m_arbre_BeforeExpand(object sender, TreeViewCancelEventArgs e)
{
TreeNode node = e.Node;
if (node.Nodes.Count == 1 && node.Nodes[0].Tag == null)
{
node.Nodes.Clear();
IEtapeLienReseau etape = node.Tag as IEtapeLienReseau;
if (etape != null)
{
//Trie les éléments par type
Dictionary <Type, ArrayList> dicParType = new Dictionary <Type, ArrayList>();
foreach (IElementALiensReseau elt in etape.ElementsALiensContenus)
{
ArrayList lst = null;
if (!dicParType.TryGetValue(elt.GetType(), out lst))
{
lst = new ArrayList();
dicParType[elt.GetType()] = lst;
}
if (!lst.Contains(elt))
{
lst.Add(elt);
}
}
foreach (IEtapeLienReseau etapeFille in etape.EtapesContenues)
{
ArrayList lst = null;
if (!dicParType.TryGetValue(etapeFille.GetType(), out lst))
{
lst = new ArrayList();
dicParType[etapeFille.GetType()] = lst;
}
if (!lst.Contains(etapeFille))
{
lst.Add(etapeFille);
}
}
foreach (KeyValuePair <Type, ArrayList> paire in dicParType)
{
TreeNode nodeType = new TreeNode(DynamicClassAttribute.GetNomConvivial(paire.Key));
nodeType.Tag = paire.Key;
foreach (object element in paire.Value)
{
CreateNode(element, nodeType.Nodes);
}
nodeType.BackColor = Color.LightYellow;
node.Nodes.Add(nodeType);
}
}
}
}
public bool Initialiser(object valeur)
{
try
{
m_type = (Type)valeur;
if (m_type.GetCustomAttributes(typeof(DynamicClassAttribute), false).Length == 1)
{
m_lnk.Text = DynamicClassAttribute.GetNomConvivial(m_type);
m_lnk.Enabled = true;
}
else if (m_type == typeof(string))
{
m_lnk.Text = I.T("Text|30279");
m_lnk.Enabled = false;
}
else if (m_type == typeof(int))
{
m_lnk.Text = I.T("Integer|30280");
m_lnk.Enabled = false;
}
else if (m_type == typeof(DateTime))
{
m_lnk.Text = I.T("Date|246");
m_lnk.Enabled = false;
}
else if (m_type == typeof(bool))
{
m_lnk.Text = I.T("Yes/No|30281");
m_lnk.Enabled = false;
}
else if (m_type == typeof(double))
{
m_lnk.Text = I.T("Decimal|30282");
m_lnk.Enabled = false;
}
else
{
m_lnk.Text = I.T("Unknown type|30283");
m_lnk.Enabled = false;
}
}
catch
{
m_lnk.Enabled = false;
}
Controls.Clear();
Controls.Add(m_lnk);
m_lnk.Dock = DockStyle.Fill;
m_lnk.TextAlign = ContentAlignment.MiddleLeft;
return(true);
}
//------------------------------------------------------------------------------------------
public CResultAErreur Execute(CContexteExecutionMacro contexteExecution)
{
CResultAErreur result = CResultAErreur.True;
//Initialise les valeurs des variables
foreach (KeyValuePair <string, CDbKey> kv in m_dicVariableToInitialId)
{
IVariableDynamique var = GetVariable(kv.Key);
if (var != null && kv.Value != null)
{
Type tpObjet = var.TypeDonnee.TypeDotNetNatif;
if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpObjet))
{
try
{
CObjetDonneeAIdNumerique obj = Activator.CreateInstance(tpObjet, new object[] { contexteExecution.ContexteDonnee }) as CObjetDonneeAIdNumerique;
if (obj != null && obj.ReadIfExists(kv.Value))
{
SetValeurChamp(kv.Key, obj);
}
}
catch { }
}
}
}
IVariableDynamique variable = VariableCible;
if (variable == null)
{
result.EmpileErreur("#Macro target is not specified");
return(result);
}
if (contexteExecution.Cible != null && variable.TypeDonnee.TypeDotNetNatif != contexteExecution.Cible.GetType())
{
result.EmpileErreur("#Macro must be applied on " + DynamicClassAttribute.GetNomConvivial(variable.TypeDonnee.TypeDotNetNatif));
return(result);
}
SetValeurChamp(variable.IdVariable, contexteExecution.Cible);
if (Formulaire != null)
{
if (CFormFormulairePopup.EditeElement(Formulaire, this, "MACRO"))
{
foreach (CMacroObjet macObj in Objets)
{
macObj.Execute(contexteExecution);
}
}
}
return(result);
}
//---------------------------------------------------
public override CResultAErreur RunAndSaveIfOk(CEtapeWorkflow etape)
{
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(etape);
CResultAErreur result = CResultAErreur.True;
if (m_formuleElementDeclencheur == null)
{
result.EmpileErreur(I.T("Invalid wait paramter on step @1|20091", TypeEtape.Libelle));
return(result);
}
result = m_formuleElementDeclencheur.Eval(ctxEval);
if (!result)
{
result.EmpileErreur(I.T("Invalid wait parameter on step @1|20091", TypeEtape.Libelle));
return(result);
}
if (result.Data == null)//Pas de cible, ok, on dégage
{
return(EndAndSaveIfOk(etape));
}
CObjetDonneeAIdNumerique objetCible = result.Data as CObjetDonneeAIdNumerique;
if (objetCible == null)
{
result.EmpileErreur(I.T("Can not run wait step @1 on type @2|20092",
TypeEtape.Libelle, DynamicClassAttribute.GetNomConvivial(result.Data.GetType())));
return(result);
}
CResultAErreurType <CHandlerEvenement> resH = CHandlerEvenement.CreateHandlerOnObject(
etape.ContexteDonnee,
objetCible,
ParametreDeclencheur,
"Workflow step " + TypeEtape.Id + "/" + etape.UniversalId,
etape.UniversalId);
if (!resH)
{
result.EmpileErreur(resH.Erreur);
return(result);
}
if (resH)
{
resH.DataType.EtapeWorkflowATerminer = etape;
}
return(etape.ContexteDonnee.SaveAll(true));
}
private void ShowInfos(object obj)
{
if (obj == null)
{
m_panelInfo.Visible = false;
}
CRepertoire repertoire = obj as CRepertoire;
if (repertoire != null)
{
m_imageErreur.Image = m_imagesFichiers.Images[GetIndexImageDossier(repertoire)];
m_lblTitreErreur.Text = repertoire.Nom;
m_txtErreur.Text = repertoire.InfoImport;
}
CFichier fichier = obj as CFichier;
if (fichier != null)
{
m_imageErreur.Image = m_imagesFichiers.Images[GetIndexImageFichier(fichier)];
m_lblTitreErreur.Text = fichier.Nom;
if (fichier.KeyObjetAssocie != null && fichier.TypeObjetAssocie != null)
{
m_txtErreur.Text = "Imported to ";
CObjetDonneeAIdNumerique objet = null;
if (CImportMyanmarConst.ContexteDonnee != null)
{
try
{
objet = Activator.CreateInstance(fichier.TypeObjetAssocie, new object[] { CImportMyanmarConst.ContexteDonnee }) as CObjetDonneeAIdNumerique;
if (obj != null && objet.ReadIfExists(fichier.KeyObjetAssocie))
{
m_txtErreur.Text += objet.DescriptionElement;
}
}
catch { }
}
if (objet == null && fichier.TypeObjetAssocie != null)
{
m_txtErreur.Text += DynamicClassAttribute.GetNomConvivial(fichier.TypeObjetAssocie);
}
else
{
m_txtErreur.Text += " ? ";
}
}
else
{
m_txtErreur.Text = fichier.InfoImport;
}
}
}
/// <summary>
/// Surchages de CInfoStructureDynamique
/// </summary>
/// <param name="tp"></param>
/// <param name="nDepth"></param>
/// <returns></returns>
//-----------------------------------------------------------------
public static CInfoStructureDynamique GetStructure(Type tp, int nDepth)
{
if (nDepth < 0)
{
return(null);
}
CFournisseurPropDynStd fournisseur = new CFournisseurPropDynStd(false);
ArrayList lst = new ArrayList();
foreach (CDefinitionProprieteDynamique def in fournisseur.GetDefinitionsChamps(tp, 0, null))
{
if (!def.TypeDonnee.IsArrayOfTypeNatif)
{
CInfoChampDynamique info = null;
CInfoStructureDynamique infoFils = GetStructure(def.TypeDonnee.TypeDotNetNatif, nDepth - 1);
if (infoFils != null && infoFils.Champs.Count == 0)
{
infoFils = null;
}
//Champs simples, interpretés par CInterpreteurTextePropriete
if (def.GetType() == typeof(CDefinitionProprieteDynamique))
{
info = new CInfoChampDynamique(
def.Nom,
def.TypeDonnee.TypeDotNetNatif,
def.NomPropriete,
def.Rubrique,
infoFils);
}
else
{
CStringSerializer serializer = new CStringSerializer(ModeSerialisation.Ecriture);
I2iSerializable obj = (I2iSerializable)def;
serializer.TraiteObject(ref obj);
info = new CInfoChampDynamique(
def.Nom,
def.TypeDonnee.TypeDotNetNatif,
"~#" + serializer.String + "~@#@",
def.Rubrique,
infoFils);
}
lst.Add(info);
}
}
CInfoStructureDynamique infoStructure = new CInfoStructureDynamique();
infoStructure.NomConvivial = DynamicClassAttribute.GetNomConvivial(tp);
infoStructure.Champs = lst;
return(infoStructure);
}
//////////////////////////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CDossierSuivi DossierSuivi = (CDossierSuivi)objet;
if (DossierSuivi.Libelle == "")
{
result.EmpileErreur(I.T("Workbook label should not be empty|306"));
}
if (DossierSuivi.TypeDossier == null)
{
result.EmpileErreur(I.T("The Worbook Type connot be null|307"));
}
else
if (DossierSuivi.ElementSuivi != null && DossierSuivi.TypeDossier.TypeSuivi != null &&
!DossierSuivi.ElementSuivi.GetType().Equals(DossierSuivi.TypeDossier.TypeSuivi))
{
result.EmpileErreur(I.T("Workbook linked element is not of the expected type (@1)|308",
DynamicClassAttribute.GetNomConvivial(DossierSuivi.TypeDossier.TypeSuivi)));
}
CRelationDossierSuivi_ChampCustomServeur relServeur = new CRelationDossierSuivi_ChampCustomServeur(IdSession);
foreach (CRelationDossierSuivi_ChampCustom rel in CNettoyeurValeursChamps.RelationsChampsNormales(DossierSuivi))
{
CResultAErreur resultTmp = relServeur.VerifieDonnees(rel);
if (!resultTmp)
{
result.Erreur.EmpileErreurs(resultTmp.Erreur);
result.SetFalse();
}
}
Hashtable m_tableRelationsToElements = new Hashtable();
foreach (CRelationDossierSuivi_Element relElement in DossierSuivi.RelationsElements)
{
m_tableRelationsToElements[relElement.RelationParametre_TypeElement.Id] = true;
}
return(result);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Workbook data error|309"));
}
return(result);
}
//------------------------------------------------------
private void FillTypes()
{
List <CCustomizableListItem> items = new List <CCustomizableListItem>();
foreach (Type tp in CContexteDonnee.GetAllTypes())
{
CCustomizableListItem item = new CCustomizableListItem();
item.Tag = tp;
items.Add(item);
}
items.Sort((x, y) => DynamicClassAttribute.GetNomConvivial((Type)x.Tag).CompareTo(DynamicClassAttribute.GetNomConvivial((Type)y.Tag)));
m_wndListeTypes.Items = items.ToArray();
m_wndListeTypes.Refill();
}
