//-------------------------------------------------------------------------------
//Optimisation : l'entité pour sup n'est créée qu'une seul fois lors d'appels multiples
public CResultAErreur ReadChampSnmp(int nIdChampCustom, CInterrogateurSnmp dynamicAgent, ref CEntiteSnmpPourSupervision ettPourSup)
{
CResultAErreur result = CResultAErreur.True;
CResultAErreurType <string> resOID = GetFieldOIDWithEntitePourSupervision(nIdChampCustom, ettPourSup);
if (!resOID)
{
result.EmpileErreur(resOID.Erreur);
return(result);
}
string strOID = resOID.DataType;
ISnmpData valeur = dynamicAgent.Get(strOID) as ISnmpData;
CRelationEntiteSnmp_ChampCustom relChamp = CUtilElementAChamps.GetRelationToChamp(this, nIdChampCustom) as CRelationEntiteSnmp_ChampCustom;
if (relChamp != null)
{
if (valeur == null)
{
relChamp.LastSnmpValue = null;
}
else
{
relChamp.LastSnmpValue = valeur.ConvertToTypeDotNet();
}
}
result.Data = valeur != null?valeur.ConvertToTypeDotNet() : null;
return(result);
}
public static CResultAErreurType <CCamusatQowisioData> StaticTraiteDataRowFromCsv(CContexteDonnee contexte, string strCsvRow)
{
CResultAErreurType <CCamusatQowisioData> result = new CResultAErreurType <CCamusatQowisioData>();
result.Result = true;
CCamusatQowisioData newData = new CCamusatQowisioData(contexte);
newData.CreateNewInCurrentContexte();
CResultAErreur resTmp = CResultAErreur.True;
resTmp = newData.TraiteDataRowFromCsv(strCsvRow);
if (!resTmp && newData.IsNew())
{
newData.CancelCreate();
}
if (!resTmp)
{
result.Erreur = resTmp.Erreur;
}
else
{
result.DataType = newData;
}
return(result);
}
//-----------------------------------------------------------------------------------------------------
private void m_menuCreateStep_Click(object sender, EventArgs e)
{
CEtapeWorkflow etape = EtapeSelectionnee;
if (etape == null)
{
using (CContexteDonnee ctx = new CContexteDonnee(m_workflowRacine.ContexteDonnee.IdSession, true, false))
{
CWorkflow wkf = m_stackWorkflows.Peek();
if (wkf != null)
{
wkf = wkf.GetObjetInContexte(ctx) as CWorkflow;
CResultAErreurType <CEtapeWorkflow> res = wkf.CreateOrGetEtapeInCurrentContexte(TypeEtapeSelectionnee);
if (!res)
{
CFormAlerte.Afficher(res.Erreur);
return;
}
CResultAErreur result = ctx.SaveAll(true);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
}
}
}
}
////////////////////////////////////////////////////////////////////////
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 <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 <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 CResultAErreur AppliqueTo(CEtapeWorkflow etape, bool bIsRedemarrage)
{
CResultAErreur result = CResultAErreur.True;
if (!bIsRedemarrage || RecalculerAffectationsSurRedemarrage)
{
CResultAErreurType <CAffectationsEtapeWorkflow> resAff = Affectations.CalculeAffectations(etape.Workflow);
if (!resAff)
{
result.EmpileErreur(resAff.Erreur);
return(result);
}
etape.Affectations = resAff.DataType;
}
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(etape);
if (FormuleInitialisation != null)
{
if (!bIsRedemarrage || ReevaluerInitialisationSurRedemarrage)
{
result = FormuleInitialisation.Eval(ctx);
}
}
return(result);
}
//-------------------------------------------------------------------------------------
public CResultAErreurType <CDataTableFastSerialize> GetDataDirect(CDataHotelQuery query)
{
CResultAErreurType <CDataTableFastSerialize> res = new CResultAErreurType <CDataTableFastSerialize>();
res.DataType = CDataRoomManager.Instance.GetData(query);
return(res);
}
//-------------------------------------------------------
private void m_menuWalk_Click(object sender, EventArgs e)
{
IDefinition definition = GetCurrent();
if (definition != null)
{
if (m_connexion == null)
{
if (!SetupConnexion())
{
return;
}
}
CResultAErreurType <IList <Variable> > result = m_connexion.Walk(definition.GetNumericalForm());
if (!result)
{
CFormAfficheErreur.Show(result.Erreur);
}
else
{
CFormViewSNMPResult.ViewResult("Walk " + definition.Name,
result.DataType,
this,
definition.Tree);
}
}
}
//----------------------------------
public void GetSNMP()
{
IDefinition definition = GetCurrent();
if (definition != null)
{
if (m_connexion == null)
{
if (!SetupConnexion())
{
return;
}
}
List <uint> lstOID = new List <uint>(definition.GetNumericalForm());
lstOID.Add(0);
CResultAErreurType <Variable> result = m_connexion.Get(lstOID.ToArray());
if (!result)
{
CFormAfficheErreur.Show(result.Erreur);
}
else
{
CFormViewSNMPResult.ViewResult("Get " + definition.Name,
result.DataType,
this,
definition.Tree);
}
}
}
/// <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);
}
private CResultAErreur PrepareImport(
ref CConfigMappagesSmartImport config,
ref DataTable tableSource)
{
CResultAErreur result = CResultAErreur.True;
CResultAErreurType <CConfigMappagesSmartImport> resConfig = m_ctrlSetup.GetConfigFinale();
if (!resConfig)
{
result.EmpileErreur(resConfig.Erreur);
return(result);
}
config = resConfig.DataType;
if (m_sessionImport.TableSource != null)
{
tableSource = m_sessionImport.TableSource;
}
else if (m_parametreLectureFichier != null)
{
result = m_parametreLectureFichier.LectureFichier(m_strNomFichierExemple);
if (!result)
{
return(result);
}
tableSource = result.Data as DataTable;
}
return(result);
}
//-----------------------------------------------------------------
private void m_btnOk_Click(object sender, EventArgs e)
{
CResultAErreur result = CResultAErreur.True;
if (m_txtColumnName.Text.Trim().Length == 0)
{
result.EmpileErreur(I.T("Column name should not be empty|20049"));
}
CResultAErreurType <IDataHotelCalcul> res = null;
if (m_editeurEnCours != null)
{
res = m_editeurEnCours.GetCalcul();
if (!res)
{
result.EmpileErreur(res.Erreur);
}
}
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
if (res != null)
{
m_colonne.Calcul = res.DataType;
}
m_colonne.ColumnName = m_txtColumnName.Text.Trim();
DialogResult = DialogResult.OK;
Close();
}
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 <CObjetDonneeAIdNumeriqueAuto> CloneObjet(CObjetDonneeAIdNumeriqueAuto objetSource)
{
CResultAErreurType <CObjetDonneeAIdNumeriqueAuto> resObjet = new CResultAErreurType <CObjetDonneeAIdNumeriqueAuto>();
CResultAErreur result = CResultAErreur.True;
Dictionary <CObjetDonneeAIdNumeriqueAuto, CObjetDonneeAIdNumeriqueAuto> dicClones = new Dictionary <CObjetDonneeAIdNumeriqueAuto, CObjetDonneeAIdNumeriqueAuto>();
resObjet = CloneObjet(objetSource.ContexteDonnee, objetSource, dicClones);
if (!resObjet)
{
return(resObjet);
}
Dictionary <object, object> copie = new Dictionary <object, object>();
foreach (KeyValuePair <CObjetDonneeAIdNumeriqueAuto, CObjetDonneeAIdNumeriqueAuto> kv in dicClones)
{
copie[kv.Key] = kv.Value;
}
foreach (CObjetDonneeAIdNumeriqueAuto objet in dicClones.Values)
{
if (objet.GetType().GetCustomAttributes(typeof(RefillAfterCloneAttribute), true).Length > 0)
{
RefillAfterCloneAttribute.RefillAfterClone(objet, copie);
}
}
return(resObjet);
}
//-------------------------------------------------------
public CResultAErreur GetDatas(CListeQuerySource sources)
{
CResultAErreur result = CResultAErreur.True;
if (m_bUseCache && m_tableCache != null && Query != null && Query.UseRuntimeCache)
{
result.Data = m_tableCache;
return(result);
}
result = GetDatasHorsCalculees(sources);
DataTable table = result.Data as DataTable;
if (result && table != null)
{
AddDonneesCalculees(table);
}
if (m_postFilter != null && table != null)
{
CResultAErreurType <DataTable> resTable = m_postFilter.FiltreData(table, Query, sources);
if (!resTable)
{
result.EmpileErreur(resTable.Erreur);
return(result);
}
table = resTable.DataType;
result.Data = table;
}
if (m_bUseCache && table != null)
{
m_tableCache = table;
}
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);
}
//-----------------------------------------------------------------------------------------------------
private void m_menuStartStep_Click(object sender, EventArgs e)
{
CEtapeWorkflow etape = EtapeSelectionnee;
CWorkflow wkf = m_stackWorkflows.Peek();
using (CContexteDonnee ctx = new CContexteDonnee(wkf.ContexteDonnee.IdSession, true, false))
{
wkf = wkf.GetObjetInContexte(ctx) as CWorkflow;
CTypeEtapeWorkflow typeEtape = TypeEtapeSelectionnee;
if (etape != null)
{
typeEtape = etape.TypeEtape;
}
CResultAErreurType <CEtapeWorkflow> resEtape = wkf.CreateOrGetEtapeInCurrentContexte(typeEtape);
if (!resEtape)
{
CFormAlerte.Afficher(resEtape.Erreur);
return;
}
etape = resEtape.DataType;
etape = etape.GetObjetInContexte(ctx) as CEtapeWorkflow;
etape.InternalSetInfosDemarrageInCurrentContext();
CResultAErreur result = ctx.SaveAll(true);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
}
Refresh();
}
}
public CResultAErreurType <CAffectationsEtapeWorkflow> CalculeAffectations(CWorkflow workflow)
{
CResultAErreurType <CAffectationsEtapeWorkflow> resultAff = new CResultAErreurType <CAffectationsEtapeWorkflow>();
resultAff.Result = true;
CAffectationsEtapeWorkflow affectations = new CAffectationsEtapeWorkflow();
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(workflow);
foreach (CFormuleNommee formule in Formules)
{
CResultAErreur result = formule.Formule.Eval(ctx);
if (result)
{
if (result.Data is IAffectableAEtape)
{
affectations.AddAffectable(result.Data as IAffectableAEtape);
}
else if (result.Data is IEnumerable)
{
foreach (object obj in (IEnumerable)result.Data)
{
IAffectableAEtape a = obj as IAffectableAEtape;
if (a != null)
{
affectations.AddAffectable(a);
}
}
}
}
}
resultAff.DataType = affectations;
return(resultAff);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(Process);
result = FormuleElementACloner.Eval(ctx);
if (!result)
{
return(result);
}
CObjetDonneeAIdNumeriqueAuto obj = result.Data as CObjetDonneeAIdNumeriqueAuto;
if (obj == null)
{
result.EmpileErreur(I.T("Erreur while cloning object : source is null|20049"));
return(result);
}
CResultAErreurType <CObjetDonneeAIdNumeriqueAuto> resultClone = OptionsClonage.CloneObjet(obj);
/*
*
* Dictionary<CObjetDonneeAIdNumeriqueAuto, CObjetDonneeAIdNumeriqueAuto> dicClones = new Dictionary<CObjetDonneeAIdNumeriqueAuto, CObjetDonneeAIdNumeriqueAuto>();
* result = CloneObjet(contexte.ContexteDonnee, obj, dicClones);
* if (!result)
* return result;
*
* Dictionary<object,object> copie = new Dictionary<object,object>();
* foreach ( KeyValuePair<CObjetDonneeAIdNumeriqueAuto, CObjetDonneeAIdNumeriqueAuto> kv in dicClones )
* copie[kv.Key] = kv.Value;
* foreach (CObjetDonneeAIdNumeriqueAuto objet in dicClones.Values)
* {
* if (objet.GetType().GetCustomAttributes(typeof(RefillAfterCloneAttribute), true).Length > 0)
* {
* RefillAfterCloneAttribute.RefillAfterClone(objet, copie);
* }
* }*/
if (!resultClone)
{
result.EmpileErreur(resultClone.Erreur);
}
if (resultClone && VariableResultat != null)
{
if (VariableResultat != null)
{
Process.SetValeurChamp(VariableResultat, resultClone.DataType);
}
}
CLienAction[] liens = GetLiensSortantHorsErreur();
if (liens.Length > 0)
{
result.Data = liens[0];
}
return(result);
}
public CResultAErreur DémarreWorkflow(CTypeEtapeWorkflow typeEtapeDebut, bool bStartImmediate)
{
CSessionClient session = CSessionClient.GetSessionForIdSession(ContexteDonnee.IdSession);
IInfoUtilisateur info = session != null?session.GetInfoUtilisateur() : null;
if (info != null)
{
//TESTDBKEYOK
KeyManager = info.KeyUtilisateur;
}
CResultAErreur result = CResultAErreur.True;
if (EtapesEnCours.Count != 0)
{
result.EmpileErreur(I.T("Workflow was already started|20073"));
return(result);
}
if (typeEtapeDebut == null ||
typeEtapeDebut.Workflow != TypeWorkflow//cas pourri : l'étape de début n'est pas valide pour ce workflow ça ne doit pas arriver
)
{
if (TypeWorkflow == null)
{
result.EmpileErreur(I.T("Workflow type should be set before it starts|20077"));
return(result);
}
typeEtapeDebut = TypeWorkflow.EtapeDemarrageDefaut;
if (typeEtapeDebut == null)
{
result.EmpileErreur(I.T("Workflow type @1 doesn't have any start point|20074",
TypeWorkflow != null?TypeWorkflow.Libelle:"???"));
return(result);
}
}
using (CContexteDonnee ctx = new CContexteDonnee(ContexteDonnee.IdSession, true, false))
{
///Si bStartImmediate, travaille dans un contexte spécifique qui est sauvé tout de suite
CContexteDonnee contexteDeTravail = bStartImmediate ? ctx : ContexteDonnee;
CWorkflow wkf = GetObjetInContexte(contexteDeTravail) as CWorkflow;
typeEtapeDebut = typeEtapeDebut.GetObjetInContexte(contexteDeTravail) as CTypeEtapeWorkflow;
CResultAErreurType <CEtapeWorkflow> resEtape = wkf.CreateOrGetEtapeInCurrentContexte(typeEtapeDebut);
if (resEtape)
{
CEtapeWorkflow etape = resEtape.DataType;
etape.DemandeDemarrageInCurrentContext(null);
}
else
{
result.EmpileErreur(resEtape.Erreur);
}
IsRunning = true;
RunGeneration++;
if (result && bStartImmediate)
{
result = ctx.SaveAll(true);
}
}
return(result);
}
//-----------------------------------------------------------------------------------
public CResultAErreurType <CCAMLQuery> MajChamps()
{
CResultAErreurType <CCAMLQuery> res = new CResultAErreurType <CCAMLQuery>();
m_query.RootItem = GetRootItem();
res.DataType = m_query;
return(res);
}
public CResultAErreur RecalculeParametresHotelPolling()
{
//Trouve le setup system
List <CSnmpHotelPollingSetup> lstSetups = ParametresHotelPollingList;
CSnmpHotelPollingSetup setup = null;
foreach (CSnmpHotelPollingSetup s in lstSetups)
{
if (s.Id.StartsWith(CSnmpHotelPollingSetup.c_IdPollingSystem))
{
setup = s;
break;
}
}
if (setup == null)
{
CMemoryDb db = new CMemoryDb();
setup = new CSnmpHotelPollingSetup(db);
setup.CreateNew();
setup.Id = CSnmpHotelPollingSetup.c_IdPollingSystem + sc2i.common.CUniqueIdentifier.GetNew();
setup.Libelle = "System";
setup.HotelPort = CSnmpPollingHotelClient.HotelPollingServerPort;
lstSetups.Add(setup);
}
if (setup.HotelPort == 0)
{
setup.HotelPort = CSnmpPollingHotelClient.HotelPollingServerPort;
}
if (setup.HotelIp == null || setup.HotelIp.Length == 0)
{
setup.HotelIp = CSnmpPollingHotelClient.HotelPollingServerIp;
}
CListeSnmpHotelPolledData lstPolled = setup.PolledDatas;
lstPolled.Clear();
CResultAErreur result = CResultAErreur.True;
foreach (CEntiteSnmp entite in EntitesSnmp)
{
CResultAErreurType <IEnumerable <CSnmpHotelPolledData> > res = entite.GetSnmpHotelPolledData();
if (!res)
{
result.EmpileErreur(res.Erreur);
result.EmpileErreur(I.T("Error in entity @1|20259", entite.Libelle));
}
else if (res.DataType is IEnumerable <CSnmpHotelPolledData> )
{
foreach (CSnmpHotelPolledData data in res.DataType)
{
lstPolled.Add(data);
}
}
}
setup.PolledDatas = lstPolled;
CommitParametresHotelPolling();
return(result);
}
//--------------------------------------------------------------------------
public static CResultAErreur LinkProjetToWorkflowStep(CProjet projet,
CWorkflow workflow,
string strTypeEtape,
bool bSynchronizeStarts)
{
CResultAErreur result = CResultAErreur.True;
CTypeEtapeWorkflow typeEtape = new CTypeEtapeWorkflow(projet.ContexteDonnee);
if (!typeEtape.ReadIfExists(new CFiltreData(CObjetDonnee.c_champIdUniversel + "=@1",
strTypeEtape)))
{
result.EmpileErreur(I.T("Workflow step type @1 doesn't exists|20196", strTypeEtape));
return(result);
}
if (typeEtape.Workflow.Id != workflow.TypeWorkflow.Id)
{
result.EmpileErreur(I.T("Workflow step type @1 doesn't belong to workflow type @2|20197"),
strTypeEtape, workflow.TypeWorkflow.Libelle);
return(result);
}
CBlocWorkflowProjet blocProjet = typeEtape.Bloc as CBlocWorkflowProjet;
if (blocProjet == null)
{
result.EmpileErreur(I.T("Step type @1 is not a valid project step|20198",
typeEtape.Libelle));
return(result);
}
CResultAErreurType <CEtapeWorkflow> resEtape = workflow.CreateOrGetEtapeInCurrentContexte(typeEtape);
if (!resEtape)
{
result.EmpileErreur(resEtape.Erreur);
return(result);
}
if (resEtape.DataType == null)
{
result.EmpileErreur(I.T("Erreur while creating step for type '@1'|20199",
typeEtape.Libelle));
return(result);
}
CWorkflow sousWkf = blocProjet.GetOrCreateWorkflowInCurrentContexte(resEtape.DataType);
if (sousWkf == null)
{
result.EmpileErreur(I.T("Erreur while creating workflow for stef @1|20200",
resEtape.DataType.Libelle));
return(result);
}
sousWkf.SetValeurChamp(blocProjet.IdChampProjet.Value, projet);
projet.GanttId = blocProjet.GetGanttId(resEtape.DataType);
return(SynchroniseWorkflow(
sousWkf,
projet,
projet.DateDebutReel != null && projet.DateFinRelle == null,
bSynchronizeStarts));
}
//-------------------------------------------------------------------
private void m_lnkImportMibs_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
OpenFileDialog dlg = new OpenFileDialog();
dlg.Filter = I.T("Mib files (*.mib)|*.mib|All files (*.*)|*.*|20255");
if (dlg.ShowDialog() == DialogResult.OK)
{
try
{
StreamReader reader = new StreamReader(dlg.FileName, System.Text.Encoding.Default);
CResultAErreurType <IList <IModule> > resultModules = CSnmpMibModule.CompileFile(reader);
reader.Close();
if (resultModules)
{
using (CContexteDonnee ctx = CSc2iWin32DataClient.ContexteCourant.GetContexteEdition())
{
CListeObjetDonneeGenerique <CSnmpMibModule> lstModules = new CListeObjetDonneeGenerique <CSnmpMibModule>(ctx);
lstModules.AssureLectureFaite();
lstModules.InterditLectureInDB = true;
foreach (IModule module in resultModules.DataType)
{
//Cherche le module dans la liste des modules
lstModules.Filtre = new CFiltreData(CSnmpMibModule.c_champModuleId + "=@1",
module.Name);
if (lstModules.Count == 0)
{
CSnmpMibModule mib = new CSnmpMibModule(ctx);
mib.CreateNewInCurrentContexte();
mib.ModuleId = module.Name;
mib.ModuleMib = module;
mib.Libelle = module.Name;
}
}
CResultAErreur result = ctx.CommitEdit();
if (!result)
{
CFormAfficheErreur.Show(result.Erreur);
}
else
{
m_panelListe.RemplirGrille();
}
}
}
else
{
CFormAfficheErreur.Show(resultModules.Erreur);
}
}
catch (Exception ex)
{
CResultAErreur result = CResultAErreur.True;
result.EmpileErreur(new CErreurException(ex));
CFormAfficheErreur.Show(result.Erreur);
}
}
}
//--------------------------------------------------------------------------
private CResultAErreur StartOrRestartProjet(CEtapeWorkflow etape)
{
CResultAErreur result = CResultAErreur.True;
CResultAErreurType <CProjet> resProjet = CGestionnaireProjetsDeWorkflow.AssureProjetRunnable(etape, this);
if (!resProjet)
{
result.EmpileErreur(resProjet.Erreur);
return(result);
}
CProjet projet = resProjet.DataType;
if (projet == null)
{
return(result);
}
if (etape.DateDebut == null)
{
etape.DateDebut = DateTime.Now;
}
if (projet.ProjetsFils.Count == 0)
{
if (projet.DateDebutReel == null || GererIteration)
{
projet.DateDebutReel = etape.DateDebut.Value;
projet.DateFinRelle = null;
}
else if (!projet.HasOptionLienEtape(EOptionLienProjetEtape.StepKeepDates))
{
projet.DateDebutReel = etape.DateDebut.Value;
projet.DateFinRelle = null;
}
}
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(etape);
foreach (CAffectationsProprietes affectation in AffectationsCreationEtDemarrage)
{
bool bAppliquer = affectation.FormuleCondition == null || affectation.FormuleCondition is C2iExpressionVrai;
if (affectation.FormuleCondition != null)
{
CResultAErreur res = affectation.FormuleCondition.Eval(ctxEval);
if (res && res.Data != null && CUtilBool.BoolFromString(res.Data.ToString()) == true)
{
bAppliquer = true;
}
}
if (bAppliquer)
{
affectation.AffecteProprietes(projet, etape, new CFournisseurPropDynStd());
}
}
System.Console.WriteLine("Démarrage projet " + projet.Libelle);
return(result);
}
public string GetFieldOID(int nIdChampCustom)
{
CResultAErreurType <string> res = GetFieldOIDWithEntitePourSupervision(nIdChampCustom, null);
if (res)
{
return(res.DataType);
}
return(null);
}
//-------------------------------------------------------
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);
}
}
