/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
if (FormuleDateLimite == null)
{
result.EmpileErreur(I.T("You have to specify a limit date|20008"));
return(result);
}
result = FormuleDateLimite.Eval(contexteEval);
if (!result)
{
return(result);
}
if (!(result.Data is DateTime))
{
result.EmpileErreur(I.T("Bad limit date|20009"));
return(result);
}
result = CVersionDonnees.Purger((DateTime)result.Data, contexte.IdSession);
return(result);
}
private void RecalcIdsVersions()
{
CVersionDonnees v = m_audit.VersionCible;
m_idsVersions = new List <string>();
while (v != null)
{
m_idsVersions.Add(v.Id.ToString());
v = v.VersionParente;
}
if (m_idsVersions.Count < 1)
{
//ERR
}
m_idsVersionsCibles = new List <string>(m_idsVersions);
if (m_idsVersions.Count > 1)
{
m_idsVersionsCibles.RemoveAt(m_idsVersionsCibles.Count - 1);
}
m_idsVersionsSources = new List <string>(m_idsVersions);
m_idsVersionsSources.RemoveAt(0);
m_bRecalcIDs = false;
}
public void Init()
{
CResultAErreur result = CResultAErreur.True;
CTimosTestMetierApp.AssureInit();
m_contexteDonnee = new CContexteDonnee(CTimosTestMetierApp.SessionClient.IdSession, true, false);
using (CContexteDonnee contexte = new CContexteDonnee(CTimosTestMetierApp.SessionClient.IdSession, true, false))
{
CVersionDonnees version1 = null;
for (int nVersion = 0; nVersion < m_nIdsVersions.Length; nVersion++)
{
CVersionDonnees version = new CVersionDonnees(contexte);
if (version.ReadIfExists(new CFiltreData(CVersionDonnees.c_champLibelle + "=@1 and " +
CVersionDonnees.c_champTypeVersion + "=@2",
GetLibelleVersion(nVersion),
(int)CTypeVersion.TypeVersion.Previsionnelle)))
{
m_nIdsVersions[nVersion] = version.Id;
}
else
{
version.CreateNew();
version.Libelle = GetLibelleVersion(nVersion);
version.CodeTypeVersion = (int)CTypeVersion.TypeVersion.Previsionnelle;
version.Date = DateTime.Now;
if (nVersion == 2)
{
version.VersionParente = version1;
}
result = version.CommitEdit();
if (!result)
{
throw new CExceptionErreur(result.Erreur);
}
m_nIdsVersions[nVersion] = version.Id;
}
if (nVersion == 0)
{
version1 = version;
}
}
}
//Création de l'acteur de test
CActeur acteur = new CActeur(m_contexteDonnee);
if (!acteur.ReadIfExists(new CFiltreData(CActeur.c_champPrenom + "=@1",
"NUNIT ACTEUR")))
{
acteur.CreateNew();
acteur.Nom = "NUnit acteur";
acteur.Prenom = "NUNIT ACTEUR";
result = acteur.CommitEdit();
Assert.IsTrue(result.Result);
}
m_nIdActeur = acteur.Id;
//Remet le jeu de test à 0
ResetModifs();
}
//--------------------------------------------------------
public static CVersionDonnees GetVersionForInter(CIntervention intervention)
{
if (intervention.VersionDonneesAAppliquer != null)
{
CFormAlerte.Afficher(I.T("This intervention is already linked to a version|1355"), EFormAlerteType.Erreur);
return(intervention.VersionDonneesAAppliquer);
}
CFormCreateVersionPourIntervention form = new CFormCreateVersionPourIntervention();
form.m_intervention = intervention;
CVersionDonnees version = null;
if (form.ShowDialog() == DialogResult.OK)
{
if (form.m_radioLierNouveau.Checked)
{
//S'assure que la version est bien sauvegardée, en la créant dans une nouveau contexte
CContexteDonnee contexteForVersion = new CContexteDonnee(intervention.ContexteDonnee.IdSession, true, false);
version = new CVersionDonnees(contexteForVersion);
version.CreateNew();
version.CodeTypeVersion = (int)CTypeVersion.TypeVersion.Previsionnelle;
version.Libelle = form.m_txtLibelleVersion.Text;
version.VersionParente = (CVersionDonnees)form.m_txtSelectVersionParente.ElementSelectionne;
version.Date = DateTime.Now;
}
else
{
version = (CVersionDonnees)form.m_txtSelectVersionExistante.ElementSelectionne;
}
}
form.Dispose();
return(version);
}
public static void ShowDetail(CObjetDonneeAIdNumerique objet, CVersionDonnees version)
{
CFormDetailVersion form = new CFormDetailVersion();
form.m_panelDetail.InitForObjet(objet, version);
form.ShowDialog();
form.Dispose();
}
//----------------------------------------------------------
public CResultAErreur AnnuleModificationPrevisionnelle(CVersionDonneesObjet versionObjet)
{
CContexteDonnee contexte = versionObjet.ContexteDonnee;
CResultAErreur result = CResultAErreur.True;
int nIdObjet = versionObjet.IdElement;
Type typeObjet = versionObjet.TypeElement;
CVersionDonnees versionPrev = versionObjet.VersionDonnees;
int nIdVersion = versionPrev.Id;
//Vérifie que l'utilisateur peut travailler avec cette version
result = versionPrev.EnregistreEvenement(CVersionDonnees.c_eventBeforeUtiliser, true);
if (!result)
{
return(result);
}
contexte.SetVersionDeTravail(-1, false);
//Suppression de l'objet associé
string strPrimKey = contexte.GetTableSafe(CContexteDonnee.GetNomTableForType(typeObjet)).PrimaryKey[0].ColumnName;
CListeObjetsDonnees listeTmp = new CListeObjetsDonnees(contexte, typeObjet);
listeTmp.Filtre = new CFiltreData(
CSc2iDataConst.c_champIdVersion + "=@1 and " +
"(" + CSc2iDataConst.c_champOriginalId + "=@2 or " +
strPrimKey + "=@2)",
nIdVersion,
nIdObjet);
listeTmp.Filtre.IgnorerVersionDeContexte = true;
result = CObjetDonneeAIdNumerique.Delete(listeTmp);
if (!result)
{
return(result);
}
//Suppression de la version objet
result = versionObjet.Delete();
if (!result)
{
return(result);
}
//Force la modification de l'objet pour mettre à jour les versions suivantes
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)Activator.CreateInstance(typeObjet, new object[] { contexte });
if (objet.ReadIfExists(nIdObjet))
{
//Passe dans la version de l'objet
result = contexte.SetVersionDeTravail(objet.IdVersionDatabase, false);
if (!result)
{
return(result);
}
objet.Row.Row.SetModified();
}
return(result);
}
//-------------------------------------------------------
public static CResultAErreurType <CMacro> FromVersion(CVersionDonnees version)
{
CResultAErreurType <CMacro> result = new CResultAErreurType <CMacro>();
using (CContexteDonnee contexte = new CContexteDonnee(version.ContexteDonnee.IdSession, true, false))
{
contexte.SetVersionDeTravail(version.Id, false);
CMacro macro = new CMacro();
macro.m_contexteDonnee = version.ContexteDonnee;
macro.Libelle = version.Libelle;
CVariableDynamiqueSysteme variable = new CVariableDynamiqueSysteme();
variable.SetTypeDonnee(new CTypeResultatExpression(typeof(string), false));
variable.Nom = "CurrentElement";
variable.IdVariable = m_strIdVariableCurrentElement;
macro.AddVariable(variable);
Dictionary <int, CMacroObjet> dicMacrosObjets = new Dictionary <int, CMacroObjet>();
Dictionary <CObjetDonneeAIdNumerique, CMacroObjet> dicObjetToMacros = new Dictionary <CObjetDonneeAIdNumerique, CMacroObjet>();
foreach (CVersionDonneesObjet vo in version.VersionsObjets)
{
if (!typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(vo.TypeElement) && vo.TypeElement.GetCustomAttributes(typeof(NoMacroAttribute), true).Length == 0)
{
CMacroObjet mo = new CMacroObjet(macro);
mo.TypeObjet = vo.TypeElement;
mo.IdObjet = vo.IdElement;
mo.TypeOperation = vo.TypeOperation;
macro.AddObjet(mo);
dicMacrosObjets[vo.Id] = mo;
CObjetDonneeAIdNumerique objet = Activator.CreateInstance(vo.TypeElement, new object[] { contexte }) as CObjetDonneeAIdNumerique;
if (objet.ReadIfExists(vo.IdElement))
{
dicObjetToMacros[objet] = mo;
}
mo.CreateVariable(objet);
}
}
foreach (CVersionDonneesObjet vo in version.VersionsObjets)
{
if (!typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(vo.TypeElement) && vo.TypeElement.GetCustomAttributes(typeof(NoMacroAttribute), true).Length == 0)
{
CMacroObjet mo = dicMacrosObjets[vo.Id];
CResultAErreur resMo = CResultAErreur.True;
resMo = mo.FillFromVersion(vo, contexte, dicObjetToMacros);
if (!resMo)
{
result.EmpileErreur(resMo.Erreur);
}
}
}
result.DataType = macro;
return(result);
}
}
//----------------------------------
private void ResetModifs()
{
using (CContexteDonnee contexte = new CContexteDonnee(CTimosTestMetierApp.SessionClient.IdSession, true, false))
{
for (int nVersion = 0; nVersion < m_nIdsVersions.Length; nVersion++)
{
CVersionDonnees version = new CVersionDonnees(contexte);
version.ReadIfExists(m_nIdsVersions[nVersion]);
foreach (CVersionDonneesObjet dataObjet in version.VersionsObjets)
{
Assert.IsTrue(dataObjet.AnnuleModificationsPrevisionnelles().Result);
}
}
}
}
//--------------------------------------------------------------------------
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 SetVersionEnCours(CContexteDonnee contexte)
{
if (contexte == null || contexte.IdVersionDeTravail == null)
{
m_timerClignote.Stop();
m_panelVersion.Visible = false;
}
else
{
CVersionDonnees version = new CVersionDonnees(contexte);
if (version.ReadIfExists((int)contexte.IdVersionDeTravail))
{
m_lblVersion.Text = version.Libelle;
m_panelVersion.Visible = true;
m_timerClignote.Start();
}
}
}
//------------------------------------------------------
public void InitForObjet(CObjetDonneeAIdNumerique objet, CVersionDonnees version)
{
CSessionClient session = CSessionClient.GetSessionForIdSession(objet.ContexteDonnee.IdSession);
IInfoUtilisateur info = session.GetInfoUtilisateur();
if (info != null)
{
m_bCanRestore = info.GetDonneeDroit(CDroitDeBaseSC2I.c_droitAdministration) != null;
}
m_bCanRestore &= version != null && version.TypeVersion.Code == CTypeVersion.TypeVersion.Archive;
m_panelRestore.Visible = m_bCanRestore;
if (m_contexteDonnees != null)
{
m_contexteDonnees.Dispose();
}
m_tableValeurs.Clear();
m_objetDepart = null;
m_version = null;
m_arbreObjet.Nodes.Clear();
if (objet == null || version == null)
{
return;
}
m_contexteDonnees = new CContexteDonnee(objet.ContexteDonnee.IdSession, true, false);
m_contexteDonnees.SetVersionDeTravail(-1, false); //Travaille sur toutes les versions
m_objetDepart = (CObjetDonneeAIdNumerique)m_contexteDonnees.GetObjetInThisContexte(objet);
m_version = (CVersionDonnees)m_contexteDonnees.GetObjetInThisContexte(version);
List <int> lstIds = new List <int>();
if (m_version.TypeVersion.Code == CTypeVersion.TypeVersion.Previsionnelle)
{
CVersionDonnees verTmp = m_version.VersionParente;
while (verTmp != null)
{
lstIds.Add(verTmp.Id);
verTmp = verTmp.VersionParente;
}
}
m_nIdsVersionsSuccessives = lstIds.ToArray();
CreateNodeObjet(m_arbreObjet.Nodes, m_objetDepart);
}
//-------------------------------------------------------
public static CResultAErreurType <CMacro> FromVersion(CVersionDonnees version)
{
CResultAErreurType <CMacro> result = new CResultAErreurType <CMacro>();
using (CContexteDonnee contexte = new CContexteDonnee(version.ContexteDonnee.IdSession, true, false))
{
contexte.SetVersionDeTravail(version.Id, false);
CMacro macro = new CMacro();
macro.m_contexteDonnee = version.ContexteDonnee;
Dictionary <int, CMacroObjet> dicMacrosObjets = new Dictionary <int, CMacroObjet>();
Dictionary <CObjetDonneeAIdNumerique, CMacroObjet> dicObjetToMacros = new Dictionary <CObjetDonneeAIdNumerique, CMacroObjet>();
foreach (CVersionDonneesObjet vo in version.VersionsObjets)
{
CMacroObjet mo = new CMacroObjet(macro);
mo.TypeObjet = vo.TypeElement;
mo.IdObjet = vo.IdElement;
mo.TypeOperation = vo.TypeOperation;
macro.AddObjet(mo);
dicMacrosObjets[vo.Id] = mo;
CObjetDonneeAIdNumerique objet = Activator.CreateInstance(vo.TypeElement, new object[] { contexte }) as CObjetDonneeAIdNumerique;
if (objet.ReadIfExists(vo.IdElement))
{
dicObjetToMacros[objet] = mo;
}
mo.CreateVariable(objet);
}
foreach (CVersionDonneesObjet vo in version.VersionsObjets)
{
CMacroObjet mo = dicMacrosObjets[vo.Id];
CResultAErreur resMo = CResultAErreur.True;
resMo = mo.FillFromVersion(vo, contexte, dicObjetToMacros);
if (!resMo)
{
result.EmpileErreur(resMo.Erreur);
}
}
result.DataType = macro;
return(result);
}
}
//-------------------------------------------------------------------------------
//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);
}
void item_Click(object sender, EventArgs e)
{
ToolStripMenuItem item = sender as ToolStripMenuItem;
CVersionDonnees version = item != null ? item.Tag as CVersionDonnees : null;
if (version != null)
{
CResultAErreurType <CMacro> res = CMacro.FromVersion(version);
bool bAdd = res;
if (!res)
{
if (CFormAlerte.Afficher(res.Erreur) == DialogResult.Ignore)
{
bAdd = true;
}
}
if (bAdd)
{
CListeMacros.AddMacro(res.DataType);
FillListe();
}
}
}
private void m_txtSelectVersionCible_ElementSelectionneChanged(object sender, EventArgs e)
{
if (!m_bInitialise)
{
return;
}
CVersionDonnees vSourceSelec = VersionSourceSelectionnee;
if (IdsVersionsSourcesPossibles.Count > 0)
{
m_txtSelectVersionSource.InitAvecFiltreDeBase <CVersionDonnees>(
"Libelle",
new CFiltreData(CVersionDonnees.c_champId + " in(" + string.Join(",", IdsVersionsSourcesPossibles.ToArray()) + ")"),
true);
}
else
{
m_txtSelectVersionSource.InitAvecFiltreDeBase <CVersionDonnees>(
"Libelle",
new CFiltreDataImpossible(),
true);
}
VersionSourceSelectionnee = vSourceSelec;
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
//Calcule le fichier ou l'url
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = FormuleLibelle.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during the Label evaluation|20002"));
return(result);
}
CVersionDonnees version = new CVersionDonnees(contexte.ContexteDonnee);
version.CreateNew();
version.CodeTypeVersion = (int)CTypeVersion.TypeVersion.Etiquette;
version.Libelle = (string)result.Data;
version.Date = DateTime.Now;
result = version.CommitEdit();
if (!result)
{
return(result);
}
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (!(lien is CLienUtilisateurAbsent))
{
result.Data = lien;
return(result);
}
}
result.Data = null;
return(result);
}
//---------------------------------------------------------------------------------
public CResultAErreurType <CSessionImport> DoSmartImport(
DataTable tableSource,
CConfigMappagesSmartImport config,
COptionExecutionSmartImport options,
IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
CSessionImport sessionImport = new CSessionImport();
sessionImport.TableSource = tableSource;
sessionImport.ConfigMappage = config;
CResultAErreurType <CSessionImport> resSession = new CResultAErreurType <CSessionImport>();
resSession.DataType = sessionImport;
int nTaillePaquet = options.TaillePaquets == null ? tableSource.Rows.Count : options.TaillePaquets.Value;
int nStartLigne = options.StartLine == null ? 0 : options.StartLine.Value;
int nEndLigne = options.EndLine == null ? tableSource.Rows.Count - 1 : Math.Min(options.EndLine.Value, tableSource.Rows.Count - 1);
int nNbToDo = nEndLigne - nStartLigne + 1;
int nNbDone = 0;
int?nIdVersionDonnees = null;
if (options.UtiliserVersionDonnee)
{
using (CContexteDonnee ctx = new CContexteDonnee(IdSession, true, false))
{
CVersionDonnees version = new CVersionDonnees(ctx);
version.CreateNew();
version.TypeVersion = new CTypeVersion(CTypeVersion.TypeVersion.Previsionnelle);
version.Libelle = I.T("Import data @1|20013", DateTime.Now.ToString("G"));
result = version.CommitEdit();
if (!result)
{
resSession.EmpileErreur(result.Erreur);
return(resSession);
}
nIdVersionDonnees = version.Id;
}
}
if (nStartLigne > 0)
{
sessionImport.AddLog(new CLigneLogImport(ETypeLigneLogImport.Info,
null,
"",
0,
nStartLigne - 1,
"Lines 0 to " + (nStartLigne - 1) + " are ignored"));
sessionImport.SetNonImportees(0, nStartLigne - 1);
}
if (nEndLigne < tableSource.Rows.Count - 1)
{
sessionImport.AddLog(new CLigneLogImport(ETypeLigneLogImport.Info,
null,
"",
nEndLigne + 1,
tableSource.Rows.Count - 1,
"Lines " + (nEndLigne + 1) + " to " + (tableSource.Rows.Count - 1) + " are ignored"));
sessionImport.SetNonImportees(nEndLigne + 1, tableSource.Rows.Count - 1);
}
//Ajoute dans la liste des lignes non importées, les lignes ignorées
using (C2iSponsor sponsor = new C2iSponsor())
{
if (indicateur != null)
{
sponsor.Register(indicateur);
indicateur.SetBornesSegment(0, nNbToDo);
}
try
{
while (nStartLigne <= nEndLigne)
{
using (CContexteDonnee ctxDonnees = new CContexteDonnee(IdSession, true, false))
{
if (m_nIdSession != null)
{
ctxDonnees.SetVersionDeTravail(nIdVersionDonnees, false);
}
CContexteImportDonnee ctxImport = new CContexteImportDonnee(ctxDonnees);
ctxImport.BestEffort = options.BestEffort;
ctxImport.StartLine = nStartLigne;
ctxImport.EndLine = Math.Min(nStartLigne + nTaillePaquet - 1, tableSource.Rows.Count - 1);
if (ctxImport.EndLine > nEndLigne)
{
ctxImport.EndLine = nEndLigne;
}
if (indicateur != null)
{
indicateur.PushSegment(nNbDone, nNbDone + ctxImport.EndLine.Value - ctxImport.StartLine.Value);
}
result = config.ImportTable(
tableSource,
ctxImport,
indicateur);
sessionImport.AddLogs(ctxImport.Logs);
if (indicateur != null)
{
indicateur.PopSegment();
}
if (result)
{
if (indicateur != null)
{
indicateur.SetInfo(I.T("Saving|20012"));
}
result = ctxDonnees.SaveAll(true);
if (!result)
{
sessionImport.SetNonImportees(ctxImport.StartLine.Value,
ctxImport.EndLine.Value);
sessionImport.AddLog(new CLigneLogImport(
ETypeLigneLogImport.Error,
null,
"",
ctxImport.StartLine.Value,
ctxImport.EndLine.Value,
"Error saving lines " + ctxImport.StartLine.Value + " to " + ctxImport.EndLine.Value + " " +
result.Erreur.ToString()));
}
if (!result && !ctxImport.BestEffort)
{
return(resSession);
}
if (result)
{
sessionImport.SetImportees(ctxImport.StartLine.Value,
ctxImport.EndLine.Value);
}
}
else
{
sessionImport.SetNonImportees(ctxImport.StartLine.Value,
ctxImport.EndLine.Value);
}
if (!result && !options.BestEffort)
{
return(resSession);
}
nStartLigne += nTaillePaquet;
nNbDone += nTaillePaquet;
if (indicateur != null)
{
indicateur.SetValue(nNbDone);
}
}
}
}
catch (Exception e)
{
resSession.EmpileErreur(new CErreurException(e));
}
finally
{
if (!result && !options.BestEffort)
{
resSession.EmpileErreur(result.Erreur);
}
}
return(resSession);
}
}
//--------------------------------------------------------------------
private void m_lnkEditerModificationsPrevisionnelles_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
if (m_gestionnaireModeEdition.ModeEdition)
{
Intervention.VersionDonneesAAppliquer = (CVersionDonnees)m_txtSelectVersionLiee.ElementSelectionne;
}
if (Intervention.VersionDonneesAAppliquer == null)
{
if (!m_gestionnaireModeEdition.ModeEdition)
{
CFormAlerte.Afficher(I.T("No planified modification for that intervention|1359"), EFormAlerteType.Erreur);
return;
}
//Si nouvelle inter, il faut la valider
if (CFormAlerte.Afficher(I.T("You have to save your intervention before associate it to planified modification. Would you like to save now ?|1356"),
EFormAlerteType.Question) == DialogResult.No)
{
return;
}
if (SaveRequired != null)
{
CancelEventArgs args = new CancelEventArgs();
args.Cancel = false;
SaveRequired(this, args);
if (args.Cancel)
{
return;
}
}
else
{
CFormAlerte.Afficher("Error", EFormAlerteType.Erreur);
return;
}
CResultAErreur result = CResultAErreur.True;
//Création de la version
CVersionDonnees version = CFormCreateVersionPourIntervention.GetVersionForInter(Intervention);
if (version != null)
{
if (version.IsNew())
{
result = version.CommitEdit();
if (!result)
{
CFormAlerte.Afficher(I.T("Error while creating data version|1357"), EFormAlerteType.Erreur);
return;
}
}
//Affectation de la version à l'intervention
CIntervention intervention = Intervention;
bool bStartEdit = intervention.ContexteDonnee.IsEnEdition;
if (!bStartEdit)
{
intervention.BeginEdit();
}
intervention.VersionDonneesAAppliquer = version;
if (!bStartEdit)
{
result = intervention.CommitEdit();
}
if (!result)
{
intervention.CancelEdit();
CFormAlerte.Afficher(I.T("Error while affecting version do intervention|1358"), EFormAlerteType.Erreur);
}
InitChamps(intervention);
}
}
//La version de données est maintenant normallement associée à l'intervention
CSite site = Intervention.Site;
if (site == null)
{
return;
}
if (Intervention.VersionDonneesAAppliquer == null)
{
return;
}
//Crée un contexte dans la version
using (CContexteDonnee contexte = new CContexteDonnee(Intervention.ContexteDonnee.IdSession, true, false))
{
CResultAErreur result = contexte.SetVersionDeTravail(Intervention.VersionDonneesAAppliquer.Id, true);
if (!result)
{
CFormAfficheErreur.Show(result.Erreur);
return;
}
site = (CSite)site.GetObjetInContexte(contexte);
CFormNavigateurPopup.Show(new CFormEditionSite(site));
}
}
/// ////////////////////////////////
public CResultAErreur ExecuteRequete(C2iRequeteAvancee requete)
{
CResultAErreur result = CResultAErreur.True;
string strTable = requete.TableInterrogee;
//S'il y a un filtre sur la requête avancée,
//On prépare d'abord la sous requête de sélection des ids qui nous
//Interessent
Type typeReference = CContexteDonnee.GetTypeForTable(strTable);
if (typeReference == null)
{
result.EmpileErreur(I.T("Impossible to define the associated type with @1|121", strTable));
return(result);
}
IDatabaseConnexion con;
if (typeReference == null)
{
con = CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, "");
}
else
{
con = CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, typeReference);
}
CFiltreData filtre = requete.FiltreAAppliquer;
CArbreTable arbre = null;
bool bHasVersionSurTablePrincipale = false;
Type tpObjet = CContexteDonnee.GetTypeForTable(requete.TableInterrogee);
if (tpObjet != null && !typeof(IObjetSansVersion).IsAssignableFrom(tpObjet) &&
typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpObjet))
{
bHasVersionSurTablePrincipale = true;
}
if (bHasVersionSurTablePrincipale)
{
CFiltreDataAvance filtreVersion = new CFiltreDataAvance(strTable, "");
//Lecture dans le référentiel
if (requete.IdVersionDeTravail == null && (filtre == null || !filtre.IgnorerVersionDeContexte))
{
filtreVersion.Filtre = "HasNo(" + CSc2iDataConst.c_champIdVersion + ")";
}
//Ignorer les suppressions
if (filtre != null && !filtre.IntegrerLesElementsSupprimes)
{
if (filtreVersion.Filtre != "")
{
filtreVersion.Filtre += " and ";
}
filtreVersion.Filtre += CSc2iDataConst.c_champIsDeleted + "=0";
}
//Lecture dans une version
if (requete.IdVersionDeTravail != null && (filtre == null || !filtre.IgnorerVersionDeContexte) && requete.IdVersionDeTravail >= 0)
{
if (filtre == null)
{
filtre = new CFiltreData();
}
filtre.IdsDeVersionsALire = CVersionDonnees.GetVersionsToRead(IdSession, (int)requete.IdVersionDeTravail);
}
if (filtreVersion.Filtre != "")
{
filtre = CFiltreData.GetAndFiltre(filtre, filtreVersion);
}
}
if (filtre != null && filtre is CFiltreDataAvance)
{
result = ((CFiltreDataAvance)filtre).GetArbreTables();
if (!result)
{
return(result);
}
arbre = (CArbreTable)result.Data;
}
result = requete.CalculeArbre(arbre);
if (!result)
{
return(result);
}
arbre = (CArbreTable)result.Data;
int nOldTimeOut = con.CommandTimeOut;
con.CommandTimeOut = 60 * 2;
result = con.ExecuteRequeteComplexe(requete.Champs, arbre, filtre);
con.CommandTimeOut = nOldTimeOut;
return(result);
}
//-------------------------------------------------------------------------
public CVersionDonneesObjet JournaliseDonnees(System.Data.DataRow row, CVersionDonnees version)
{
if (row.RowState == DataRowState.Modified ||
row.RowState == DataRowState.Added ||
row.RowState == DataRowState.Deleted)
{
Type tp = CContexteDonnee.GetTypeForTable(row.Table.TableName);
if (!typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(tp))
{
return(null);
}
//Récupère l'objet associé
DataRowVersion rowVersion = DataRowVersion.Current;
if (row.RowState == DataRowState.Deleted)
{
if (row.HasVersion(DataRowVersion.Original))
{
rowVersion = DataRowVersion.Original;
}
else
{
return(null);
}
}
CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)Activator.CreateInstance(tp, new object[] { row });
rel.VersionToReturn = rowVersion;
try
{
IElementAChamps objet = rel.ElementAChamps;
//Si l'objet est ajouté, on n'archive pas !
if (objet is CObjetDonneeAIdNumerique &&
((CObjetDonneeAIdNumerique)objet).Row.RowState != DataRowState.Added)
{
CObjetDonneeAIdNumerique objetAId = (CObjetDonneeAIdNumerique)objet;
if (objetAId != null)
{
//Récupère un version pour l'objet
CVersionDonneesObjet versionObjet = version.GetVersionObjetAvecCreation(objetAId.Row.Row);
if (versionObjet == null)
{
return(null);
}
//Stef 14082008 : en cas d'ajout, on ne fait rien. le datarow de l'objet n'est pas added
//car l'objet a déjà été sauvé quand on passe par là !
if (versionObjet.CodeTypeOperation == (int)CTypeOperationSurObjet.TypeOperation.Ajout)
{
return(null);
}
new CJournaliseurValeurChampCustom().JournaliseDonneeInContexte(versionObjet, rel.ChampCustom, row);
return(versionObjet);
}
}
}
catch
{
return(null);
}
}
return(null);
}
