public static void AutoexecInit()
{
lock (typeof(CGestionnaireDonneesQowisio))
{
if (m_bAutoexecDone)
{
return;
}
m_bAutoexecDone = true;
}
m_bTraitementEnCours = true;
CTimosServeur.OnMajStructureBaseEvent += new EventHandler(CTimosServeur_OnMajStructureBaseEvent);
string strAppData = AppDataPath;
if (!Directory.Exists(strAppData))
{
Directory.CreateDirectory(strAppData);
}
C2iEventLog.WriteInfo(strAppData);
// Récupère le nom du dernier fichier traité
CDataBaseRegistrePourClient registreClient = new CDataBaseRegistrePourClient(0);
CContexteDonneeServeur.AddTraitementAvantSauvegarde(new TraitementSauvegardeExterne(TraitementAvantSauvegardeExterne));
}
//-------------------------------------------------------------------
public static void Autoexec()
{
if (C2iAppliServeur.GetValeur(c_cleDesactivation) == null)
{
m_timer = new Timer(new TimerCallback(OnTachePlanifiee), null, 4 * 60000, 60000);
C2iEventLog.WriteInfo("Gestionnaire d'évenements sur date démarré");
}
}
//-------------------------------------------------------------------
public CResultAErreur ExecuteTache(int nIdIntervention, IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
CTachePlanifiee tache = new CTachePlanifiee(contexte);
if (!tache.ReadIfExists(nIdIntervention))
{
result.EmpileErreur(I.T("The Planned Task '@1' does not exist|338", nIdIntervention.ToString()));
return(result);
}
int nNbErreurs = 0;
C2iEventLog.WriteInfo(I.T("Starting planned task @1|339", tache.Libelle), NiveauBavardage.PetiteCausette);
int nNbFait = 0;
string strErreur = "";
foreach (CRelationTachePlanifieeProcess rel in tache.RelationsProcess)
{
if (indicateur != null)
{
indicateur.SetInfo(I.T("Action @1|340", rel.Process.Libelle));
}
CInfoDeclencheurProcess infoDeclencheur = new CInfoDeclencheurProcess(TypeEvenement.Date);
result = CProcessEnExecutionInDb.StartProcess(rel.Process.Process, infoDeclencheur, IdSession, null, null);
if (!result)
{
result.EmpileErreur(I.T("Action @1|341", rel.Process.Libelle));
strErreur += Environment.NewLine;
strErreur += result.Erreur.ToString() + Environment.NewLine + "-------------------------------------" + Environment.NewLine;
nNbErreurs++;
result = CResultAErreur.True;
}
nNbFait++;
if (indicateur != null)
{
indicateur.SetValue(nNbFait);
}
}
foreach (CRelationTachePlanifieeTypeDonneeCumulee relData in tache.RelationsTypesDonneesCumulees)
{
result = relData.TypeDonneeCumulee.StockResultat(indicateur);
if (!result)
{
result.EmpileErreur(I.T("Cumulated data @1|342", relData.TypeDonneeCumulee.Libelle));
strErreur += result.Erreur.ToString() + "\r\n-------------------------------------\r\n";
nNbErreurs++;
result = CResultAErreur.True;
}
}
C2iEventLog.WriteInfo(I.T("End of planned task @1, @2 error(s)|343", tache.Libelle, nNbErreurs.ToString()), NiveauBavardage.PetiteCausette);
return(result);
}
}
///////////////////////////////////////////////
public void CloseSession()
{
string strMessage = I.T("Closing session @1|110", IdSession.ToString());
try
{
strMessage += " " + GetInfoUtilisateur().NomUtilisateur;
}
catch
{
}
CAuthentificationSessionSousSession authSousSession = m_authentification as CAuthentificationSessionSousSession;
if (authSousSession != null)
{
ISessionClientSurServeur sessionPrinc = CGestionnaireSessions.GetSessionClientSurServeurStatic(authSousSession.IdSessionPrincipale);
if (sessionPrinc != null)
{
sessionPrinc.RemoveSousSession(this);
}
}
C2iEventLog.WriteInfo(strMessage, NiveauBavardage.VraiPiplette);
int nIdSession = IdSession;
DateTime dt = DateTime.Now;
MyCloseSession();
TimeSpan sp = DateTime.Now - dt;
Console.WriteLine("SessionServeur closing " + nIdSession + " / 1 : " + sp.TotalMilliseconds);
CGestionnaireObjetsAttachesASession.OnCloseSession(IdSession);
sp = DateTime.Now - dt;
Console.WriteLine("SessionServeur closing " + nIdSession + " / 2 : " + sp.TotalMilliseconds);
CGestionnaireSessions.CloseSession(this);
sp = DateTime.Now - dt;
Console.WriteLine("SessionServeur closing " + nIdSession + " / 3 : " + sp.TotalMilliseconds);
CGestionnaireObjetsAttachesASession.OnCloseSession(IdSession); //Si jamais le close sessino a réaloué des éléments
sp = DateTime.Now - dt;
Console.WriteLine("SessionServeur closing " + nIdSession + " / 4 : " + sp.TotalMilliseconds);
m_sponsor.Unregister(m_sessionSurClient);
sp = DateTime.Now - dt;
Console.WriteLine("SessionServeur closing " + nIdSession + " / 5 : " + sp.TotalMilliseconds);
m_sessionSurClient = null;
}
/// ///////////////////////////////////////////////////
public CResultAErreur ReconnecteSession(CSessionClient sessionSurClient)
{
CResultAErreur result = CResultAErreur.True;
ISessionClientSurServeur sessionSurServeur = GetSessionClientSurServeur(sessionSurClient.IdSession);
if (sessionSurServeur != null)
{
sessionSurClient.SessionSurServeur = sessionSurServeur;
return(result);
}
result = CanOpenSession(sessionSurClient);
if (result)
{
sessionSurServeur = GetNewSessionSurServeur(sessionSurClient, result.Data);
result.Data = null;
if (sessionSurServeur == null)
{
result.EmpileErreur(I.T("Server session allocation impossible|105"));
}
else
{
sessionSurClient.SessionSurServeur = sessionSurServeur;
lock (typeof(CLockerListeSessions))
{
m_listeSessions[sessionSurClient.IdSession] = sessionSurServeur;
}
string strMessage = I.T("Session Reconnection n°|111") + sessionSurClient.IdSession +
"\r\n" + I.T("Type|107") + sessionSurClient.TypeApplicationCliente.ToString();
strMessage += I.T("\r\n|108") + sessionSurServeur.DescriptionApplicationCliente;
try
{
strMessage += I.T("\r\n|108") + sessionSurClient.GetInfoUtilisateur().NomUtilisateur;
}
catch
{ }
C2iEventLog.WriteInfo(strMessage, NiveauBavardage.VraiPiplette);
CDonneeNotificationConnection donnee = new CDonneeNotificationConnection(sessionSurClient.IdSession, true);
CEnvoyeurNotification.EnvoieNotifications(new IDonneeNotification[] { donnee });
}
}
return(result);
}
public int Compare(object x, object y)
{
try
{
object val1, val2;
if (((DataRow)x).RowState == DataRowState.Deleted ||
((DataRow)y).RowState == DataRowState.Deleted)
{
return(0);
}
val1 = ((DataRow)x)[m_strColonne];
val2 = ((DataRow)y)[m_strColonne];
if (val1 is IComparable && val2 is IComparable)
{
return(((IComparable)val1).CompareTo((IComparable)val2));
}
if (val1.Equals(val2))
{
return(0);
}
return(-1);
}
catch (Exception ex)
{
object val1, val2;
val1 = ((DataRow)x)[m_strColonne];
val2 = ((DataRow)y)[m_strColonne];
string strInfosDebug = "DEBUG_OOREDOO" + Environment.NewLine;
strInfosDebug += "Error in Compare function" + Environment.NewLine;
strInfosDebug += "Val1 = " + val1.ToString() + Environment.NewLine;
strInfosDebug += "Val2 = " + val2.ToString() + Environment.NewLine;
C2iEventLog.WriteInfo(strInfosDebug);
}
return(0);
}
/// ///////////////////////////////////////////////////
public static void NettoieSessions(object state)
{
try
{
StringBuilder blInfo = new StringBuilder();
blInfo.Append("Sessions cleaning : " + DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss") + "\r\n");
foreach (DictionaryEntry entry in new ArrayList(m_listeSessions))
{
try
{
int nIdSession = (int)entry.Key;
blInfo.Append("Session ");
blInfo.Append(nIdSession);
CSessionClientSurServeur sessionServeur = (CSessionClientSurServeur)entry.Value;
CSessionClient session = CSessionClient.GetSessionForIdSession(nIdSession);
bool bIsConnected = false;
try
{
bIsConnected = session.IsConnected;
if (bIsConnected)
{
sessionServeur.DateHeureLastTestSessionClientSuccess = DateTime.Now;
}
}
catch
{
blInfo.Append("/Disconnected from client/");
}
if (session == null || !bIsConnected)
{
TimeSpan sp = DateTime.Now - sessionServeur.DateHeureLastTestSessionClientSuccess;
if (sp.TotalMinutes > LifetimeServices.SponsorshipTimeout.Minutes)
{
blInfo.Append("/Closing/");
C2iEventLog.WriteInfo("Loose " + nIdSession + " Automatic disconnect", NiveauBavardage.PetiteCausette);
try
{
sessionServeur.CloseSession();
}
catch
{
CloseSession(sessionServeur);
}
blInfo.Append("/Closed/");
}
}
else
{
blInfo.Append("/active/");
}
blInfo.Append(Environment.NewLine);
}
catch {
blInfo.Append("ERROR \r\n");
}
}
C2iEventLog.WriteInfo(blInfo.ToString(), NiveauBavardage.VraiPiplette);
}
catch {}
}
//-------------------------------------------------------------------
public static void Autoexec()
{
m_timer = new Timer(new TimerCallback(OnTachePlanifiee), null, c_nDelaiTachePlanifiee, c_nDelaiTachePlanifiee);
C2iEventLog.WriteInfo(I.T("Planned Task Manager started|331"));
}
protected virtual CResultAErreur UpdateTable(CStructureTable structure, ArrayList strChampsAutorisesANull)
{
CResultAErreur result = CResultAErreur.True;
ArrayList champsCrees = new ArrayList();
DataTable dt = GetDataTableForUpdateTable(structure);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#region M.A.J des champs de la table
string strNomTable = structure.NomTableInDb;
foreach (CInfoChampTable champ in structure.Champs)
{
bool bExists = false;
bool bModifiedType = false;
bool bModifiedNotNull = false;
bool bModifiedLength = false;
bool bModifiedIndex = false;
if (strChampsAutorisesANull.Contains(champ.NomChamp))
{
champ.NullAuthorized = true;
}
// 1 - Verification d'existance de la colonne et des modifs à faire si elle existe
foreach (DataColumn colonne in dt.Columns)
{
if (champ.NomChamp == colonne.ColumnName)
{
bModifiedType = Champ_ModifiedType(champ, colonne);
bModifiedLength = Champ_ModifiedLength(champ, colonne);
bModifiedNotNull = Champ_ModifiedNotNull(champ, colonne, strChampsAutorisesANull);
bModifiedIndex = Champ_ModifiedIndex(strNomTable, champ);
bExists = true;
break;
}
}
// 2 - Creation d'une colonne inexistante
if (!bExists)
{
result = CreateChamp(structure.NomTableInDb, champ);
if (result)
{
champsCrees.Add(champ.NomChamp);
}
}
// 3 - Modification d'une colonne
else if (bModifiedType || bModifiedNotNull || bModifiedLength)
{
result = UpdateChamp(strNomTable, champ, bModifiedNotNull, bModifiedLength, bModifiedType);
}
if (!result)
{
return(result);
}
if (bModifiedIndex)
{
if (champ.IsIndex)
{
result = CreateIndex(strNomTable, false, champ.NomChamp);
}
else
{
result = DeleteIndex(strNomTable, champ.NomChamp);
}
if (!result)
{
return(result);
}
}
}
// Suppression d'une colonne de la table
foreach (DataColumn colonne in dt.Columns)
{
bool bExists = false;
foreach (CInfoChampTable info in structure.Champs)
{
if (info.NomChamp == colonne.ColumnName)
{
bExists = true;
break;
}
}
if (!bExists)
{
//SC le 17082009 : Plus de suppression automatique de colonne
//Par UpdateTable. Pour supprimer une colonne, il faut utiliser une opération
//de suppression de colonne
C2iEventLog.WriteInfo("Field " + colonne.ColumnName + " in table " + structure.NomTableInDb + " should be deleted");
//result = DeleteChamp(structure.NomTableInDb, colonne.ColumnName);
if (!result)
{
return(result);
}
}
}
#endregion
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#region M.A.J des contraintes de la table
List <CInfoRelation> relationsActuelles = new List <CInfoRelation>();
result = GetRelationsExistantes(strNomTable, ref relationsActuelles);
if (!result)
{
return(result);
}
List <CInfoRelation> relationsVoulues = new List <CInfoRelation>();
foreach (CInfoRelation r in structure.RelationsParentes)
{
if (r.IsInDb)
{
relationsVoulues.Add(r);
}
}
List <CInfoRelation> nouvellesRelations = GetRelationsInnexistantes(relationsActuelles, relationsVoulues);
List <CInfoRelation> relationsObseletes = GetRelationsInnexistantes(relationsVoulues, relationsActuelles);
foreach (CInfoRelation rel in nouvellesRelations)
{
foreach (string strChampFils in rel.ChampsFille)
{
if (strChampsAutorisesANull.Contains(strChampFils))
{
rel.Obligatoire = false;
}
}
string strRequeteRelation = GetRequeteCreateCleEtrangere(rel);
result = Connection.RunStatement(strRequeteRelation);
if (result)
{
AfterChangeContraintes(CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille));
}
string strNomTableFilleInDb = CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille);
if (result && rel.Indexed)
{
result = CreateIndex(strNomTableFilleInDb, rel.IsClustered, rel.ChampsFille);
if (result)
{
AfterChangeIndexs(CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille));
}
}
if (!result)
{
result.EmpileErreur(I.T("Error while creating foreign key of @1 table (@2)|127", structure.NomTableInDb, strRequeteRelation));
return(result);
}
}
foreach (CInfoRelation rel in relationsObseletes)
{
string strNomTableFilleInDb = CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille);
result = DeleteIndex(strNomTableFilleInDb, rel.ChampsFille);
string strRequeteRelation = GetRequeteDeleteClefEtrangere(rel);
result = Connection.RunStatement(strRequeteRelation);
if (result)
{
AfterChangeContraintes(strNomTableFilleInDb);
}
if (!result)
{
result.EmpileErreur(I.T("Error while deleting foreign key of @1 table (@2)|212", structure.NomTableInDb, strRequeteRelation));
return(result);
}
}
//Vérification des indexs des relations
foreach (CInfoRelation rel in relationsVoulues)
{
if (!nouvellesRelations.Contains(rel))
{
string strNomTableFilleInDb = CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille);
if (rel.Indexed)
{
result = CreateIndex(strNomTableFilleInDb, rel.IsClustered, rel.ChampsFille);
}
else if (ShouldDeleteIndexRelation(strNomTableFilleInDb, rel))
{
result = DeleteIndex(strNomTableFilleInDb, rel.ChampsFille);
}
if (!result)
{
return(result);
}
}
}
//Gestion des attributs Index sur la classe
foreach (CInfoIndexTable info in structure.IndexSupplementaires)
{
result = CreateIndex(strNomTable, info.IsCluster, info.Champs);
if (!result)
{
return(result);
}
}
#endregion
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
return(result);
}
//------------------------------------------------------------------------
private void ExecuteEtape(CParametresStartEtapeInPile parametreStart)
{
//C2iEventLog.WriteInfo("DEBUG_TODO - ExecuteEtape()");
List <CDonneeNotificationWorkflow> lstNotifications = new List <CDonneeNotificationWorkflow>();
//TESTDBKEYTODO
if (parametreStart.KeyUtilisateur != null)
{
m_session.ChangeUtilisateur(parametreStart.KeyUtilisateur);
}
try
{
using (CContexteDonnee ctx = new CContexteDonnee(m_session.IdSession, true, false))
{
CResultAErreur result = CResultAErreur.True;
CEtapeWorkflow etape = new CEtapeWorkflow(ctx);
//C2iEventLog.WriteInfo("DEBUG_TODO - ExecuteEtape() - etape.ReadIfExists(" + parametreStart.IdEtape + ")");
if (etape.ReadIfExists(parametreStart.IdEtape))
{
//C2iEventLog.WriteInfo("DEBUG_TODO - ExecuteEtape() OK étape existe Id = " + parametreStart.IdEtape);
result = etape.InternalSetInfosDemarrageInCurrentContext();
//C2iEventLog.WriteInfo("DEBUG_TODO - etape.InternalSetInfosDemarrageInCurrentContext() Id = " + parametreStart.IdEtape);
etape.EtatCode = (int)EEtatEtapeWorkflow.Démarrée;
result = ctx.SaveAll(true);
//C2iEventLog.WriteInfo("DEBUG_TODO - ctx.SaveAll(true) Id = " + parametreStart.IdEtape + " - result = " + result.Result);
if (result)
{
//C2iEventLog.WriteInfo("DEBUG_TODO - before InternalRunAndSaveifOk() Id = " + parametreStart.IdEtape);
result = etape.InternalRunAndSaveifOk();
//C2iEventLog.WriteInfo("DEBUG_TODO - after InternalRunAndSaveifOk() Id = " + parametreStart.IdEtape);
}
else
{
C2iEventLog.WriteInfo("DEBUG_TODO - InternalRunAndSaveifOk() - Erreur : " + result.MessageErreur);
}
if (result && etape.CodeAffectations.Length > 0 && etape.DateFin == null)
{
CDonneeNotificationWorkflow donneeWorkflow = new CDonneeNotificationWorkflow(
m_session.IdSession,
etape.Id,
etape.Libelle,
etape.CodeAffectations,
etape.TypeEtape.ExecutionAutomatique);
lstNotifications.Add(donneeWorkflow);
// Déclenche l'evenement spécifique au démarrage de l'étape
result = etape.EnregistreEvenement(CEtapeWorkflow.c_codeEvenementOnRunStep, true);
//C2iEventLog.WriteInfo("DEBUG_TODO - ExecuteEtape() - etape.EnregistreEvenement()");
}
if (!result)
{
NoteErreurSurEtape(etape, result.MessageErreur);
return;
}
//C2iEventLog.WriteInfo("DEBUG_TODO - ExecuteEtape() - Fin traitement étape Id = " + parametreStart.IdEtape);
}
}
}
catch (Exception e)
{
C2iEventLog.WriteErreur("DEBUG_TODO - ExecuteEtape() - Exception executing step Id = " + parametreStart.IdEtape + Environment.NewLine + e.Message);
}
if (lstNotifications != null)
{
CEnvoyeurNotification.EnvoieNotifications(lstNotifications.ToArray());
}
}
//-------------------------------------------------------------------
public static void Autoexec()
{
m_timer = new Timer(new TimerCallback(OnRetrieveMails), null, c_nDelaiEnvoi, 1000 * 60);
C2iEventLog.WriteInfo(I.T("Receive Mails Service started|10000"));
}
//-------------------------------------------------------------------
public static void Autoexec()
{
m_timer = new Timer(new TimerCallback(OnSendSMS), null, c_nDelaiEnvoi, 1000 * 60);
C2iEventLog.WriteInfo(I.T("SMS service started|20158"));
}
