/// <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); }