/// /////////////////////////////////////////////////////////
protected override CResultAErreur MySerialize(C2iSerializer serializer)
{
CResultAErreur result = CResultAErreur.True;
int nVersion = GetNumVersion();
result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.MySerialize(serializer);
if (!result)
{
return(result);
}
I2iSerializable objet = m_filtreDynamique;
result = serializer.TraiteObject(ref objet, Process, Process.ContexteDonnee);
if (!result)
{
result.EmpileErreur(I.T("Filter serialisation error|154"));
return(result);
}
m_filtreDynamique = (CFiltreDynamique)objet;
if (nVersion >= 1)
{
serializer.TraiteBool(ref m_bCompterSeulement);
}
else
{
m_bCompterSeulement = false;
}
if (nVersion >= 2)
{
serializer.TraiteBool(ref m_bAppliquerFiltreParDefaut);
}
else
{
m_bAppliquerFiltreParDefaut = true;
}
return(result);
}
/// /////////////////////////////////////////////////////////
public CResultAErreur InsertDataInDataSet(
IEnumerable list,
DataSet ds,
ITableExport tableParente,
int[] nValeursCle,
RelationAttribute relationToObjetParent,
IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablePourFiltres,
CCacheValeursProprietes cacheValeurs,
ITableExport tableFilleANeParCharger,
bool bAvecOptimisation,
CConteneurIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
result.EmpileErreur(I.T("Not supported function calling : C2iTableExportCalculée.InsertDataInDataset|124"));
return(result);
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
try
{
IGestionnaireSessions gestionnaire = (IGestionnaireSessions)C2iFactory.GetNewObject(typeof(IGestionnaireSessions));
CInfoSessionAsDynamicClass[] infos = gestionnaire.GetInfosSessionsActives();
result.Data = infos;
return(result);
}
catch
{
result.EmpileErreur(I.T("Error while retrieving active sessions|20056"));
}
return(result);
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
try
{
DateTime dt = Convert.ToDateTime(valeursParametres[0]);
double fVal = Convert.ToDouble(valeursParametres[1]);
dt = dt.AddDays(fVal);
result.Data = dt;
}
catch
{
result.EmpileErreur(I.T("The parameters of the function 'AddDays' are incorrect|184"));
}
return(result);
}
/// //////////////////////////////////////////
protected override CResultAErreur ProtectedEval(CContexteEvaluationExpression ctx)
{
CResultAErreur result = CResultAErreur.True;
if (!typeof(IEnumerable).IsAssignableFrom(ctx.ObjetSource.GetType()))
{
result.EmpileErreur(I.T("The function select cannot apply to the @1 type|227", ctx.ObjetSource.GetType().ToString()));
return(result);
}
ArrayList lst = new ArrayList();
List <KeyValuePair <object, object> > lstObjValeurs = new List <KeyValuePair <object, object> >();
foreach (object obj in (IEnumerable)ctx.ObjetSource)
{
try
{
ctx.PushObjetSource(obj, true);
result = Parametres2i[0].Eval(ctx);
ctx.PopObjetSource(true);
object val = null;
if (result)
{
val = result.Data;
}
lstObjValeurs.Add(new KeyValuePair <object, object>(obj, val));
}
catch {}
}
lstObjValeurs.Sort(new CSorterListe());
foreach (KeyValuePair <object, object> kv in lstObjValeurs)
{
lst.Add(kv.Key);
}
if (Parametres2i.Length > 1)
{
result = Parametres2i[1].Eval(ctx);
if (result && result.Data is bool && !(bool)result.Data) //descending
{
lst.Reverse();
}
}
result.Data = lst;
return(result);
}
//----------------------------------------------------------
public CResultAErreur UpdateEntite(CEntiteDeMemoryDb entite)
{
CResultAErreur result = CResultAErreur.True;
if (entite.Database != this)
{
try
{
ImporteObjet(entite, true, true);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
}
return(result);
}
public override CResultAErreur VerifieDonnees(sc2i.data.CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
CSeveriteAlarme severite = objet as CSeveriteAlarme;
if (severite != null)
{
if (severite.Libelle.Trim() == string.Empty)
{
result.EmpileErreur(I.T("Alarm Severity Label connot be empty|10023"));
}
}
return(result);
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
try
{
DateTime dt = Convert.ToDateTime(valeursParametres[0]);
int nVal = Convert.ToInt32(valeursParametres[1]);
dt = new DateTime(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, nVal);
result.Data = dt;
}
catch
{
result.EmpileErreur(I.T("The parameters of the function 'SetSeconds' are incorrect|20123"));
}
return(result);
}
//-----------------------------------------------
public CResultAErreur RefreshFormuleFinale()
{
m_formuleFinale = null;
CResultAErreur result = CResultAErreur.True;
C2iExpressionBegin formule = new C2iExpressionBegin();
foreach (CDefinitionProprieteDynamiqueVariableFormule def in m_listeVariables)
{
C2iExpressionVariable var = new C2iExpressionVariable();
C2iExpression exp = new C2iExpressionChamp();
((C2iExpressionChamp)exp).DefinitionPropriete = def;
var.Parametres.Add(exp);
exp = new C2iExpressionConstante(def.TypeDonnee.TypeDotNetNatif.ToString());
var.Parametres.Add(exp);
if (def.TypeDonnee.IsArrayOfTypeNatif)
{
exp = new C2iExpressionVrai();
var.Parametres.Add(exp);
}
formule.Parametres.Add(var);
}
CRepresentationExpressionGraphique graf = StartPoint;
if (graf == null)
{
result.EmpileErreur(I.T("No start point|20103"));
return(result);
}
while (graf != null)
{
result = graf.RefreshParametres();
if (!result)
{
return(result);
}
if (graf.Formule != null)
{
formule.Parametres.Add(graf.Formule);
}
graf = graf.Next;
}
m_formuleFinale = formule;
return(CResultAErreur.True);
}
//----------------------------------------------------
private CResultAErreur SauvegardeOptimisee(CContexteDonnee ctxEdition)
{
CResultAErreur result = CResultAErreur.True;
m_sessionClient.BeginTrans();
try
{
CAlarmeServeur serveur = new CAlarmeServeur(m_sessionClient.IdSession);
serveur.TraitementAvantSauvegarde(ctxEdition);
CDonneeNotificationModificationContexteDonnee donneeNotif = new CDonneeNotificationModificationContexteDonnee(m_sessionClient.IdSession);
CListeRestrictionsUtilisateurSurType lst = new CListeRestrictionsUtilisateurSurType();
CContexteSauvegardeObjetsDonnees ctx = new CContexteSauvegardeObjetsDonnees(ctxEdition, donneeNotif, lst);
result = serveur.SaveAll(ctx, DataRowState.Modified | DataRowState.Added);
if (result)
{
CRelationAlarme_ChampCustomServeur chServeur = new CRelationAlarme_ChampCustomServeur(m_sessionClient.IdSession);
result = chServeur.SaveAll(ctx, DataRowState.Modified | DataRowState.Added);
}
if (result)
{
result = serveur.TraitementApresSauvegarde(ctxEdition, true);
}
if (result)
{
CEnvoyeurNotification.EnvoieNotifications(new IDonneeNotification[] { ctx.DonneeNotification });
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
if (result)
{
result = m_sessionClient.CommitTrans();
}
else
{
m_sessionClient.RollbackTrans();
}
}
return(result);
}
private CResultAErreur GetFileFromFtp(CActionCopierLocalDansGed.CParametresCopierLocalDansGed parametre)
{
CResultAErreur result = CResultAErreur.True;
string strExt = "dat";
int nPosPoint = parametre.NomFichierLocal.LastIndexOf(".");
if (nPosPoint >= 0)
{
strExt = parametre.NomFichierLocal.Substring(nPosPoint + 1);
}
m_fichierTemporaireFromFTP = new CFichierLocalTemporaire(strExt);
m_fichierTemporaireFromFTP.CreateNewFichier();
using (FileStream streamDest = new FileStream(
m_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();
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
streamDest.Close();
}
return(result);
}
/// ///////////////////////////////////////////
public override sc2i.common.CResultAErreur RunService(object parametre)
{
CResultAErreur result = CResultAErreur.True;
if (!(parametre is CActionSelectionFichierClient))
{
result.EmpileErreur(I.T("Bad parameter value for service Select local file|20123"));
return(result);
}
m_actionSelection = parametre as CActionSelectionFichierClient;
m_strNomFichierSelectionne = "";
CTimosApp.Navigateur.Invoke((MethodInvoker) delegate
{
ShowDialogFichier();
});
result.Data = m_strNomFichierSelectionne;
return(result);
}
//---------------------------------------------------------
public CResultAErreur MajChamps()
{
CResultAErreur result = CResultAErreur.True;
if (m_gestionnaireModeEdition.ModeEdition && m_ligneEditee != null)
{
try
{
m_ligneEditee.Libelle = m_txtLibelle.Text;
m_ligneEditee.TypeLigne = m_txtTypeLigne.ElementSelectionne as CGPSTypeLigne;
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
}
return(result);
}
//-------------------------------------------------------------------------
public CResultAErreur MajChamps()
{
CResultAErreur result = CResultAErreur.True;
if (m_plageIP != null)
{
if (IP.IsValidIP(m_txtModeleIP.Text))
{
m_plageIP.Mask = m_numMask.IntValue;
m_plageIP.ModeleIpString = m_txtModeleIP.Text;
}
else
{
result.EmpileErreur(I.T("Invalid IP Address format: @1|10204", m_txtModeleIP.Text));
}
}
return result;
}
public static CResultAErreur TryAuthentificationAD()
{
CResultAErreur result = CResultAErreur.True;
IIdentity id = GetIdentiteAD();
CSessionClient session = CSessionClient.CreateInstance();
result = session.OpenSession(new CAuthentificationSessionTimosAD(id, new CParametresLicence(GetIdsSupportAmovibles(), GetMACs())));
if (result)
{
CTimosApp.SessionClient = session;
}
else
{
result.EmpileErreur(I.T("Incorrect AD user|30020"));
}
return(result);
}
/// ///////////////////////////////////////////
public override sc2i.common.CResultAErreur RunService(object parametre)
{
CResultAErreur result = CResultAErreur.True;
if (!(parametre is IEnumerable <int>))
{
result.EmpileErreur("Bad parameter value for service Multi documents to EDM");
return(result);
}
m_listeCategories = parametre as IEnumerable <int>;
m_listeFichiersSelect = null;
CTimosApp.Navigateur.Invoke((MethodInvoker) delegate
{
ShowDialogSelect();
});
result.Data = m_listeFichiersSelect;
return(result);
}
//------------------------------------------------------------------------------
public CResultAErreur Acquitter(int nIdSession)
{
CResultAErreur result = CResultAErreur.True;
try
{
if (m_traiteurAcquittement != null)
{
result = m_traiteurAcquittement.AcquitteAlarme(Id, DateTime.Now, nIdSession);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------------
protected override CResultAErreur MAJ_Champs()
{
CResultAErreur result = base.MAJ_Champs();
Workflow.TypeWorkflow = m_txtSelectTypeWorkflow.ElementSelectionne as CTypeWorkflow;
CActeur acteur = m_txtSelectManager.ElementSelectionne as CActeur;
if (acteur == null || acteur.Utilisateur == null)
{
result.EmpileErreur(I.T("Select a manager for this workflow|20627"));
}
else
{
//TESTDBKEYOK
Workflow.KeyManager = acteur.Utilisateur.DbKey;
}
return(result);
}
//Champs Auto Incremente
internal CResultAErreur CreateTable_ChampsAutoIncrementes(CStructureTable structure)
{
CResultAErreur result = CResultAErreur.True;
foreach (CInfoChampTable info in structure.Champs)
{
if (info.IsAutoId)
{
result = CreerSystemeAutoIncremente(structure.NomTableInDb, info.NomChamp);
if (!result)
{
result.EmpileErreur(I.T("Error while creating the numbering system of the column @1 of the table @2|189", info.NomChamp, structure.NomTableInDb));
break;
}
}
}
return(result);
}
//----------------------------------------------------
public override CResultAErreur OnDeclencheSurClient( )
{
CResultAErreur result = CResultAErreur.True;
if (Objet is CObjetDonneeAIdNumerique && !IsDejaDeclenche)
{
result = Evenement.EnregistreDeclenchementEvenementSurClient((CObjetDonneeAIdNumerique)Objet, InfoDeclencheur, null);
if (result)
{
SetIsDeclenche(true);
}
else
{
result.EmpileErreur(I.T("Error in @1 event|20000", Evenement.Libelle));
}
}
return(result);
}
/// ///////////////////////////////////////////
public override sc2i.common.CResultAErreur RunService(object parametre)
{
CResultAErreur result = CResultAErreur.True;
if (!(parametre is CParametreServiceVisuListeObjets))
{
result.EmpileErreur(I.T("Parameter type is not compatible with 'Visualise list' service|1083"));
return(result);
}
m_parametreVisu = (CParametreServiceVisuListeObjets)parametre;
Thread th = new Thread(new ThreadStart(AfficheListe));
th.SetApartmentState(ApartmentState.STA);
th.Start();
th.Join();
return(m_resultEdit);
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
string strChaine, strRegEx;
strChaine = valeursParametres[0].ToString();
strRegEx = valeursParametres[1].ToString();
try
{
Regex ex = new Regex(strRegEx, RegexOptions.IgnoreCase);
result.Data = ex.IsMatch(strChaine);
}
catch
{
result.EmpileErreur(I.T("Error in the regular expression '@1'|285", strRegEx));
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
//Calcule le message
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = FormuleMessage.Eval(contexteEval);
if (!result)
{
return(result);
}
else
{
result.EmpileErreur(result.Data.ToString());
}
return(result);
}
public static CResultAErreur TryAuthentification(string strLogin, string strMdp)
{
CResultAErreur result = CResultAErreur.True;
CSessionClient session = CSessionClient.CreateInstance();
result = session.OpenSession(new CAuthentificationSessionTimosLoginPwd(strLogin, strMdp, new CParametresLicence(GetIdsSupportAmovibles(), GetMACs())));
if (result)
{
CTimosApp.SessionClient = session;
}
else
{
result.EmpileErreur(I.T("Login or password identification error|10092"));
}
return(result);
}
private void m_txtIndex_TextChanged(object sender, EventArgs e)
{
if (!m_bEdition)
{
if (m_txtIndex.Text != null && m_txtIndex.Text != "")
{
m_bEdition = true;
m_lblErr.Text = "";
m_txtReference.Text = "";
CResultAErreur result = CResultAErreur.True;
try
{
result = FormatNumerotation.GetReference(int.Parse(m_txtIndex.Text));
}
catch
{
result.EmpileErreur(I.T("Bad Index or too long|334"));
}
if (!result.Result)
{
foreach (CErreurSimple E in result.Erreur)
{
m_lblErr.Text += E.Message;
}
}
else
{
m_txtReference.Text = result.Data.ToString();
}
m_bEdition = false;
}
else
{
m_bEdition = true;
m_txtReference.Text = "";
m_bEdition = false;
}
}
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
try
{
DateTime dt1 = Convert.ToDateTime(valeursParametres[0]);
DateTime dt2 = Convert.ToDateTime(valeursParametres[1]);
TimeSpan sp = dt1 - dt2;
double fVal = 0;
switch (Convert.ToInt32(valeursParametres[2]))
{
case 0:
fVal = sp.TotalDays / 7;
break;
case 1:
fVal = sp.TotalDays;
break;
case 2:
fVal = sp.TotalHours;
break;
case 3:
fVal = sp.TotalMinutes;
break;
case 4:
fVal = sp.TotalSeconds;
break;
default:
fVal = sp.TotalDays;
break;
}
result.Data = fVal;
}
catch
{
result.EmpileErreur(I.T("The parameters of the function 'DateDiff' are incorrect|194"));
}
return(result);
}
public CResultAErreur Serialize(C2iSerializer serializer)
{
//VERSION
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strNom);
#region IDs des Types
string strIds = ChaineIDsPourFiltreSimple;
serializer.TraiteString(ref strIds);
try
{
string[] arrayStrIds = strIds.Split(',');
m_ids = new List <int>();
foreach (string strId in arrayStrIds)
{
m_ids.Add(int.Parse(strId));
}
}
catch
{
result.EmpileErreur(I.T("The reading of Types IDs in the @1 key failed|548", Nom));
return(result);
}
#endregion
//FORMULE
I2iSerializable iFormuleCle = m_formuleCle;
result = serializer.SerializeObjet(ref iFormuleCle);
if (!result)
{
return(result);
}
m_formuleCle = (C2iExpression)iFormuleCle;
return(result);
}
//Champ
public override CResultAErreur DeleteChamp_Dependances(string strNomTableInDb, string strNomChamp)
{
CResultAErreur result = CResultAErreur.True;
//Suppression des clefs etrangeres
result = DeleteChamp_ClesEtrangeres(strNomTableInDb, strNomChamp);
//Regarde les autres contraintes
string strRequeteGetForeignKey =
"SELECT obj2.name " +
"FROM dbo.sysobjects AS obj1 " +
"INNER JOIN syscolumns AS sc ON sc.id=obj1.id " +
"INNER JOIN sysconstraints AS scon ON (scon.id=obj1.id AND sc.colid=scon.colid) " +
"INNER JOIN sysobjects AS obj2 ON scon.constid=obj2.id " +
"AND obj1.name='" + strNomTableInDb + "' " +
"AND sc.name='" + strNomChamp + "'";
IDataAdapter adapter = Connection.GetSimpleReadAdapter(strRequeteGetForeignKey);
DataSet ds = new DataSet();
Connection.FillAdapter(adapter, ds);
CUtilDataAdapter.DisposeAdapter(adapter);
DataTable dt = ds.Tables[0];
foreach (DataRow row in dt.Rows)
{
string strRequeteSuppressionRelation = "ALTER TABLE " + strNomTableInDb + " DROP CONSTRAINT " + (string)row[0];
result = Connection.RunStatement(strRequeteSuppressionRelation);
if (!result)
{
result.EmpileErreur(I.T("Error while deleting constrain @1 of table @2|133", (string)row[0], strNomTableInDb));
return(result);
}
}
//Suppression des indexs
result = DeleteIndex(strNomTableInDb, strNomChamp);
return(result);
}
//------------------------------------------------------------------------
private CResultAErreur WriteRows(DataTable table, StreamWriter writer)
{
CResultAErreur result = CResultAErreur.True;
try
{
string strTempLine = "";
ArrayList lstCols = new ArrayList(table.Columns);
Regex colKeyAuto = new Regex("^Key_");
if (m_bMasquerClesAuto)
{
foreach (DataColumn col in lstCols.ToArray())
{
if (col.AutoIncrement || colKeyAuto.IsMatch(col.ColumnName))
{
lstCols.Remove(col);
}
}
}
if (!ExporteStructureOnly)
{
foreach (DataRow row in table.Rows)
{
foreach (DataColumn col in lstCols)
{
if (strTempLine != "")
{
strTempLine += SeparateurChamp;
}
strTempLine += GetValeur(row[col]);
}
writer.WriteLine(strTempLine);
strTempLine = "";
}
}
}
catch
{
result.EmpileErreur(I.T("Error while writing lines in the table @1|30005", table.TableName));
}
return(result);
}
/// //////////////////////////////////////////
/// //////////////////////////////////////////
protected override CResultAErreur ProtectedEval(CContexteEvaluationExpression ctx)
{
CResultAErreur result = CResultAErreur.True;
try
{
if (ctx.SynchronizationContext == null)//Pas déjà en background
{
CContexteEvaluationExpression ctxCopie = ctx.GetCopie();
ctxCopie.SynchronizationContext = SynchronizationContext.Current;
Thread th = new Thread(delegate()
{
try
{
foreach (C2iExpression parametre in Parametres2i)
{
parametre.Eval(ctxCopie);
}
}
catch (Exception ex)
{
}
});
th.Start();
}
else
{
foreach (C2iExpression parametre in Parametres2i)
{
result = parametre.Eval(ctx);
if (!result)
{
break;
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
