/// <summary>
/// Retourne l'étape de ce type pour le workflow
/// </summary>
/// <param name="workflow"></param>
/// <returns></returns>
public CResultAErreurType <CEtapeWorkflow> CreateOrGetEtapeInCurrentContexte(CTypeEtapeWorkflow typeEtape)
{
CResultAErreurType <CEtapeWorkflow> result = new CResultAErreurType <CEtapeWorkflow>();
//Vérifie que le workflow n'a pas déjà une étape de ce type
if (typeEtape == null)
{
result.EmpileErreur(I.T("Create step need a step type|20076"));
return(result);
}
//Vérifie que le workflow n'a pas déjà une étape de ce type
CEtapeWorkflow etape = GetEtapeForType(typeEtape);
bool bIsRedemarrage = true;
if (etape == null)
{
etape = new CEtapeWorkflow(ContexteDonnee);
etape.CreateNewInCurrentContexte();
etape.Workflow = this;
etape.TypeEtape = typeEtape;
bIsRedemarrage = false;
}
CResultAErreur resTmp = typeEtape.ParametresInitialisation.AppliqueTo(etape, bIsRedemarrage);
if (!resTmp)
{
result.EmpileErreur(resTmp.Erreur);
}
if (result)
{
result.DataType = etape;
}
return(result);
}
public CResultAErreurType <CParametresInitialisationEtape> MajChamps()
{
CParametresInitialisationEtape parametre = new CParametresInitialisationEtape();
CResultAErreurType <CParametresInitialisationEtape> result = new CResultAErreurType <CParametresInitialisationEtape>();
foreach (CFormuleNommee formuleNommée in m_panelFormules.GetFormules())
{
if (formuleNommée.Formule == null) //|| !typeof(IAffectableAEtape).IsAssignableFrom(formuleNommée.Formule.TypeDonnee.TypeDotNetNatif))
{
result.EmpileErreur(I.T("Formula @1 is invalid (should return an object that can be assigned to a step)|20066",
formuleNommée.Libelle));
}
}
C2iExpression formule = m_txtFormuleInitialisation.Formule;
if (formule == null && !m_txtFormuleInitialisation.ResultAnalyse)
{
result.EmpileErreur(m_txtFormuleInitialisation.ResultAnalyse.Erreur);
}
if (formule != null)
{
parametre.FormuleInitialisation = formule;
}
if (result)
{
parametre.Affectations.Formules = m_panelFormules.GetFormules();
result.DataType = parametre;
}
parametre.RecalculerAffectationsSurRedemarrage = m_chkRecalculerAffectations.Checked;
parametre.ReevaluerInitialisationSurRedemarrage = m_chkReevaluerFormuleSurRedemarrage.Checked;
return(result);
}
/// /////////////////////////////////////////////////////////
public CResultAErreurType <ObjectRegistryBase> GetMibComplete()
{
CResultAErreurType <ObjectRegistryBase> resultBase = new CResultAErreurType <ObjectRegistryBase>();
try
{
SimpleObjectRegistry registre = new SimpleObjectRegistry();
if (!LoadInRegistre(registre))
{
//Regarde s'il y a des modules manquants
string[] strDeps = DependancesManquantes;
if (strDeps.Length > 0)
{
resultBase.EmpileErreur(I.T("Can not compile this module because of missing dependancies|20254"));
}
else
{
resultBase.EmpileErreur(I.T("Can not compile this module|20255"));
}
}
else
{
resultBase.DataType = registre;
}
}
catch (Exception e)
{
resultBase.EmpileErreur(new CErreurException(e));
}
return(resultBase);
}
//------------------------------------------------
public CResultAErreurType <CObjetDonnee> GetObjetAssocie(
DataRow row,
CContexteImportDonnee contexteImport,
bool bAutoriseCreation)
{
CResultAErreurType <CObjetDonnee> resObjet = new CResultAErreurType <CObjetDonnee>();
if (Source == null)
{
return(resObjet);
}
CSourceSmartImportFixedValue sourceFixe = Source as CSourceSmartImportFixedValue;
if (sourceFixe != null)
{
CResultAErreur result = sourceFixe.GetValue(row, contexteImport);
if (!result)
{
resObjet.EmpileErreur(result.Erreur);
return(resObjet);
}
resObjet.DataType = result.Data as CObjetDonnee;
return(resObjet);
}
else if (Source is CSourceSmartImportReference)
{
resObjet.DataType = ((CSourceSmartImportReference)Source).GetValue(row, contexteImport).Data as CObjetDonnee;
return(resObjet);
}
else
{
if (m_configMappageEntiteParente != null)
{
string strFiltre = "";
resObjet = m_configMappageEntiteParente.FindObjet(row, contexteImport, null, ref strFiltre);
if (!resObjet)
{
return(resObjet);
}
if (resObjet.DataType != null || bAutoriseCreation)
{
CResultAErreur result = m_configMappageEntiteParente.ImportRow(row, contexteImport, null, false);
if (!result)
{
resObjet.EmpileErreur(result.Erreur);
return(resObjet);
}
resObjet = m_configMappageEntiteParente.FindObjet(row, contexteImport, null, ref strFiltre);
}
}
}
return(resObjet);
}
//-------------------------------------------------
public CResultAErreurType <CSnmpHotelPolledData> GetHotelPolledData(CEntiteSnmp entite)
{
CResultAErreurType <CSnmpHotelPolledData> result = new CResultAErreurType <CSnmpHotelPolledData>();
//trouve le champ
CSnmpPollingField field = new CSnmpPollingField(entite.ContexteDonnee);
if (!field.ReadIfExistsUniversalId(PollingFieldUID) ||
field.HotelTableId.Length == 0 ||
field.HotelColumnId.Length == 0)
{
result.EmpileErreur(I.T("Incorrect polling field|20256"));
return(result);
}
CSnmpHotelPolledData polledData = new CSnmpHotelPolledData();
polledData.HotelTable = field.HotelTableId;
polledData.HotelField = field.HotelColumnId;
//calcule l'id de l'entité
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(entite);
if (FormuleIdEntite == null)
{
result.EmpileErreur(I.T("Invalid entity id formula|20257"));
return(result);
}
CResultAErreur resTmp = FormuleIdEntite.Eval(ctx);
if (!resTmp || resTmp.Data == null)
{
result.EmpileErreur(I.T("Invalid entity id formula|20257"));
result.EmpileErreur(resTmp.Erreur);
return(result);
}
polledData.EntityId = resTmp.Data.ToString();
CResultAErreurType <C2iExpression> resFormule = GetFormuleFinaleForEntite(entite);
if (!resFormule || !(resFormule.Data is C2iExpression))
{
result.EmpileErreur(I.T("Error while converting Polling formula|20258"));
return(result);
}
polledData.Formule = resFormule.DataType;
result.DataType = polledData;
return(result);
}
//-------------------------------------------------------------
public CResultAErreurType <DataTable> GetTable(uint[] oid, params uint[][] colonnesAPrendre)
{
ISnmpConnexion cnxDisttante = GetConnexionDistante();
if (cnxDisttante != null)
{
return(cnxDisttante.GetTable(oid, colonnesAPrendre));
}
CResultAErreurType <DataTable> resultTable = new CResultAErreurType <DataTable>();
List <Variable> lstVars = new List <Variable>();
try
{
resultTable.DataType = Messenger.ReadTable(m_version,
m_endPoint,
new OctetString(m_strCommunity),
new ObjectIdentifier(oid),
m_nTimeOut,
colonnesAPrendre);
}
catch (Exception e)
{
resultTable.EmpileErreur(new CErreurException(e));
}
return(resultTable);
}
//-----------------------------------------------
public CResultAErreurType <IList <Variable> > Walk(uint[] oid)
{
ISnmpConnexion cnxDisttante = GetConnexionDistante();
if (cnxDisttante != null)
{
return(cnxDisttante.Walk(oid));
}
CResultAErreurType <IList <Variable> > resultList = new CResultAErreurType <IList <Variable> >();
List <Variable> lstVars = new List <Variable>();
try
{
int nResult = Messenger.Walk(m_version,
m_endPoint,
new OctetString(m_strCommunity),
new ObjectIdentifier(oid),
lstVars,
m_nTimeOut,
WalkMode.WithinSubtree);
resultList.DataType = lstVars;
}
catch (Exception e)
{
resultList.EmpileErreur(new CErreurException(e));
}
return(resultList);
}
//-----------------------------------------------
public CResultAErreurType <IList <Variable> > Get(IList <Variable> variables)
{
ISnmpConnexion cnxDisttante = GetConnexionDistante();
if (cnxDisttante != null)
{
return(cnxDisttante.Get(variables));
}
CResultAErreurType <IList <Variable> > result = new CResultAErreurType <IList <Variable> >();
try
{
IList <Variable> lst = Messenger.Get(
m_version,
m_endPoint,
new OctetString(m_strCommunity),
variables,
m_nTimeOut);
result.Data = lst;
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
public CResultAErreurType <CListeParametresInspiration> MajChamps()
{
CResultAErreur result = CResultAErreur.True;
CResultAErreurType <CListeParametresInspiration> resRetour = new CResultAErreurType <CListeParametresInspiration>();
CListeParametresInspiration lst = new CListeParametresInspiration();
if (CurrentItemIndex != null)
{
ItemControl.MajChamps();
}
foreach (CCustomizableListItem item in Items)
{
CParametreInspirationProprieteDeType parametre = item.Tag as CParametreInspirationProprieteDeType;
if (parametre != null)
{
result = parametre.VerifieDonnees();
if (!result)
{
resRetour.EmpileErreur(result.Erreur);
return(resRetour);
}
lst.Add(parametre);
}
}
resRetour.DataType = lst;
return(resRetour);
}
////////////////////////////////////////////////////////////////////////
public CResultAErreurType <List <CModifSynchronisation> > GetModifsFromVersion(
int nIdSyncStart,
int nIdSyncEnd,
CFiltresSynchronisation filtres)
{
bool bTmp = false;
CResultAErreur res = FillWithModifsFromVersion(
nIdSyncStart,
nIdSyncEnd,
ref bTmp,
filtres,
false,
true);
CResultAErreurType <List <CModifSynchronisation> > result = new CResultAErreurType <List <CModifSynchronisation> >();
if (!res)
{
result.EmpileErreur(res.Erreur);
result.Result = false;
}
else
{
result.DataType = res.Data as List <CModifSynchronisation>;
}
return(result);
}
//-----------------------------------------------------
public CResultAErreurType <ISnmpData> GetValue()
{
CResultAErreurType <ISnmpData> result = new CResultAErreurType <ISnmpData>();
if (m_txtValeur.Text.Trim().Length > 0)
{
try
{
ISnmpData data = DataFactory.CreateSnmpDataFromStringUnsafe(m_typeAttendu, m_txtValeur.Text);
result.DataType = data;
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Invalid value for @1|20114", m_lblNomVariable.Text));
}
}
return(result);
}
//-------------------------------------------------------
public static CResultAErreurType <CMacro> FromVersion(CVersionDonnees version)
{
CResultAErreurType <CMacro> result = new CResultAErreurType <CMacro>();
using (CContexteDonnee contexte = new CContexteDonnee(version.ContexteDonnee.IdSession, true, false))
{
contexte.SetVersionDeTravail(version.Id, false);
CMacro macro = new CMacro();
macro.m_contexteDonnee = version.ContexteDonnee;
macro.Libelle = version.Libelle;
CVariableDynamiqueSysteme variable = new CVariableDynamiqueSysteme();
variable.SetTypeDonnee(new CTypeResultatExpression(typeof(string), false));
variable.Nom = "CurrentElement";
variable.IdVariable = m_strIdVariableCurrentElement;
macro.AddVariable(variable);
Dictionary <int, CMacroObjet> dicMacrosObjets = new Dictionary <int, CMacroObjet>();
Dictionary <CObjetDonneeAIdNumerique, CMacroObjet> dicObjetToMacros = new Dictionary <CObjetDonneeAIdNumerique, CMacroObjet>();
foreach (CVersionDonneesObjet vo in version.VersionsObjets)
{
if (!typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(vo.TypeElement) && vo.TypeElement.GetCustomAttributes(typeof(NoMacroAttribute), true).Length == 0)
{
CMacroObjet mo = new CMacroObjet(macro);
mo.TypeObjet = vo.TypeElement;
mo.IdObjet = vo.IdElement;
mo.TypeOperation = vo.TypeOperation;
macro.AddObjet(mo);
dicMacrosObjets[vo.Id] = mo;
CObjetDonneeAIdNumerique objet = Activator.CreateInstance(vo.TypeElement, new object[] { contexte }) as CObjetDonneeAIdNumerique;
if (objet.ReadIfExists(vo.IdElement))
{
dicObjetToMacros[objet] = mo;
}
mo.CreateVariable(objet);
}
}
foreach (CVersionDonneesObjet vo in version.VersionsObjets)
{
if (!typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(vo.TypeElement) && vo.TypeElement.GetCustomAttributes(typeof(NoMacroAttribute), true).Length == 0)
{
CMacroObjet mo = dicMacrosObjets[vo.Id];
CResultAErreur resMo = CResultAErreur.True;
resMo = mo.FillFromVersion(vo, contexte, dicObjetToMacros);
if (!resMo)
{
result.EmpileErreur(resMo.Erreur);
}
}
}
result.DataType = macro;
return(result);
}
}
//-------------------------------------------------
private CResultAErreurType <C2iExpression> GetFormuleFinaleForEntite(CEntiteSnmp entite)
{
CResultAErreurType <C2iExpression> result = new CResultAErreurType <C2iExpression>();
if (m_formulePolling == null)
{
result.EmpileErreur(I.T("Can not apply formula to entity @1|20254",
entite.Libelle));
return(result);
}
C2iExpression formule = CCloner2iSerializable.Clone(m_formulePolling) as C2iExpression;
ArrayList lst = formule.ExtractExpressionsType(typeof(C2iExpressionChamp));
foreach (C2iExpressionChamp exp in lst)
{
CDefinitionProprieteDynamiqueChampCustom def = exp.DefinitionPropriete as CDefinitionProprieteDynamiqueChampCustom;
string strOID = null;
if (def != null)
{
CChampCustom champ = new CChampCustom(CContexteDonneeSysteme.GetInstance());
if (champ.ReadIfExists(def.DbKeyChamp))
{
strOID = entite.GetFieldOID(champ.Id);
if (strOID.Trim().Length == 0)
{
strOID = null;
}
else
{
exp.DefinitionPropriete = new CDefinitionProprieteDynamiqueOID(strOID);
}
}
}
if (strOID == null)
{
result.EmpileErreur(I.T("Can not find SNMP field for @1|20255", def.Nom));
return(result);
}
}
result.Data = formule;
return(result);
}
//---------------------------------------------------------------------------------------------------------
public CResultAErreurType <ISourceEntitesPourTableDataHotel> MajChamps()
{
if (m_editeurEnCours != null)
{
return(m_editeurEnCours.MajChamps());
}
CResultAErreurType <ISourceEntitesPourTableDataHotel> res = new CResultAErreurType <ISourceEntitesPourTableDataHotel>();
res.EmpileErreur(I.T("Valid source for entity must be set|20003"));
return(res);
}
//--------------------------------------------------------------------
public CResultAErreurType <ISourceEntitesPourTableDataHotel> MajChamps()
{
CResultAErreurType <ISourceEntitesPourTableDataHotel> result = new CResultAErreurType <ISourceEntitesPourTableDataHotel>();
if (!(m_cmbTable.SelectedValue is string))
{
result.EmpileErreur(I.T("Select a source table|20040"));
return(result);
}
if (!(m_cmbColonne.SelectedValue is string))
{
result.EmpileErreur(I.T("Select a source columns|20041"));
return(result);
}
m_source.IdTable = m_cmbTable.SelectedValue as string;
m_source.IdColonne = m_cmbColonne.SelectedValue as string;
result.DataType = m_source;
return(result);
}
//--------------------------------------------------
public CResultAErreurType <CColumnDeEasyQueryChampDeRequete> GetColonneIdSource()
{
CResultAErreurType <CColumnDeEasyQueryChampDeRequete> result = new CResultAErreurType <CColumnDeEasyQueryChampDeRequete>();
IODEQTableFromFramework tableSource = ElementsSource[0] as IODEQTableFromFramework;
if (tableSource == null)
{
result.EmpileErreur(I.T("Incompatible source table|20074"));
return(result);
}
Type tp = tableSource.TypeElements;
if (!typeof(IObjetDonneeAIdNumerique).IsAssignableFrom(tp))
{
result.EmpileErreur(I.T("Incompatible source table|20074"));
return(result);
}
CStructureTable structure = CStructureTable.GetStructure(tp);
HashSet <string> setIds = new HashSet <string>();
setIds.Add("#PP|" + structure.ChampsId[0].Propriete);
if (structure.ChampsId.Length == 1)
{
setIds.Add(structure.ChampsId[0].NomChamp);
}
foreach (CColumnDeEasyQueryChampDeRequete col in tableSource.ChampsDeRequete)
{
if (col.Sources.Length == 1)
{
if (setIds.Contains(col.Sources[0].Source) &&
col.OperationAgregation == OperationsAgregation.None)
{
result.Data = col;
return(result);
}
}
}
result.EmpileErreur(I.T("Source table must reference 'Id' field with 'None' operation|20075"));
return(result);
}
//-------------------------------------------------------------------------------
public CResultAErreurType <CConfigMappagesSmartImport> GetConfigFinale()
{
MajChamps();
CResultAErreurType <CConfigMappagesSmartImport> resFinal = new CResultAErreurType <CConfigMappagesSmartImport>();
if (Items.Count() == 0 || !(Items[0] is CSetupSmartImportChampEntiteItem))
{
resFinal.EmpileErreur(I.T("Can not calculate import setup|20121"));
return(resFinal);
}
CSetupSmartImportChampEntiteItem root = Items[0] as CSetupSmartImportChampEntiteItem;
CConfigMappagesSmartImport config = new CConfigMappagesSmartImport();
CResultAErreur result = root.MajConfig(config);
if (!result)
{
resFinal.EmpileErreur(result.Erreur);
return(resFinal);
}
resFinal.DataType = config;
return(resFinal);
}
//-----------------------------------------------
public CResultAErreurType <Variable> Get(uint[] oid)
{
CResultAErreurType <Variable> resultVar = new CResultAErreurType <Variable>();
ISnmpConnexion cnxDisttante = GetConnexionDistante();
if (cnxDisttante != null)
{
try
{
resultVar = cnxDisttante.Get(oid);
}
catch (Exception e)
{
resultVar.EmpileErreur(new CErreurException(e));
}
return(resultVar);
}
Variable variable = new Variable(oid);
List <Variable> lstSource = new List <Variable>();
lstSource.Add(variable);
CResultAErreurType <IList <Variable> > resultList = Get(lstSource);
if (resultList)
{
if (resultList.DataType.Count > 0)
{
resultVar.Data = resultList.DataType[0];
}
}
else
{
resultVar.EmpileErreur(resultList.Erreur);
}
return(resultVar);
}
//------------------------------------------------------------------------
public CResultAErreurType <CParametreDroitEditionType> GetParametre()
{
CResultAErreurType <CParametreDroitEditionType> result = new CResultAErreurType <CParametreDroitEditionType>();
CResultAErreur resTmp = ItemControl.MajChamps();
if (resTmp && CurrentItemIndex != null)
{
resTmp = ItemControl.MajChamps();
}
if (!resTmp)
{
result.EmpileErreur(resTmp.Erreur);
return(result);
}
CParametreDroitEditionType parametre = new CParametreDroitEditionType();
foreach (CCustomizableListItem item in Items)
{
CParametreDroitEditionType.CCoupleFormuleToGroupeRestrictions couple = item.Tag as CParametreDroitEditionType.CCoupleFormuleToGroupeRestrictions;
if (couple != null)
{
parametre.AddFormule(couple);
}
}
resTmp = parametre.VerifieDonnees();
if (!resTmp)
{
result.EmpileErreur(resTmp.Erreur);
}
else
{
result.DataType = parametre;
}
return(result);
}
public CResultAErreurType <ISourceEntitesPourTableDataHotel> MajChamps()
{
CResultAErreurType <ISourceEntitesPourTableDataHotel> result = new CResultAErreurType <ISourceEntitesPourTableDataHotel>();
if (m_txtFormule.Formule == null || !m_txtFormule.ResultAnalyse)
{
result.EmpileErreur(m_txtFormule.ResultAnalyse.Erreur);
}
else
{
m_source.FormuleEntites = m_txtFormule.Formule;
result.DataType = m_source;
}
return(result);
}
/// /////////////////////////////////////////////////////////
public static CResultAErreurType <IList <IModule> > CompileFile(TextReader textReader)
{
CResultAErreurType <IList <IModule> > result = new CResultAErreurType <IList <IModule> >();
try
{
IList <IModule> lst = Parser.Compile(textReader);
result.Data = lst;
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
private CResultAErreurType <CFichierLocalTemporaire> GetFileFromFtp(CActionCopierLocalDansGed.CParametresCopierLocalDansGed parametre)
{
CResultAErreurType <CFichierLocalTemporaire> result = new CResultAErreurType <CFichierLocalTemporaire>();
string strExt = "dat";
int nPosPoint = parametre.NomFichierLocal.LastIndexOf(".");
if (nPosPoint >= 0)
{
strExt = parametre.NomFichierLocal.Substring(nPosPoint + 1);
}
CFichierLocalTemporaire fichierTemporaireFromFTP = new CFichierLocalTemporaire(strExt);
fichierTemporaireFromFTP.CreateNewFichier();
using (FileStream streamDest = new FileStream(
fichierTemporaireFromFTP.NomFichier,
FileMode.CreateNew,
FileAccess.Write))
{
try
{
FtpWebRequest req = (FtpWebRequest)WebRequest.Create(parametre.NomFichierLocal);
req.Method = WebRequestMethods.Ftp.DownloadFile;
req.Credentials = new NetworkCredential(parametre.User, parametre.Password);
FtpWebResponse response = (FtpWebResponse)req.GetResponse();
Stream respStream = response.GetResponseStream();
byte[] buffer = new byte[256];
int nNbLus = 0;
while ((nNbLus = respStream.Read(buffer, 0, 256)) != 0)
{
streamDest.Write(buffer, 0, nNbLus);
}
respStream.Close();
respStream.Dispose();
response.Close();
response.Dispose();
result.DataType = fichierTemporaireFromFTP;
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
streamDest.Close();
}
return(result);
}
//-------------------------------------------------------------------------------
public CResultAErreurType <string> GetFieldOIDWithEntitePourSupervision(int nIdChampCustom, CEntiteSnmpPourSupervision ettPourSup)
{
CResultAErreurType <string> resString = new CResultAErreurType <string>();
CColumnDefinitionSNMP colSnmp = GetSourceColumn(nIdChampCustom);
if (colSnmp == null)
{
CChampCustom champ = new CChampCustom(ContexteDonnee);
string strChamp = nIdChampCustom.ToString();
if (champ.ReadIfExists(nIdChampCustom))
{
strChamp = champ.Nom;
}
resString.EmpileErreur(I.T("Can not find snmp source for @1|20099", strChamp));
return(resString);
}
IEnumerable <CChampEntiteFromQueryToChampCustom> lstChamps = TypeEntiteSnmp.ChampsFromQuery;
CChampEntiteFromQueryToChampCustom assocChamp = lstChamps.FirstOrDefault(c => c.IdChampCustom == nIdChampCustom);
string strOID = colSnmp.OIDString;
string strIndex = Index;
if (assocChamp != null && assocChamp.Champ.FormuleIndex != null)
{
if (ettPourSup == null)
{
ettPourSup = GetEntitePourSupervision(TypeEntiteSnmp.GetTypeEntitePourSupervision(null, false));
}
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(ettPourSup);
CResultAErreur resTmp = assocChamp.Champ.FormuleIndex.Eval(ctxEval);
if (resTmp && resTmp.Data != null)
{
strIndex = resTmp.Data.ToString();
}
}
if (strIndex.Length > 0)
{
if (!strIndex.StartsWith("."))
{
strOID += ".";
}
strOID += strIndex;
}
resString.DataType = strOID;
return(resString);
}
//-------------------------------------------------
public CResultAErreurType <IDataHotelCalcul> GetCalcul()
{
CResultAErreurType <IDataHotelCalcul> res = new CResultAErreurType <IDataHotelCalcul>();
CColumnEQFromSource col = m_cmbChampSource.SelectedValue as CColumnEQFromSource;
if (col == null)
{
res.EmpileErreur(I.T("Select a source field|20033"));
return(res);
}
IDHFiltre filtre = m_panelFiltre.MajAndGetFiltre();
m_calcul.IdChampSource = col.IdColumnSource;
m_calcul.Filtre = filtre;
res.DataType = m_calcul;
return(res);
}
//--------------------------------------------------------------------------------------
public CResultAErreurType <IPostFilter> MajChamps()
{
CResultAErreurType <IPostFilter> resPost = new CResultAErreurType <IPostFilter>();
CResultAErreur res = m_editeurParametre.MajChamps();
if (!res)
{
resPost.EmpileErreur(res.Erreur);
return(resPost);
}
m_postFilter.ParametreJointure = m_editeurParametre.Parametre;
if (m_cmbTableSource.SelectedValue is IObjetDeEasyQuery)
{
m_postFilter.SourceTableId = ((IObjetDeEasyQuery)m_cmbTableSource.SelectedValue).Id;
}
resPost.DataType = m_postFilter;
return(resPost);
}
//-------------------------------------------------------
public static CResultAErreurType <CMacro> FromVersion(CVersionDonnees version)
{
CResultAErreurType <CMacro> result = new CResultAErreurType <CMacro>();
using (CContexteDonnee contexte = new CContexteDonnee(version.ContexteDonnee.IdSession, true, false))
{
contexte.SetVersionDeTravail(version.Id, false);
CMacro macro = new CMacro();
macro.m_contexteDonnee = version.ContexteDonnee;
Dictionary <int, CMacroObjet> dicMacrosObjets = new Dictionary <int, CMacroObjet>();
Dictionary <CObjetDonneeAIdNumerique, CMacroObjet> dicObjetToMacros = new Dictionary <CObjetDonneeAIdNumerique, CMacroObjet>();
foreach (CVersionDonneesObjet vo in version.VersionsObjets)
{
CMacroObjet mo = new CMacroObjet(macro);
mo.TypeObjet = vo.TypeElement;
mo.IdObjet = vo.IdElement;
mo.TypeOperation = vo.TypeOperation;
macro.AddObjet(mo);
dicMacrosObjets[vo.Id] = mo;
CObjetDonneeAIdNumerique objet = Activator.CreateInstance(vo.TypeElement, new object[] { contexte }) as CObjetDonneeAIdNumerique;
if (objet.ReadIfExists(vo.IdElement))
{
dicObjetToMacros[objet] = mo;
}
mo.CreateVariable(objet);
}
foreach (CVersionDonneesObjet vo in version.VersionsObjets)
{
CMacroObjet mo = dicMacrosObjets[vo.Id];
CResultAErreur resMo = CResultAErreur.True;
resMo = mo.FillFromVersion(vo, contexte, dicObjetToMacros);
if (!resMo)
{
result.EmpileErreur(resMo.Erreur);
}
}
result.DataType = macro;
return(result);
}
}
//--------------------------------------------------------------------
public CResultAErreurType <CMappageIdsAlarmes> RemonteAlarmes(CMemoryDb dbContenantLesAlarmesARemonter)
{
CResultAErreurType <CMappageIdsAlarmes> result = new CResultAErreurType <CMappageIdsAlarmes>();
if (m_traiteurAlarme != null)
{
return(m_traiteurAlarme.Traite(dbContenantLesAlarmesARemonter));
}
else
{
foreach (CSnmpProxy proxy in CSnmpProxyConfiguration.GetInstance().GetProxiesPrecedents())
{
ISnmpConnexion connexion = proxy.GetConnexion();
return(connexion.RemonteAlarmes(dbContenantLesAlarmesARemonter));
}
}
result.EmpileErreur(I.T("Can not manage alarms"));
return(result);
}
//------------------------------------------------
private CResultAErreurType <CValeursImportFixe> GetValeursFixesPourFilles(CObjetDonnee parent)
{
CResultAErreurType <CValeursImportFixe> resVals = new CResultAErreurType <CValeursImportFixe>();
if (Propriete is CDefinitionProprieteDynamiqueDotNet)
{
Type tp = MappagesEntitesFilles.ElementAt(0).ConfigMappage.TypeEntite;
CDefinitionProprieteDynamique pDeFille = Propriete.GetDefinitionInverse(parent.GetType());
PropertyInfo info = tp.GetProperty(pDeFille.NomProprieteSansCleTypeChamp);
if (info != null)
{
RelationAttribute relPar = info.GetCustomAttribute <RelationAttribute>(true);
if (relPar != null)
{
CValeursImportFixe vals = new CValeursImportFixe();
for (int nChamp = 0; nChamp < relPar.ChampsFils.Length; nChamp++)
{
vals.SetValeur(relPar.ChampsFils[nChamp], parent.Row[relPar.ChampsParent[nChamp]]);
}
resVals.DataType = vals;
return(resVals);
}
}
}
if (Propriete is CDefinitionProprieteDynamiqueRelationTypeId && parent is CObjetDonneeAIdNumerique)
{
RelationTypeIdAttribute att = ((CDefinitionProprieteDynamiqueRelationTypeId)Propriete).Relation;
if (att != null)
{
CValeursImportFixe vals = new CValeursImportFixe();
vals.SetValeur(att.ChampType, parent.GetType().ToString());
vals.SetValeur(att.ChampId, ((CObjetDonneeAIdNumerique)parent).Id);
resVals.DataType = vals;
return(resVals);
}
}
resVals.EmpileErreur(I.T("Can not define parent filter for property @1|20098", Propriete.Nom));
return(resVals);
}
//-----------------------------------------------------------------------
public CResultAErreurType <CMapOldIdToNewId> IntegreModifsDeSecondaireDansMain(CContexteDonnee ctxDonnee)
{
CResultAErreurType <CMapOldIdToNewId> result = new CResultAErreurType <CMapOldIdToNewId>();
CResultAErreur resTmp = CResultAErreur.True;
EnforceConstraints = false;
resTmp = AjouteNouveauxFromSecondaire(ctxDonnee);
if (resTmp)
{
resTmp = TraiteModifiesFromSecondaire(ctxDonnee);
}
if (resTmp)
{
resTmp = DeclencheEvenementAfterSyncOnMain(this);
}
if (resTmp)
{
resTmp = SaveAll(true);
}
if (!resTmp)
{
result.EmpileErreur(resTmp.Erreur);
return(result);
}
CMapOldIdToNewId map = new CMapOldIdToNewId();
foreach (KeyValuePair <DataRow, int> kv in m_mapOldRowToOldId)
{
DataRow rowDest = null;
if (m_mapRowsFromSecondaireToMain.TryGetValue(kv.Key, out rowDest))
{
map.SetNewIdForElement(kv.Key.Table.TableName, kv.Value,
(int)rowDest[rowDest.Table.PrimaryKey[0]]);
}
}
result.DataType = map;
return(result);
}
//---------------------------------------------------------------------------------
public CResultAErreurType <IEnumerable <CSnmpHotelPolledData> > GetSnmpHotelPolledData()
{
CResultAErreurType <IEnumerable <CSnmpHotelPolledData> > result = new CResultAErreurType <IEnumerable <CSnmpHotelPolledData> >();
List <CSnmpHotelPolledData> lstData = new List <CSnmpHotelPolledData>();
if (TypeEntiteSnmp != null)
{
foreach (CSnmpPollingFieldSetup s in TypeEntiteSnmp.PollingFields.Fields)
{
CResultAErreurType <CSnmpHotelPolledData> res = s.GetHotelPolledData(this);
if (!res)
{
result.EmpileErreur(res.Erreur);
}
else if (res.DataType is CSnmpHotelPolledData)
{
lstData.Add(res.DataType);
}
}
}
result.DataType = lstData;
return(result);
}
