public void PutElementInCache(CObjetDonneeAIdNumerique objet)
{
if (objet != null)
{
m_cache.AddElement(objet);
}
}
//---------------------------------------------------------------------
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);
}
}
}
/// //////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CParametreSynchronisationInDb parametre = (CParametreSynchronisationInDb)objet;
if (parametre.Libelle.Trim() == "")
{
result.EmpileErreur(I.T("The parameter name cannot be empty|129"));
}
if (parametre.Code.Trim() == "")
{
result.EmpileErreur(I.T("The parameter code cannot be empty|130"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(parametre, CParametreSynchronisationInDb.c_champCode, parametre.Code))
{
result.EmpileErreur(I.T("Another parameter with this code already exist|131"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//------------------------------------------------------------
public CResultAErreur GetValue(object objet, string strPropriete)
{
CResultAErreur result = CResultAErreur.True;
CObjetDonneeAIdNumerique objetDonnee = objet as CObjetDonneeAIdNumerique;
if (objetDonnee == null)
{
return(result);
}
//traduit la propriété : Id du type | Numéro de clé
int nIdType = -1;
int nNumCle = -1;
try
{
string[] strProps = strPropriete.Split('|');
nIdType = Int32.Parse(strProps[0]);
nNumCle = Int32.Parse(strProps[1]);
}
catch
{
result.EmpileErreur(I.T("Bad cumulated data field @1|20026", strPropriete));
return(result);
}
CTypeDonneeCumulee type = new CTypeDonneeCumulee(objetDonnee.ContexteDonnee);
if (!type.ReadIfExists(nIdType))
{
result.EmpileErreur(I.T("Cumulated data type @1 doesn't exists|20027", nIdType.ToString()));
return(result);
}
result.Data = type.GetDonneesCumuleesForObjet(objetDonnee);
return(result);
}
public bool UpdateFromPhysicalAgent(bool bDeleteUnexistingEntities)
{
BeginEdit();
CResultAErreur result = InitEntitesFromSnmpInContexteCourant();
if (!result)
{
CancelEdit();
return(false);
}
if (bDeleteUnexistingEntities)
{
CListeObjetsDonnees lstEntites = EntitesSnmp;
lstEntites.Filtre = new CFiltreData(CEntiteSnmp.c_champFromSnmp + "=@1", false);
result = CObjetDonneeAIdNumerique.Delete(lstEntites, true);
if (!result)
{
CancelEdit();
return(false);
}
}
result = CommitEdit();
if (!result)
{
CancelEdit();
}
return(result.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);
}
/// //////////////////////////////////////////////////////
private void ValideModifsDroitEnCours()
{
if (m_lastNodeAffiche == null || !(m_lastNodeAffiche.Relation != null) || m_bLockEdition)
{
return;
}
CObjetDonneeAIdNumerique[] select = new CObjetDonneeAIdNumerique[m_listeExtensions.CheckedItems.Count];
for (int n = 0; n < select.Length; n++)
{
select[n] = ((CObjetDonneeAIdNumerique)m_listeExtensions.CheckedItems[n].Tag);
}
m_lastNodeAffiche.Relation.ListeObjetsOption = select;
for (int nOption = 0; nOption < m_wndListeOptions.Items.Count; nOption++)
{
COptionDroitUtilisateur option = (COptionDroitUtilisateur)m_wndListeOptions.Items[nOption];
if (m_wndListeOptions.CheckedItems.Contains(option))
{
m_lastNodeAffiche.Relation.AddOption(option.Option);
}
else
{
m_lastNodeAffiche.Relation.RemoveOption(option.Option);
}
}
}
/// <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);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CGrilleGenerique grille = (CGrilleGenerique)objet;
if (grille.Libelle.Trim() == "")
{
result.EmpileErreur(I.T("Grid label cannot be empty|317"));
}
//Controler que le libellé est unique pour le type
if (!CObjetDonneeAIdNumerique.IsUnique(grille, CGrilleGenerique.c_champLibelle, grille.Libelle))
{
result.EmpileErreur(I.T("Another Grid has the same label|318"));
}
if (grille.Code.Trim() != "")
{
if (!CObjetDonneeAIdNumerique.IsUnique(grille, CGrilleGenerique.c_champCode, grille.Code))
{
result.EmpileErreur(I.T("Another Grid has the same code|319"));
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CTypeEquipementLogique typeEquipementLogique = (CTypeEquipementLogique)objet;
if (typeEquipementLogique.Libelle == "")
{
result.EmpileErreur(I.T("Logical equipment type label cannot be empty|20006"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(typeEquipementLogique, CTypeEquipementLogique.c_champLibelle, typeEquipementLogique.Libelle))
{
result.EmpileErreur(I.T("This logical equipment type label already exists|20007"));
}
if (typeEquipementLogique.Famille == null)
{
result.EmpileErreur(I.T("The logical equipment type must be associated to a family|20008"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
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);
}
/// //////////////////////////////////////////
///<summary>
///Ajoute les nouveaux éléments à partir du domaine Secondaire
///</summary>
public CResultAErreur AjouteNouveaux(CContexteDonneesSynchroSecondaire donneesSecondaires)
{
CResultAErreur result = CResultAErreur.True;
ArrayList lst = donneesSecondaires.GetTablesOrderInsert();
DataTable tableEntreesLog = donneesSecondaires.GetTableSafe(CEntreeLogSynchronisation.c_nomTable);
foreach (DataTable table in lst)
{
if (m_mappeurTablesToClass.IsSynchronisable(table.TableName))
{
//int nIdMaxInSecondaire = (int)table.ExtendedProperties[CContexteDonneesSynchroSecondaire.c_extMaxIdInBase];
//int nIdMaxInMain = (int)table.ExtendedProperties[CContexteDonneesSynchroSecondaire.c_extMaxIdInBase];
int nNextId = 0; //Math.Max(nIdMaxInMain, nIdMaxInSecondaire)+1;
DataTable tableDest = Tables[table.TableName];
DataView view = new DataView(tableEntreesLog);
string strFiltre = CEntreeLogSynchronisation.c_champTable + "='" + table.TableName + "'";
view.RowFilter = strFiltre;
foreach (DataRowView row in view)
{
CEntreeLogSynchronisation entree = new CEntreeLogSynchronisation(row.Row);
if (entree.TypeModif == CEntreeLogSynchronisation.TypeModifLogSynchro.tAdd)
{
CObjetDonneeAIdNumerique obj = entree.GetObjet();
DataRow newRow = CopieToNew(obj.Row, tableDest, nNextId);
nNextId++;
m_mapOldRowToNewRow[obj.Row.Row] = newRow;
m_tableAjouts[table.TableName + "_" + obj.Id] = "";
}
}
}
}
return(result);
}
private void item_Click(object sender, EventArgs e)
{
if (sender is CMenuItemAfractionIntervention)
{
CMenuItemAfractionIntervention item = (CMenuItemAfractionIntervention)sender;
if (CFormAlerte.Afficher(I.T("Retake the data '@1' ?|30188", item.Text), EFormAlerteType.Question) == DialogResult.Yes)
{
CIntervention intervention = new CIntervention(ElementEdite.ContexteDonnee);
if (intervention.ReadIfExists(new CFiltreData(CIntervention.c_champId + "=@1", item.Id)))
{
CObjetDonneeAIdNumerique.Delete(intervention.Operations);
Hashtable mapDonnees = new Hashtable();
CListeObjetsDonnees donneesToCopie = intervention.Operations;
//donneesToCopie.Filtre = new CFiltreData ( COperation.c_champIdDonneeParente+" is null" );
foreach (COperation operation in donneesToCopie)
{
COperation newDonnee = (COperation)operation.Clone(false);
mapDonnees[operation.Id] = newDonnee;
if (operation.OperationParente != null)
{
newDonnee.OperationParente = (COperation)mapDonnees[operation.OperationParente.Id];
}
else
{
newDonnee.OperationParente = null;
}
newDonnee.Intervention = intervention;
}
Init(intervention);
}
}
}
}
//////////////////////////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CTypeEntreeAgenda typeEntree = (CTypeEntreeAgenda)objet;
if (typeEntree.Libelle == "")
{
result.EmpileErreur(I.T("Diary entry type label should not be empty|347"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(typeEntree, CTypeEntreeAgenda.c_champLibelle, typeEntree.Libelle))
{
result.EmpileErreur(I.T("Another type of diary entry already has this label|249"));
}
return(result);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Diary entry type data error|348"));
}
return(result);
}
/// //////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CGroupeUtilisateursSynchronisation groupe = (CGroupeUtilisateursSynchronisation)objet;
if (groupe.Libelle.Trim() == "")
{
result.EmpileErreur(I.T("The group name cannot be empty|124"));
}
if (groupe.Code.Trim() == "")
{
result.EmpileErreur(I.T("The group code cannot be empty|123"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(groupe, CGroupeUtilisateursSynchronisation.c_champCode, groupe.Code))
{
result.EmpileErreur(I.T("Another group with this code already exist|122"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
private void ShowMenuDetail(bool bSupprimer)
{
m_bIsMenuSupprimer = bSupprimer && m_extModeEdition.ModeEdition;
if (Quantite != null)
{
foreach (ToolStripItem dis in new ArrayList(m_menuDetail.Items))
{
m_menuDetail.Items.Remove(dis);
dis.Dispose();
}
int nIndex = 0;
foreach (CRelationBesoinQuantite_Element rel in Quantite.RelationsElementsSelectionnes)
{
CObjetDonneeAIdNumerique objet = rel.Element;
if (objet != null)
{
CObjetDonneeMenuItem item = new CObjetDonneeMenuItem(
objet,
rel,
objet.DescriptionElement,
false);
if (bSupprimer && m_extModeEdition.ModeEdition)
{
item.Image = Resources.delete;
}
item.Click += new EventHandler(itemElement_Click);
m_menuDetail.Items.Insert(nIndex++, item);
}
}
m_menuDetail.Show(m_btnEdit, new Point(0, m_btnEdit.Height));
}
}
///////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CChampCalcule champ = (CChampCalcule)objet;
if (champ.Nom == "")
{
result.EmpileErreur(I.T("The calculated field name cannot be empty|105"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(champ, CChampCalcule.c_champNom, champ.Nom))
{
result.EmpileErreur(I.T("A calculated field with this name already exist|106"));
}
if (champ.TypeObjets == null)
{
result.EmpileErreur(I.T("The associated object type with the calculated field is false|107"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------
void itemElement_Click(object sender, EventArgs e)
{
CObjetDonneeMenuItem item = sender as CObjetDonneeMenuItem;
if (item != null)
{
CRelationBesoinQuantite_Element rel = item.ObjetToEdit as CRelationBesoinQuantite_Element;
if (rel != null && rel.Element != null)
{
if (m_bIsMenuSupprimer)
{
if (MessageBox.Show(I.T("Remove @1 from selection|20641", rel.Element.DescriptionElement),
"",
MessageBoxButtons.YesNo,
MessageBoxIcon.Question) == DialogResult.Yes)
{
rel.Delete(true);
InitChamps(CurrentItem);
}
}
else
{
CObjetDonneeAIdNumerique objet = rel.Element.GetObjetInContexte(sc2i.win32.data.CSc2iWin32DataClient.ContexteCourant) as CObjetDonneeAIdNumerique;
CTimosApp.Navigateur.EditeElement(objet, false, "");
}
}
}
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CModeleTexte modele = (CModeleTexte)objet;
if (modele.Libelle.Trim() == "")
{
result.EmpileErreur(I.T("Text Model label cannot be empty|321"));
}
//Controler que le libellé est unique pour le type
if (!CObjetDonneeAIdNumerique.IsUnique(modele, CModeleTexte.c_champLibelle, modele.Libelle))
{
result.EmpileErreur(I.T("Another model has the same label|322"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CUniteCoordonnee uniteCoordonnee = (CUniteCoordonnee)objet;
if (uniteCoordonnee.Libelle == "")
{
result.EmpileErreur(I.T("The label of the unit cannot be empty|174"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(uniteCoordonnee, CUniteCoordonnee.c_champLibelle, uniteCoordonnee.Libelle))
{
result.EmpileErreur(I.T("The unit '@1' already exists|173", uniteCoordonnee.Libelle));
}
if (uniteCoordonnee.Abreviation == "")
{
result.EmpileErreur(I.T("The abbreviation of the unit cannot be empty|175"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(uniteCoordonnee, CUniteCoordonnee.c_champAbreviation, uniteCoordonnee.Abreviation))
{
result.EmpileErreur(I.T("The abbreviation '@1' already exists|176", uniteCoordonnee.Abreviation));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
public CValeurCAVOOEntite(string strDescriptionEntite, int nIdEntite, Type tpEntite, CObjetDonneeAIdNumerique entite)
{
m_entite = entite;
m_nId = nIdEntite;
m_tpEntite = tpEntite;
m_strDescription = strDescriptionEntite;
}
///////////////////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CConsultationAlarmesEnCoursInDb consultAl = objet as CConsultationAlarmesEnCoursInDb;
if (consultAl.Libelle.Length == 0)
{
result.EmpileErreur(I.T("Consultation name should be defined|60007"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(consultAl, CConsultationAlarmesEnCoursInDb.c_champLibelle, consultAl.Libelle))
{
result.EmpileErreur(I.T("The consultation '@1' already exist|60007", consultAl.Libelle));
}
if (consultAl.Parametres.ListeColonnes.Length <= 0)
{
result.EmpileErreur(I.T("Select data to display|60010"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-----------------------------------------------------------
/// <summary>
/// Permet de modifier les affectation aux entités relationnelles
/// d'un objet. Attention, l'objet doit être en édition
/// </summary>
/// <param name="objet"></param>
/// <returns></returns>
public static bool AffecteEntites(CObjetDonneeAIdNumerique objet)
{
CFormAffectationEntitesOrganisationnelles form = new CFormAffectationEntitesOrganisationnelles();
form.m_objet = objet;
bool bResult = false;
if (form.ShowDialog() == DialogResult.OK)
{
if (form.m_bStopEditionSurSortie)
{
CResultAErreur result = form.m_objet.CommitEdit();
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
bResult = false;
}
else
{
bResult = true;
}
}
}
else
{
if (form.m_bStopEditionSurSortie)
{
form.m_objet.CancelEdit();
}
}
form.Dispose();
return(bResult);
}
//-------------------------------------------------------------------
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);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CStatutEquipement statutEquipement = (CStatutEquipement)objet;
if (statutEquipement.Libelle == "")
{
result.EmpileErreur(I.T("The Equipment Status label cannot be empty|118"));
}
if (statutEquipement.Code == "")
{
result.EmpileErreur(I.T("The Equipment Status code can not be empty|119"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(statutEquipement, CStatutEquipement.c_champLibelle, statutEquipement.Libelle))
{
result.EmpileErreur(I.T("Another equipment status with the same name already exists|120"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(statutEquipement, CStatutEquipement.c_champCode, statutEquipement.Code))
{
result.EmpileErreur(I.T("Another equipment status with the same code already exists|121"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CSequenceNumerotation SequenceNumerotation = (CSequenceNumerotation)objet;
if (SequenceNumerotation.Libelle == "")
{
result.EmpileErreur(I.T("Sequence Label cannot be empty|20175"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(SequenceNumerotation, CSequenceNumerotation.c_champLibelle, SequenceNumerotation.Libelle))
{
result.EmpileErreur(I.T("Sequence '@1' already exist|20176", SequenceNumerotation.Libelle));
}
if (SequenceNumerotation.FormatNumerotation == null)
{
result.EmpileErreur(I.T("Select a numbering format|20177"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
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);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CComportementGenerique comportement = (CComportementGenerique)objet;
if (comportement.Libelle == "")
{
result.EmpileErreur(I.T("The label of the behavior cannot be empty|102"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(comportement, CComportementGenerique.c_champLibelle, comportement.Libelle))
{
result.EmpileErreur(I.T("A behavior with this label already exists|103"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// <summary>
/// Démarre une action
/// </summary>
/// <param name="process"></param>
/// <param name="nIdSession"></param>
/// <returns></returns>
public static CResultAErreur RunEvent(IDeclencheurAction declencheur, CObjetDonneeAIdNumerique objetCible, bool bHideProgress)
{
CFormExecuteProcess form = new CFormExecuteProcess();
form.Top = 0;
form.Left = Screen.PrimaryScreen.WorkingArea.Width / 2 - form.Width / 2;
if (declencheur is IDeclencheurActionManuelle)
{
bHideProgress |= ((IDeclencheurActionManuelle)declencheur).HideProgress;
}
if (bHideProgress)
{
CInfoDeclencheurProcess infoDeclencheur = new CInfoDeclencheurProcess(TypeEvenement.Manuel);
CAppelleurFonctionAsynchrone appeleur = new CAppelleurFonctionAsynchrone();
CResultAErreur resultDefault = CResultAErreur.True;
resultDefault.EmpileErreur(I.T("Asynchronous call error @1|20149", "RunEvent"));
return(appeleur.StartFonctionAndWaitAvecCallback(declencheur.GetType(), declencheur,
"RunEvent", "", resultDefault, objetCible, infoDeclencheur, null) as CResultAErreur);
//return declencheur.RunEvent(objetCible, infoDeclencheur, null);
}
else
{
IAsyncResult res = form.m_runEvent.BeginInvoke(declencheur, objetCible,
new AsyncCallback(form.OnEndProcess), null);
form.ShowDialog(); //Bloque le code ici !
CResultAErreur result = form.m_runEvent.EndInvoke(res);
return(result);
}
}
public List <IChampPourVersion> GetChampsJournalisables(CObjetDonneeAIdNumerique objet)
{
List <IChampPourVersion> champs = new List <IChampPourVersion>();
if (objet is IElementAChamps)
{
IElementAChamps eleAChamps = (IElementAChamps)objet;
IDefinisseurChampCustom[] definisseurs = eleAChamps.DefinisseursDeChamps;
Dictionary <CChampCustom, bool> dicChamps = new Dictionary <CChampCustom, bool>();
if (definisseurs != null)
{
foreach (IDefinisseurChampCustom definisseur in definisseurs)
{
foreach (CChampCustom champ in definisseur.TousLesChampsAssocies)
{
dicChamps[champ] = true;
}
}
}
foreach (CChampCustom champ in dicChamps.Keys)
{
champs.Add(new CChampCustomPourVersion(champ));
}
}
return(champs);
}
