private int CreerClient(string nom, string prenom)
{
//créer un client
CActeur client = new CActeur(m_contexteDonnees);
CDonneesActeurClient donneesClient = new CDonneesActeurClient(m_contexteDonnees);
if (!client.ReadIfExists(new CFiltreData(CActeur.c_champNom + "=@1",
nom)))
{
client.CreateNewInCurrentContexte();
client.Nom = nom;
client.Prenom = prenom;
donneesClient.CreateNewInCurrentContexte();
donneesClient.Acteur = client;
}
else
{
Console.WriteLine("le client existe déjà");
return(client.Id);
}
CResultAErreur result = m_contexteDonnees.SaveAll(true);
if (!result)
{
System.Console.WriteLine(result.MessageErreur);
}
//Assert.IsTrue(result.Result);
result = m_contexteDonnees.SaveAll(true);
if (!result)
{
System.Console.WriteLine(result.MessageErreur);
}
Assert.IsTrue(result.Result);
int nId = donneesClient.Id;
CSpvClient spvClient = new CSpvClient(m_contexteDonnees);
Assert.IsTrue(spvClient.ReadIfExists(new CFiltreData(CSpvClient.c_champSmtClient_Id + "=@1", nId)));
Console.WriteLine(spvClient.CLIENT_NOM);
return(nId);
}
private void m_lnkEnseignes_LinkClicked(object sender, System.Windows.Forms.LinkLabelLinkClickedEventArgs e)
{
using (CContexteDonnee contexte = new CContexteDonnee(CTimosApp.SessionClient.IdSession, true, false))
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexte, typeof(CEntiteOrganisationnelle));
Random rnd = new Random();
for (int nNumero = 0; nNumero < 10000; nNumero++)
{
int nNbEOs = rnd.Next(liste.Count - 1);
//CTestSecurite test = new CTestSecurite(contexte);
//test.CreateNewInCurrentContexte();
//test.Libelle = "Test n°" + nNumero;
StringBuilder builder = new StringBuilder();
for (int nEO = 0; nEO < nNbEOs; nEO++)
{
int nNumEO = rnd.Next(liste.Count - 1);
CEntiteOrganisationnelle entite = (CEntiteOrganisationnelle)liste[nNumEO];
builder.Append("~");
builder.Append(entite.CodeSystemeComplet);
}
//test.EOs = builder.ToString();
}
contexte.SaveAll(true);
}
}
//-------------------------------------------------------------
public static CResultAErreur IntegreReleves(C2iSessionInventaire session,
CMemoryDb db)
{
CResultAErreur result = CResultAErreur.True;
try
{
DateTime dt = DateTime.Now;
CListeEntitesDeMemoryDb <TID.releve.CReleveSite> lstReleves = new CListeEntitesDeMemoryDb <TID.releve.CReleveSite>(db);
using (CContexteDonnee ctx = new CContexteDonnee(session.Session.IdSession, true, false))
{
foreach (TID.releve.CReleveSite releve in lstReleves)
{
result = IntegreReleve(releve, ctx);
if (!result)
{
return(result);
}
}
TimeSpan sp = DateTime.Now - dt;
Console.WriteLine(sp.TotalMilliseconds);
dt = DateTime.Now;
result = ctx.SaveAll(false);
sp = DateTime.Now - dt;
Console.WriteLine(sp.TotalMilliseconds);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//----------------------------------------------------------------------------------------------------
public CResultAErreur SendDonneesPooled(List <CDonneeCumuleeTransportable> lstDonnees)
{
CResultAErreur result = AssureSessionPolling();
if (!result)
{
return(result);
}
using (CContexteDonnee ctx = new CContexteDonnee(m_sessionPolling.IdSession, true, false))
{
foreach (CDonneeCumuleeTransportable donnee in lstDonnees)
{
CDonneeCumulee data = new CDonneeCumulee(ctx);
data.CreateNewInCurrentContexte();
if (!data.FillFromDonneeTransportable(donnee))
{
data.Delete(true);
}
}
ctx.EnableTraitementsAvantSauvegarde = false;
ctx.EnableTraitementsExternes = false;
result = ctx.SaveAll(false);
}
result.Data = null;
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();
}
}
//-----------------------------------------------------------------------------------------------------
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 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);
}
private int AssureCreerTypeSite(string libelle)
{
//créer un type de site
CTypeSite typeSite = new CTypeSite(m_contexteDonnees);
Console.WriteLine("création du type de site " + libelle);
if (!typeSite.ReadIfExists(new CFiltreData(CTypeSite.c_champLibelle + "=@1",
libelle)))
{
typeSite.CreateNewInCurrentContexte();
typeSite.Libelle = libelle;
typeSite.Commentaire = "commentaire";
}
CResultAErreur result = CResultAErreur.True;
Console.WriteLine("vérification des données");
result = typeSite.VerifieDonnees(false);
if (!result)
{
System.Console.WriteLine(result.MessageErreur);
}
Assert.IsTrue(result.Result);
Console.WriteLine("enregistrement des donnees");
m_contexteDonnees.SaveAll(true);
if (!result)
{
System.Console.WriteLine(result.MessageErreur);
}
Assert.IsTrue(result.Result);
int id = typeSite.Id;
CSpvTypsite test = new CSpvTypsite(m_contexteDonnees);
Console.WriteLine("vérification de la création du type SPV");
Assert.IsTrue(test.ReadIfExists(new CFiltreData(CSpvTypsite.c_champSmtTypeSite_Id + "=@1", id)));
Console.WriteLine("vérification du libellé");
Assert.IsTrue(test.TypeSiteNom == libelle);
Console.WriteLine("vérification du ClassId");
Assert.IsTrue(test.TypeSiteClassId == 1053);
return(id);
}
private static void ImporterChamps()
{
StreamReader reader = new StreamReader("C:\\Partage\\Import Orange\\Champs controles.txt", Encoding.Default);
string strLigne = reader.ReadLine();
strLigne = reader.ReadLine();
using (CContexteDonnee contexte = new CContexteDonnee(CSessionClient.GetSessionUnique().IdSession, true, false))
{
while (strLigne != null)
{
CRoleChampCustom roleSite = CRoleChampCustom.GetRole(CSite.c_roleChampCustom);
CRoleChampCustom roleWorkBook = CRoleChampCustom.GetRole(CDossierSuivi.c_roleChampCustom);
CRoleChampCustom roleCaracteristique = CRoleChampCustom.GetRole(CCaracteristiqueEntite.c_roleChampCustom);
string[] datas = strLigne.Split('\t');
if (datas.Length >= 1)
{
CChampCustom champ = new CChampCustom(contexte);
if (!champ.ReadIfExists(new CFiltreData(CChampCustom.c_champNom + "=@1",
datas[0])))
{
champ.CreateNewInCurrentContexte();
}
champ.Nom = datas[0];
C2iTypeDonnee tp = new C2iTypeDonnee(TypeDonnee.tString);
if (datas.Length > 1)
{
if (datas[1].ToUpper() == "BOOL")
{
tp = new C2iTypeDonnee(TypeDonnee.tBool);
}
else if (datas[1].ToUpper() == "DATE")
{
tp = new C2iTypeDonnee(TypeDonnee.tDate);
}
}
champ.TypeDonneeChamp = tp;
champ.Categorie = "";
if (datas.Length > 2)
{
champ.Categorie = datas[2];
}
CRoleChampCustom role = roleCaracteristique;
champ.Role = role;
}
strLigne = reader.ReadLine();
}
reader.Close();
CResultAErreur result = contexte.SaveAll(true);
if (!result)
{
CFormAfficheErreur.Show(result.Erreur);
}
}
}
//------------------------------------------------------------------------
private void NoteErreurSurEtape(CEtapeWorkflow etape, string strMessage)
{
using (CContexteDonnee ctx = new CContexteDonnee(etape.ContexteDonnee.IdSession, true, false))
{
etape = etape.GetObjetInContexte(ctx) as CEtapeWorkflow;
etape.EtatCode = (int)EEtatEtapeWorkflow.Erreur;
etape.LastError = strMessage;
etape.DateFin = null;
ctx.SaveAll(false);
}
}
//----------------------------------------------------------------------
public CResultAErreur UpdateValeurs(CContexteDonnee contexteDeBasePasEnEdition, IIndicateurProgression indicateurProgression)
{
if (Count == 0)
{
return(CResultAErreur.True);
}
CConteneurIndicateurProgression progress = CConteneurIndicateurProgression.GetConteneur(indicateurProgression);
CResultAErreur result = CResultAErreur.True;
//Lecture entite par entité pour optimiser la lecture
Dictionary <CEntiteSnmp, HashSet <CChampCustom> > lstChamps = new Dictionary <CEntiteSnmp, HashSet <CChampCustom> >();
progress.SetBornesSegment(0, Count);
foreach (CCoupleEntiteSnmp_Champ couple in this)
{
HashSet <CChampCustom> set = null;
if (!lstChamps.TryGetValue(couple.Entite, out set))
{
set = new HashSet <CChampCustom>();
lstChamps[couple.Entite] = set;
}
set.Add(couple.ChampCustom);
}
CSessionClient session = CSousSessionClient.GetNewSousSession(this[0].Entite.ContexteDonnee.IdSession);
session.OpenSession(new CAuthentificationSessionSousSession(this[0].Entite.ContexteDonnee.IdSession),
"SNMP", ETypeApplicationCliente.Service);
using (CContexteDonnee ctxModif = new CContexteDonnee(session.IdSession, true, false))
{
int nIndex = 1;
foreach (KeyValuePair <CEntiteSnmp, HashSet <CChampCustom> > kv in lstChamps)
{
CEntiteSnmp entite = kv.Key.GetObjetInContexte(ctxModif) as CEntiteSnmp;
CInterrogateurSnmp dynamicAgent = new CInterrogateurSnmp();
dynamicAgent.Connexion = entite.AgentSnmp.GetNewSnmpConnexion();
CEntiteSnmpPourSupervision ettSup = null;
foreach (CChampCustom champ in kv.Value)
{
int nIdChamp = champ.Id;
if (entite.ReadChampSnmp(nIdChamp, dynamicAgent, ref ettSup))
{
entite.CopieValeurSnmpDansValeurChamp(nIdChamp);
}
progress.SetValue(nIndex++);
}
}
progress.SetValue(Count);
ctxModif.SaveAll(true);
System.Threading.Thread.Sleep(2000);
session.CloseSession();
}
return(result);
}
private void m_lnkDemarrer_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
CResultAErreur result = CResultAErreur.True;
try
{
C2iStructureImport structure = m_panelStructure.GetStructureFinale();
if (structure.Mappages.Select(m => m.IsCle).Count() == 0)
{
if (MessageBox.Show(I.T("Warning, You didn't select any identification field. Continue ?|20052"),
"",
MessageBoxButtons.YesNo) == DialogResult.No)
{
return;
}
}
string strFichier = m_panelStructure.NomFichier;
using (CContexteDonnee ctx = new CContexteDonnee(CSc2iWin32DataClient.ContexteCourant.IdSession, true, false))
{
ctx.SetVersionDeTravail(CSc2iWin32DataClient.ContexteCourant.IdVersionDeTravail, false);
using (CWaitCursor waiter = new CWaitCursor())
{
result = structure.Importer(strFichier, ctx);
}
if (result)
{
DataTable table = ctx.GetTableSafe(CContexteDonnee.GetNomTableForType(structure.TypeCible));
int nNbUpdate = structure.NbUpdated;
int nNbCreate = structure.NbCreated;
if (CFormAlerte.Afficher(I.T("This opération will create @1 and update @2 elements. Do you confirm this operation ?|20050",
nNbCreate.ToString(),
nNbUpdate.ToString()), EFormAlerteType.Question) == DialogResult.Yes)
{
result = ctx.SaveAll(true);
if (result)
{
CFormAlerte.Afficher(I.T("Import ended with success|20051"), EFormAlerteType.Info);
}
}
}
}
}
catch (Exception ex)
{
result.EmpileErreur(new CErreurException(ex));
}
if (!result)
{
CFormAfficheErreur.Show(result.Erreur);
}
}
private CResultAErreur SaveAll()
{
CResultAErreur result = CResultAErreur.True;
result = m_contexte.SaveAll(true);
if (!result)
{
CFormAlerte.Afficher(result.MessageErreur, EFormAlerteBoutons.Ok, EFormAlerteType.Erreur);
}
return(result);
}
//------------------------------------------------------------
private void m_btnValider_Click(object sender, EventArgs e)
{
CResultAErreur result = m_contexteDonnee.SaveAll(true);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
}
else
{
CFormAlerte.Afficher(I.T("Ok|10"));
}
}
//--------------------------------------------------------------------------
private void m_btnExecuter_Click(object sender, EventArgs e)
{
CResultAErreur result = SaveAll();
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
using (CContexteDonnee ctx = new CContexteDonnee(m_releve.ContexteDonnee.IdSession, true, false))
{
CReleveSite releve = m_releve;
CVersionDonnees version = releve.VersionDonneesPourApplication;
if (version == null)
{
releve.BeginEdit();
version = new CVersionDonnees(releve.ContexteDonnee);
version.CreateNewInCurrentContexte();
version.CodeTypeVersion = (int)CTypeVersion.TypeVersion.Previsionnelle;
version.Libelle = I.T("Site @1 survey (@2)|20796",
releve.Site.LibelleComplet, releve.DateReleve.ToShortDateString());
releve.VersionDonneesPourApplication = version;
releve.CommitEdit();
}
version = releve.VersionDonneesPourApplication;
//ctx.SetVersionDeTravail(version.Id, false);
foreach (CTraitementReleveEquipement traitement in m_listeTraitements)
{
result = traitement.Execute(ctx, null);
if (!result)
{
break;
}
}
if (result)
{
result = ctx.SaveAll(true);
}
if (result)
{
MessageBox.Show(I.T("Modifications have been applied|20798"));
}
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
}
}
}
//-----------------------------------------------------------------------------------------------------
private void m_menuAnnulerEtape_Click(object sender, EventArgs e)
{
CEtapeWorkflow etape = EtapeSelectionnee;
using (CContexteDonnee ctx = new CContexteDonnee(etape.ContexteDonnee.IdSession, true, false))
{
etape = etape.GetObjetInContexte(ctx) as CEtapeWorkflow;
etape.CancelStep();
CResultAErreur result = ctx.SaveAll(true);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
}
Refresh();
}
}
//-------------------------------------------------------
private bool ValideModifs()
{
if (!m_gestionnaireModeEdition.ModeEdition || m_contexteEnEdition == null)
{
return(false);
}
CResultAErreur result = m_contexteEnEdition.SaveAll(true);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return(false);
}
m_contexteEnEdition.Dispose();
m_contexteEnEdition = null;
m_panelTop.SetContexteDonnee(m_contexteDonnee);
return(true);
}
public CResultAErreur Execute(int nIdSession, Hashtable valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee contexte = new CContexteDonnee(nIdSession, true, false))
{
try
{
CHandlerEvenementServeur.SuspendGestionnaire(true);
// Supprimer les interventions SANS DEPLACEMENT
CListeObjetsDonnees listeIntersASupprimer = new CListeObjetsDonnees(contexte, typeof(CIntervention));
listeIntersASupprimer.Filtre = new CFiltreDataAvance(
CIntervention.c_nomTable,
//CIntervention.c_champId + " > @1 AND " + // DEBUG
CFractionIntervention.c_nomTable + "." +
COperation.c_nomTable + "." +
CTypeOperation.c_champId + " = @1",
//8900, // DEBUG
30); // 30 = Id du type d'opération SANS DEPLACEMENT
//int nbASupprimer = listeIntersASupprimer.CountNoLoad;
CObjetDonneeAIdNumerique.DeleteAvecCascadeSansControleDoncIlFautEtreSurDeSoi(listeIntersASupprimer);
result = contexte.SaveAll(true);
if (!result)
{
result.EmpileErreur("Erreur de sauvegarde des données");
return(result);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
CHandlerEvenementServeur.SuspendGestionnaire(false);
}
}
return(result);
}
public CResultAErreur UpdateEOs(CReferenceObjetDonnee referenceObject)
{
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
CObjetDonnee objet = referenceObject.GetObjet(contexte);
if (objet is IElementAEO)
{
result = CUtilElementAEO.UpdateEOSInCurrentContext((IElementAEO)objet);
if (result)
{
result = contexte.SaveAll(true);
}
return(result);
}
}
return(result);
}
//------------------------------------------
void toolStripPourcentage_OnValideSaisie(object sender, EventArgs e)
{
CToolStripPourcentage pct = sender as CToolStripPourcentage;
CBesoin besoin = pct != null?pct.Tag as CBesoin:null;
if (besoin != null && pct.Value != null)
{
if (CFormAlerte.Afficher(I.T("Change repartition for '@1' uses '@2'% of '@3' cost ?|20687",
besoin.LibelleComplet,
pct.Value.Value.ToString("0.##"),
m_satisfaction.Libelle),
EFormAlerteBoutons.OuiNon,
EFormAlerteType.Question) == DialogResult.Yes)
{
if (!m_bIsEnEdition)
{
using (CContexteDonnee ctx = new CContexteDonnee(m_satisfaction.ContexteDonnee.IdSession, true, false))
{
besoin = besoin.GetObjetInContexte(ctx) as CBesoin;
CObjetDonnee satObj = m_satisfaction as CObjetDonnee;
if (satObj != null)
{
satObj = satObj.GetObjetInContexte(ctx);
ISatisfactionBesoin satInContexte = satObj as ISatisfactionBesoin;
CUtilSatisfaction.SetPourcentageFor(besoin, satInContexte, pct.Value.Value);
}
CResultAErreur result = ctx.SaveAll(false);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
}
}
}
else
{
CUtilSatisfaction.SetPourcentageFor(besoin, m_satisfaction, pct.Value.Value);
}
}
}
}
//--------------------------------------------------------------------------
private void m_lblDragExisting_DragDrop(object sender, DragEventArgs e)
{
if (m_elementEdite != null)
{
CReferenceObjetDonnee[] refs = e.Data.GetData(typeof(CReferenceObjetDonnee[])) as CReferenceObjetDonnee[];
CReferenceObjetDonnee ref1 = e.Data.GetData(typeof(CReferenceObjetDonnee)) as CReferenceObjetDonnee;
if (ref1 != null)
{
List <CReferenceObjetDonnee> lst = new List <CReferenceObjetDonnee>();
lst.Add(ref1);
refs = lst.ToArray();
}
CObjetDonneeAIdNumerique obj = m_elementEdite as CObjetDonneeAIdNumerique;
if (obj != null && refs != null)
{
using (CContexteDonnee ctx = new CContexteDonnee(obj.ContexteDonnee.IdSession, true, false))
{
obj = obj.GetObjetInContexte(ctx) as CObjetDonneeAIdNumerique;
foreach (CReferenceObjetDonnee refObj in refs)
{
CDocumentGED doc = refObj.GetObjet(ctx) as CDocumentGED;
if (doc != null)
{
doc.AssocieA(obj);
}
}
CResultAErreur result = ctx.SaveAll(true);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
}
else
{
Init(m_elementEdite);
}
}
}
}
}
//-------------------------------------------------------------------------------
//Annule les modifications réalisées sur l'objet
public CResultAErreur AnnuleModificationsPrevisionnelles(int nIdVersionObjet)
{
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
CSessionClient session = CSessionClient.GetSessionForIdSession(IdSession);
result = session.BeginTrans();
if (!result)
{
return(result);
}
CVersionDonneesObjet versionObjet = new CVersionDonneesObjet(contexte);
if (!versionObjet.ReadIfExists(nIdVersionObjet))
{
return(result); //Rien à annuler
}
CVersionDonnees versionPrev = versionObjet.VersionDonnees;
if (versionPrev.TypeVersion.Code != CTypeVersion.TypeVersion.Previsionnelle)
{
result.EmpileErreur(I.T("Cannot cancel archive operation|220"));
return(result);
}
result = AnnuleModificationPrevisionnelle(versionObjet);
if (result)
{
result = contexte.SaveAll(true);
if (result)
{
result = session.CommitTrans();
}
else
{
result = session.RollbackTrans();
}
}
}
return(result);
}
//-----------------------------------------------------------------------------------------------------
private void m_menuEndStep_Click(object sender, EventArgs e)
{
CEtapeWorkflow etape = EtapeSelectionnee;
if (etape != null)
{
using (CContexteDonnee ctx = new CContexteDonnee(etape.ContexteDonnee.IdSession, true, false))
{
etape = etape.GetObjetInContexte(ctx) as CEtapeWorkflow;
CResultAErreur result = etape.EndEtapeNoSave();
if (result)
{
result = ctx.SaveAll(true);
}
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
}
}
}
public override CResultAErreur TraitementApresSauvegarde(CContexteDonnee contexte, bool bOperationReussie)
{
CResultAErreur result = base.TraitementApresSauvegarde(contexte, bOperationReussie);
if (!result)
{
return(result);
}
DataTable table = contexte.Tables[GetNomTable()];
if (table == null)
{
return(result);
}
List <DataRow> lstCrees = (List <DataRow>)table.ExtendedProperties[CDivers.c_cleRowCrees];
if (lstCrees == null)
{
return(result);
}
foreach (DataRow row in lstCrees)
{
CSpvSite spvSite = new CSpvSite(row);
using (CContexteDonnee newContexte = new CContexteDonnee(IdSession, true, false))
{
CSpvMessem messEM = new CSpvMessem(newContexte);
messEM.CreateNewInCurrentContexte();
messEM.FormatMessCreSite(spvSite.Id);
result = newContexte.SaveAll(true);
}
}
return(result);
}
//------------------------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// <param name="strXmlFile"></param>
/// <param name="contexte"></param>
private static CResultAErreur TraiteFichierQowisio(string strXmlFile, CContexteDonnee contexte, EModeTraitment modeTraitement)
{
CResultAErreur result = CResultAErreur.True;
try
{
XmlDocument fichierXmlQowisio = new XmlDocument();
fichierXmlQowisio.Load(strXmlFile);
XmlNode nodeExport = fichierXmlQowisio.SelectSingleNode("export");
if (nodeExport == null)
{
result.EmpileErreur("<export> node not found in file : " + strXmlFile);
return(result);
}
if ((modeTraitement & EModeTraitment.MEDIUM) == EModeTraitment.MEDIUM)
{
XmlNode nodeInventory = nodeExport.SelectSingleNode("inventory");
if (nodeInventory != null)
{
result += TraiteInventaireQowisio(nodeInventory, contexte);
if (!result)
{
C2iEventLog.WriteErreur("CCamusatQowisioDataServeur error in TraiteInventaireQowisio : " + result.MessageErreur);
return(result);
}
}
}
if ((modeTraitement & EModeTraitment.SHORT) == EModeTraitment.SHORT)
{
XmlNode nodeData = nodeExport.SelectSingleNode("data");
if (nodeData != null)
{
result = TraiteDataQowisio(nodeData, contexte);
if (!result)
{
C2iEventLog.WriteErreur("CCamusatQowisioDataServeur error in TraiteDataQowisio : " + result.MessageErreur);
}
}
XmlNode nodeAlarms = nodeExport.SelectSingleNode("alarms");
if (nodeAlarms != null)
{
result = TraiteAlarmesQowisio(nodeAlarms, contexte);
if (!result)
{
C2iEventLog.WriteErreur("CCamusatQowisioDataServeur error in TraiteAlarmesQowisio : " + result.MessageErreur);
}
}
}
result = contexte.SaveAll(true);
if (!result)
{
C2iEventLog.WriteErreur(result.MessageErreur);
}
}
catch (Exception e)
{
string strErreur = "CCamusatQowisioDataServeur error in TraiteFichierQowisio : " + e.Message;
C2iEventLog.WriteErreur(strErreur);
result.EmpileErreur(strErreur);
Console.WriteLine(strErreur);
return(result);
}
finally
{
}
return(result);
}
public static void OnTimerGestionAuto(object state)
{
if (m_bGestionAutoEnCours)
{
return;
}
try
{
m_bGestionAutoEnCours = true;
CSessionClient session = CSessionClient.CreateInstance();
CResultAErreur result = session.OpenSession(new CAuthentificationSessionServer(),
I.T("Automatic management of the diary states|314"),
ETypeApplicationCliente.Service);
if (!result)
{
result.EmpileErreur(I.T("Error in the automatic management of expiration dates: Impossible to open a session|315"));
C2iEventLog.WriteErreur(result.Erreur.ToString());
return;
}
try
{
using (CContexteDonnee contexte = new CContexteDonnee(session.IdSession, true, false))
{
DateTime dt = DateTime.Now;
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexte, typeof(CEntreeAgenda));
liste.Filtre = new CFiltreData(
CEntreeAgenda.c_champEtatAutomatique + "=@1 and " +
CEntreeAgenda.c_champEtat + "<>@2 and " + CEntreeAgenda.c_champEtat + "<>@3 and (" +
"(" +
CEntreeAgenda.c_champDateDebut + "< @4 and " +
CEntreeAgenda.c_champDateFin + ">@4 and " +
CEntreeAgenda.c_champEtat + "<>@5) or (" +
CEntreeAgenda.c_champDateFin + "<@4 and " +
CEntreeAgenda.c_champEtat + "<@6) )",
true,
(int)EtatEntreeAgenda.Info,
(int)EtatEntreeAgenda.Annulee,
//dt.ToString("dd/MM/yyyy HH:mm:00"),
dt,
(int)EtatEntreeAgenda.EnCours,
(int)EtatEntreeAgenda.Terminee);
foreach (CEntreeAgenda entree in liste)
{
entree.EtatAuto = false;
if (entree.DateDebut < dt && entree.DateFin > dt)
{
entree.CodeEtatInt = (int)EtatEntreeAgenda.EnCours;
}
if (entree.DateFin < dt)
{
entree.CodeEtatInt = (int)EtatEntreeAgenda.Terminee;
}
entree.EtatAuto = true;
}
result = contexte.SaveAll(true);
if (!result)
{
result.EmpileErreur(I.T("AError in the automatic management of expiration dates:Error during backup operation|316"));
C2iEventLog.WriteErreur(result.Erreur.ToString());
return;
}
}
}
finally
{
session.CloseSession();
}
}
finally
{
m_bGestionAutoEnCours = false;
}
}
/// //////////////////////////////////////////////////
///Démarre une étape.
///Attention, un étape ne peut démarrer que si elle n'est pas déjà démarrée
public void RunEtape(int nIdSessionMain, int nIdEtape)
{
CResultAErreur result = CResultAErreur.True;
CDbKey keyUser = null;
//Attend la fin des transactions en cours pour la session principale
IDatabaseConnexion cnx = null;
do
{
CSessionClient session = CSessionClient.GetSessionForIdSession(IdSession);
if (session != null && session.IsConnected)
{
IInfoUtilisateur info = session.GetInfoUtilisateur();
//TESTDBKEYTODO
if (info != null)
{
keyUser = info.KeyUtilisateur;
}
try
{
cnx = CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, typeof(CEtapeWorkflow));
}
catch //En cas d'erreur, c'est probablement que la session a été fermée, du coup, on peut y aller !
{
cnx = null;
}
System.Threading.Thread.Sleep(50);
}
else
{
cnx = null;
}
}while (cnx != null && cnx.IsInTrans());
lock (typeof(CLockerStartEtape))//S'assure que deux étapes ne démarrent pas en même temps !
{
List <CDonneeNotificationWorkflow> lstNotifications = new List <CDonneeNotificationWorkflow>();
CAuthentificationSessionProcess auth = new CAuthentificationSessionProcess();
using (CSessionClient sousSession = CSessionClient.CreateInstance())
{
try
{
Console.WriteLine("Thread : " + System.Diagnostics.Process.GetCurrentProcess().Threads.Count);
sousSession.OpenSession(auth, "Workflow step " + nIdEtape, ETypeApplicationCliente.Process);
//TESTDBKEYTODO
if (keyUser != null)
{
sousSession.ChangeUtilisateur(keyUser);
}
using (CContexteDonnee ctx = new CContexteDonnee(sousSession.IdSession, true, true))
{
CEtapeWorkflow etape = new CEtapeWorkflow(ctx);
int nWaiter = 10;
while (!etape.ReadIfExists(nIdEtape) && nWaiter > 0)
{
//On ne trouve pas l'étape, c'est peut être que l'écriture en base n'est pas completement terminée
//On va retenter toutes les 2 secondes pendant 20 secondes, si elle n'existe jamais,
//c'est qu'il y a eu suppression (ou au moins non commit).
nWaiter--;
Thread.Sleep(2000);
}
if (etape.ReadIfExists(nIdEtape))
{
result = etape.InternalSetInfosDemarrageInCurrentContext();
etape.EtatCode = (int)EEtatEtapeWorkflow.Démarrée;
result = ctx.SaveAll(true);
if (result)
{
result = etape.InternalRunAndSaveifOk();
}
if (result && etape.CodeAffectations.Length > 0 && etape.DateFin == null)
{
CDonneeNotificationWorkflow donneeWorkflow = new CDonneeNotificationWorkflow(
nIdSessionMain,
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);
}
if (!result)
{
NoteErreurSurEtape(etape, result.Erreur.ToString());
return;
}
}
}
}
catch (Exception e)
{
}
finally
{
sousSession.CloseSession();
}
}
if (lstNotifications != null)
{
CEnvoyeurNotification.EnvoieNotifications(lstNotifications.ToArray());
}
}
}
public CResultAErreur Execute(int nIdSession, Hashtable valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee contexte = new CContexteDonnee(nIdSession, true, false))
{
try
{
CHandlerEvenementServeur.SuspendGestionnaire(true);
contexte.EnableTraitementsAvantSauvegarde = false;
CListeObjetsDonnees lstInterventions = new CListeObjetsDonnees(contexte, typeof(CIntervention));
//*** DEBUG ***
//lstInterventions.Filtre = new CFiltreData(
// CIntervention.c_champId + " > @1 ",
// 8500);
int compteur = lstInterventions.CountNoLoad;
// FIN DEBUG
lstInterventions.ReadDependances("PhaseTicket.Ticket.RelationsChampsCustom");
lstInterventions.ReadDependances("RelationsIntervenants");
foreach (CIntervention inter in lstInterventions)
{
compteur--;
CPhaseTicket phase = inter.PhaseTicket;
if (phase != null)
{
// Copier les compte rendu pour OTA depuis l'intervention vers le ticket
CTicket ticketLié = phase.Ticket;
// 113 = Id du champ [Compte rendu d'Intervention modifié]
string strCompteRendu = (string)inter.GetValeurChamp(113);
// 114 = Id du champ [Compte rendu résumé pour OTA]
ticketLié.SetValeurChamp(144, strCompteRendu);
// Affecter le technicien sur les Phases de ticket
CActeur acteur = null;
if (phase.GetValeurChamp(146) == null)
{
foreach (CIntervention_Intervenant rel in inter.RelationsIntervenants)
{
acteur = rel.Intervenant;
// 146 = Id du champ [Technicien affecté] sur Phase
if (acteur != null)
{
phase.SetValeurChamp(146, acteur);
break;
}
}
}
}
}
result = contexte.SaveAll(true);
if (!result)
{
result.EmpileErreur("Erreur de sauvegarde des données");
return(result);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
CHandlerEvenementServeur.SuspendGestionnaire(false);
}
}
return(result);
}
public CResultAErreur Execute(int nIdSession, Hashtable valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee contexte = new CContexteDonnee(nIdSession, true, false))
{
StreamReader reader = null;
try
{
CHandlerEvenementServeur.SuspendGestionnaire(true);
contexte.EnableTraitementsAvantSauvegarde = false;
// Charges tous les tickets
CListeObjetsDonnees listeTicketsACharger = new CListeObjetsDonnees(contexte, typeof(CTicket));
listeTicketsACharger.ReadDependances("RelationsChampsCustom");
// Lire le CSV
string strFichierImport = "c:\\TimosData\\IMPORT_JANVIER_MARS_2009.csv";
reader = new StreamReader(strFichierImport);
// Lit l'entête de colonnes
string strLine = reader.ReadLine();
// Lit la première ligne
strLine = reader.ReadLine();
while (strLine != null)
{
// Pour chaque ligne du ficher
string[] strChamps = strLine.Split(';');
string strNumeroTicket = strChamps[0];
string strIdQualif = strChamps[2];
// Traitement
CTicket ticket = new CTicket(contexte);
if (ticket.ReadIfExists(new CFiltreData(
CTicket.c_champNumero + " = @1",
strNumeroTicket)))
{
CQualificationTicket qualif = new CQualificationTicket(contexte);
if (qualif.ReadIfExists(new CFiltreData(
CQualificationTicket.c_champId + " = @1",
Int32.Parse(strIdQualif))))
{
// Affecte la valeur du champs custom 147 : Requalification
ticket.SetValeurChamp(147, qualif);
}
}
// Lit la ligne suivante
strLine = reader.ReadLine();
}
reader.Close();
result = contexte.SaveAll(true);
if (!result)
{
result.EmpileErreur("Erreur de sauvegarde des données");
return(result);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
CHandlerEvenementServeur.SuspendGestionnaire(false);
if (reader != null)
{
reader.Close();
}
}
}
return(result);
}
private void m_btnTesterImport_Click(object sender, EventArgs e)
{
CConfigMappagesSmartImport config = null;
DataTable table = null;
CResultAErreur result = PrepareImport(ref config, ref table);
if (!result || table == null)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
DialogResult dr = MessageBox.Show(I.T("Would you like to save configuration first ?|20225"), "",
MessageBoxButtons.YesNoCancel,
MessageBoxIcon.Question);
if (dr == DialogResult.Cancel)
{
return;
}
if (dr == DialogResult.Yes)
{
if (!SaveConfig())
{
return;
}
}
if (!CFormOptionsSimulation.EditeOptions(m_optionsSimulation))
{
return;
}
using (CContexteDonnee ctx = new CContexteDonnee(CSc2iWin32DataClient.ContexteCourant.IdSession, true, false))
{
CContexteImportDonnee contexteImport = new CContexteImportDonnee(ctx);
contexteImport.StartLine = m_optionsSimulation.StartLine;
contexteImport.EndLine = m_optionsSimulation.EndLine;
contexteImport.BestEffort = true;
IIndicateurProgression indicateur = null;
indicateur = CFormProgression.GetNewIndicateurAndPopup(I.T("Testing import|20246"));
result = config.ImportTable(table, contexteImport, indicateur);
CFormProgression.EndIndicateur(indicateur);
indicateur = null;
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
if (m_optionsSimulation.TestDbWriting)
{
CSessionClient session = CSessionClient.GetSessionForIdSession(ctx.IdSession);
session.BeginTrans();
result = ctx.SaveAll(false);
session.RollbackTrans();
if (!result)
{
if (CFormAlerte.Afficher(result.Erreur, EFormAlerteBoutons.ContinuerAnnuler, EFormAlerteType.Info) == System.Windows.Forms.DialogResult.Cancel)
{
return;
}
}
}
if (CFormResultatSmartImport.ShowImportResult(ctx, contexteImport, config, m_rootValues, table))
{
result = ctx.SaveAll(true);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
}
}
}