//----------------------------------------------------------
public override CResultAErreur AfterSave(CContexteSauvegardeObjetsDonnees contexte, IDataAdapter adapter, DataRowState etatsAPrendreEnCompte)
{
CResultAErreur result = base.AfterSave(contexte, adapter, etatsAPrendreEnCompte);
if (!result || IdVersionDeTravail == null || (etatsAPrendreEnCompte & DataRowState.Added) != DataRowState.Added)
{
return(result);
}
Dictionary <DataRow, DataRow> mapRowToRowOriginale = (Dictionary <DataRow, DataRow>)contexte.ContexteDonnee.ExtendedProperties[GetType().ToString() + "_MAPORG"];
if (mapRowToRowOriginale != null && mapRowToRowOriginale.Count > 0)
{
string strPrimKey = "";
foreach (KeyValuePair <DataRow, DataRow> pair in mapRowToRowOriginale)
{
DataRow rowVersion = pair.Key;
DataRow rowRef = pair.Value;
if (strPrimKey.Length == 0)
{
strPrimKey = rowVersion.Table.PrimaryKey[0].ColumnName;
}
rowVersion[CSc2iDataConst.c_champOriginalId] = rowRef[strPrimKey];
}
adapter.Update(contexte.ContexteDonnee);
}
contexte.ContexteDonnee.ExtendedProperties.Remove(GetType().ToString() + "_MAPORG");
return(result);
}
public override CResultAErreur BeforeSave(CContexteSauvegardeObjetsDonnees contexte, IDataAdapter adapter, DataRowState etatsAPrendreEnCompte)
{
CResultAErreur result = base.BeforeSave(contexte, adapter, etatsAPrendreEnCompte);
if (!result)
{
return(result);
}
DataTable table = contexte.ContexteDonnee.Tables[GetNomTable()];
if (table == null)
{
return(result);
}
ArrayList lstRows = new System.Collections.ArrayList(table.Rows);
foreach (DataRow row in lstRows)
{
if (row.RowState == DataRowState.Added)
{
// Recherche du BindingId lorsqu'il est négatif
CSpvLienAccesAlarme spvLienAccesAlarme = new CSpvLienAccesAlarme(row);
int?nLienId = spvLienAccesAlarme.BindingId;
if (nLienId < 0) // il faut le trouver
{
if (spvLienAccesAlarme.AccesAlarmeOne.SpvEquip != null)
{
spvLienAccesAlarme.BindingId = spvLienAccesAlarme.AccesAlarmeOne.SpvEquip.Id;
}
else if (spvLienAccesAlarme.AccesAlarmeOne.SpvSite != null)
{
spvLienAccesAlarme.BindingId = spvLienAccesAlarme.AccesAlarmeOne.SpvSite.Id;
}
else if (spvLienAccesAlarme.AccesAlarmeOne.SpvLiai != null)
{
spvLienAccesAlarme.BindingId = spvLienAccesAlarme.AccesAlarmeOne.SpvLiai.Id;
}
else
{
spvLienAccesAlarme.BindingId = null; // pas normal
}
}
if (spvLienAccesAlarme.AccesAlarmeOne != spvLienAccesAlarme.SpvAccesAlarmeSysteme0())
{
// Création du message pour EmessEM
CSpvMessem spvMessem = new CSpvMessem(contexte.ContexteDonnee);
spvMessem.CreateNewInCurrentContexte();
if (!spvMessem.FormatMessAccesAlarme(spvLienAccesAlarme, row.RowState))
{
spvMessem.CancelCreate();
}
}
}
}
return(result);
}
//----------------------------------------------------------
public override CResultAErreur BeforeSave(CContexteSauvegardeObjetsDonnees contexte, IDataAdapter adapter, DataRowState etatsAPrendreEnCompte)
{
CResultAErreur result = base.BeforeSave(contexte, adapter, etatsAPrendreEnCompte);
if (!result)
{
return(result);
}
if (IdVersionDeTravail == null || (etatsAPrendreEnCompte & DataRowState.Added) != DataRowState.Added)
{
return(result);
}
//Si on affecte un champ dans une version, il faut qu'il soit affecté dans le référentiel,
//sinon, on n'a pas d'id original pour le CRelationElementAChamp_ChampCustom
DataTable table = contexte.ContexteDonnee.Tables[GetNomTable()];
if (table == null)
{
return(result);
}
Dictionary <DataRow, DataRow> mapRowToRowOriginale = new Dictionary <DataRow, DataRow>();
ArrayList lstRows = new ArrayList(table.Rows);
foreach (DataRow row in lstRows)
{
if (row.RowState == DataRowState.Added && row[CSc2iDataConst.c_champIdVersion] != DBNull.Value)
{
if (row[CSc2iDataConst.c_champOriginalId] == DBNull.Value)
{
//Le champ n'a pas de valeur dans le référentiel, lui affecte la valeur
//par défault, sauf si l'élément parent n'appartient pas au référentiel,
//il faut trouver à quelle version appartient l'élément parent
int?nIdVersionCreationDuParent = null;
CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)contexte.ContexteDonnee.GetNewObjetForRow(row);
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)rel.ElementAChamps;
nIdVersionCreationDuParent = (int?)objet.Row[CSc2iDataConst.c_champIdVersion, true];
if ((int)row[CSc2iDataConst.c_champIdVersion] != nIdVersionCreationDuParent)
{
CRelationElementAChamp_ChampCustom newRel = (CRelationElementAChamp_ChampCustom)Activator.CreateInstance(GetTypeObjets(), contexte.ContexteDonnee);
newRel.CreateNewInCurrentContexte();
newRel.ElementAChamps = rel.ElementAChamps;
newRel.ChampCustom = rel.ChampCustom;
newRel.Valeur = rel.ChampCustom.ValeurParDefaut;
newRel.IdVersionDatabase = nIdVersionCreationDuParent;
mapRowToRowOriginale[rel.Row.Row] = newRel.Row.Row;
}
}
}
}
//Stocke le mapRow dans le contexte, pour s'en resservir après update
contexte.ContexteDonnee.ExtendedProperties[GetType().ToString() + "_MAPORG"] = mapRowToRowOriginale;
return(result);
}
///////////////////////////////////////////////////////////////////////////////
protected override CResultAErreur MySaveAll(CContexteSauvegardeObjetsDonnees contexteSauvegarde)
{
CResultAErreur result = CResultAErreur.True;
result = DoAddAndUpdateInDB(contexteSauvegarde);
if (result)
{
result = DoDeleteInDB(contexteSauvegarde);
}
/*if ( result )
* result = SaveBlobs();*/
return(result);
}
/// //////////////////////////////////////////////////
public override CResultAErreur SaveAll(CContexteSauvegardeObjetsDonnees contexteSauvegarde, System.Data.DataRowState etatsAPrendreEnCompte)
{
DataTable table = contexteSauvegarde.ContexteDonnee.Tables[GetNomTable()];
List <DataRow> rowsAdded = new List <DataRow>();
if (table != null)
{
foreach (DataRow row in new ArrayList(table.Rows))
{
if (row.RowState == DataRowState.Added || (row.RowState == DataRowState.Modified && !row[CSc2iDataConst.c_champIsDeleted].Equals(true)))
{
rowsAdded.Add(row);
}
if (row.RowState == DataRowState.Deleted || (row.RowState == DataRowState.Modified && row[CSc2iDataConst.c_champIsDeleted].Equals(true)))
{
//TESTDBKEYTODO
CDonneeNotificationBesoinIntervention notif = new CDonneeNotificationBesoinIntervention(
IdSession,
CDbKey.CreateFromStringValue((string)row[CBesoinInterventionProcess.c_champKeyUtilisateur,
DataRowVersion.Original]),
(int)row[CBesoinInterventionProcess.c_champId,
DataRowVersion.Original],
(string)row[CBesoinInterventionProcess.c_champLibelle,
DataRowVersion.Original],
true);
CEnvoyeurNotification.EnvoieNotifications(new IDonneeNotification[] { notif });
}
}
}
CResultAErreur result = base.SaveAll(contexteSauvegarde, etatsAPrendreEnCompte);
if (result)
{
foreach (DataRow row in rowsAdded)
{
//TESTDBKEYTODO
CDonneeNotificationBesoinIntervention notif = new CDonneeNotificationBesoinIntervention(
IdSession,
CDbKey.CreateFromStringValue((string)row[CBesoinInterventionProcess.c_champKeyUtilisateur]),
(int)row[CBesoinInterventionProcess.c_champId],
(string)row[CBesoinInterventionProcess.c_champLibelle],
false);
CEnvoyeurNotification.EnvoieNotifications(new IDonneeNotification[] { notif });
}
}
return(result);
}
//-------------------------------------------------------------------------------
public override CResultAErreur SaveAll(CContexteSauvegardeObjetsDonnees contexteSauvegarde, DataRowState etatsAPrendreEnCompte)
{
CResultAErreur result = CResultAErreur.True;
DataTable table = contexteSauvegarde.ContexteDonnee.Tables[GetNomTable()];
if (table != null)
{
ArrayList lstRows = new ArrayList(table.Rows);
foreach (DataRow row in lstRows)
{
if (row.RowState == DataRowState.Modified)
{
CVersionDonneesObjet version = new CVersionDonneesObjet(row);
version.CancelCreate();
}
if (row.RowState == DataRowState.Added || row.RowState == DataRowState.Modified)
{
CVersionDonneesObjet versionObjet = new CVersionDonneesObjet(row);
if (versionObjet.CodeTypeOperation == (int)CTypeOperationSurObjet.TypeOperation.Ajout ||
versionObjet.CodeTypeOperation == (int)CTypeOperationSurObjet.TypeOperation.Suppression)
{
CListeObjetsDonnees datas = versionObjet.ToutesLesOperations;
/*CListeObjetsDonnees datas = new CListeObjetsDonnees(versionObjet.ContexteDonnee, typeof(CVersionDonneesObjetOperation));
* datas.Filtre = new CFiltreData(CVersionDonneesObjet.c_champId + "=@1 and " +
* CVersionDonneesObjetOperation.c_champOperation += "@2",
* versionObjet.Id,
* (int)versionObjet.CodeTypeOperation);
* datas.InterditLectureInDB = true;*/
datas.Filtre = new CFiltreData(CVersionDonneesObjetOperation.c_champOperation + "=@1",
versionObjet.CodeTypeOperation);
if (datas.Count == 0)
{
//Création du data. pour les ajouts et les suppressions,
//il doit y avoir un data indiquant l'opération
CVersionDonneesObjetOperation data = new CVersionDonneesObjetOperation(contexteSauvegarde.ContexteDonnee);
data.CreateNewInCurrentContexte();
data.VersionObjet = versionObjet;
data.CodeTypeOperation = versionObjet.CodeTypeOperation;
data.Champ = null;
}
}
}
}
}
return(base.SaveAll(contexteSauvegarde, etatsAPrendreEnCompte));
}
//----------------------------------------------------
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);
}
public override CResultAErreur BeforeSave(CContexteSauvegardeObjetsDonnees contexte, IDataAdapter adapter, DataRowState etatsAPrendreEnCompte)
{
CResultAErreur result = base.BeforeSave(contexte, adapter, etatsAPrendreEnCompte);
if (!result)
{
return(result);
}
DataTable table = contexte.ContexteDonnee.Tables[GetNomTable()];
if (table == null)
{
return(result);
}
ArrayList lstRows = new System.Collections.ArrayList(table.Rows);
foreach (DataRow row in lstRows)
{
if (row.RowState == DataRowState.Added)
{
// Remplacement dans le message de la chaîne de caractère
// CSpvMessalrm.c_CompleterMessId par l'ID du message
CSpvMessalrm spvMessalrm = new CSpvMessalrm(row);
string strMess = spvMessalrm.MessalrmMessage;
int nPos = strMess.IndexOf(CSpvMessalrm.c_CompleterMessId);
if (nPos < 0)
{
result.EmpileErreur(I.T("MessAlrm format not compliant"));
return(result);
}
strMess = spvMessalrm.MessalrmMessage.Substring(0, nPos)
+ spvMessalrm.Id.ToString()
+ spvMessalrm.MessalrmMessage.Substring(nPos + CSpvMessalrm.c_CompleterMessId.Length);
spvMessalrm.MessalrmMessage = strMess;
}
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur BeforeSave(CContexteSauvegardeObjetsDonnees contexte, IDataAdapter adapter, DataRowState etatsAPrendreEnCompte)
{
CResultAErreur result = base.BeforeSave(contexte, adapter, etatsAPrendreEnCompte);
if (!result)
{
return(result);
}
DataTable table = contexte.ContexteDonnee.Tables[GetNomTable()];
if (table == null)
{
return(result);
}
//Recale les mappages de champs custom avec les nouveaux ids de champs
Dictionary <int, CMapChampEntiteToRowCustom> dicEntitesToChamps =
table.ExtendedProperties[GetType()] as Dictionary <int, CMapChampEntiteToRowCustom>;
if (dicEntitesToChamps == null)
{
return(result);
}
foreach (KeyValuePair <int, CMapChampEntiteToRowCustom> maps in dicEntitesToChamps)
{
CTypeEntiteSnmp te = new CTypeEntiteSnmp(contexte.ContexteDonnee);
if (te.ReadIfExists(maps.Key))
{
foreach (KeyValuePair <string, DataRow> map in maps.Value)
{
CChampEntiteFromQueryToChampCustom champ = te.GetChamp(map.Key);
champ.IdChampCustom = (int)map.Value[CChampCustom.c_champId];
}
}
te.CommitChampsFromQuery();
}
table.ExtendedProperties.Remove(GetType());
return(result);
}
public override CResultAErreur BeforeSave(CContexteSauvegardeObjetsDonnees contexte, IDataAdapter adapter, DataRowState etatsAPrendreEnCompte)
{
return(CResultAErreur.True);
}
/// ///////////////////////////////////////////////////////
/////////////////////////////////////////////////////////
public override CResultAErreur SaveAll(CContexteSauvegardeObjetsDonnees contexteSauvegarde, DataRowState etatsAPrendreEnCompte)
{
CResultAErreur result = CResultAErreur.True;
//STEF : J'avais mis base.SaveAll après : pb : lors d'une création, on ne
//le blob n'était pas sauvé car la sauvegarde d'un blob est un update
//sur la table
/*ArrayList lstRowsToSave = new ArrayList();
* foreach ( DataRow row in ds.Tables[GetNomTable()].Rows )
* if ( row.RowState == DataRowState.Modified || row.RowState == DataRowState.Added )
* lstRowsToSave.Add ( row );*/
//DataTable tableResult = null;
if (result)
{
result = base.SaveAll(contexteSauvegarde, etatsAPrendreEnCompte);
}
/*if ( result )
* {
* tableResult = (DataTable)result.Data;
* try
* {
* //s'il y a des données binaires, il faut les sauver
* DataTable table = ds.Tables[GetNomTable()];
* foreach ( DataColumn col in table.Columns )
* {
* if ( col.DataType == typeof(CDonneeBinaireInRow) )
* {
* string strPrim = table.PrimaryKey[0].ColumnName;
* foreach ( DataRow row in lstRowsToSave )
* {
* if (row[col.ColumnName] != DBNull.Value &&
* row[col.ColumnName] != null
* )
* {
* object obj = row[col.ColumnName];
* CDonneeBinaireInRow data = (CDonneeBinaireInRow)obj;
* if ( data != null && data.HasChange() )
* result = SaveBlob (col.ColumnName, strPrim+"="+row[strPrim].ToString(), data.Donnees );
* if ( !result )
* break;
*
* }
* }
* }
* if ( !result )
* break;
* }
* if ( result )
* result.Data = tableResult;
*
* }
* catch ( Exception e )
* {
* result.EmpileErreur(new CErreurException (e ) );
* result.EmpileErreur("Erreur lors de la sauvegarde "+GetNomTable() );
* }
* }*/
return(result);
}
public override CResultAErreur SaveAll(CContexteSauvegardeObjetsDonnees contexteSauvegarde, System.Data.DataRowState etatsAPrendreEnCompte)
{
ArrayList listeFichiersToDelete = null;
ArrayList listeFichiersToValide = null;
ArrayList listeFichiersANePasSupprimer = null;
GetListesPourValidation(ref listeFichiersToDelete,
ref listeFichiersToValide,
ref listeFichiersANePasSupprimer);
CResultAErreur result = CResultAErreur.True;
m_commitEventHandlerNote = new OnCommitTransEventHandler(OnCommitTrans);
DataTable table = contexteSauvegarde.ContexteDonnee.Tables[GetNomTable()];
if (table != null)
{
foreach (DataRow row in table.Rows)
{
if (row.RowState == DataRowState.Modified || row.RowState == DataRowState.Added)
{
if (!CDocumentGED.IsControleDocumentsALaSauvegardeDesactive(contexteSauvegarde.ContexteDonnee))
//si désactivation des ids auto, on est dans un processus
//de synchronisation, donc , pas de contrôle de document
{
CDocumentGED doc = new CDocumentGED(row);
CReferenceDocument newReference = doc.ReferenceDoc;
bool bRefAsChange = true;
if (row.RowState == DataRowState.Modified)
{
doc.VersionToReturn = DataRowVersion.Original;
CReferenceDocument oldRef = doc.ReferenceDoc;
bRefAsChange = false;
if ((newReference == null) != (oldRef == null))
{
bRefAsChange = true;
}
if (oldRef != null && !oldRef.Equals(newReference))
{
listeFichiersToDelete.Add(oldRef);
bRefAsChange = true;
}
doc.VersionToReturn = DataRowVersion.Current;
}
if (bRefAsChange)
{
result = PreValideDocument(newReference);
}
if (!result)
{
return(result);
}
if (bRefAsChange)
{
listeFichiersToValide.Add(doc.ReferenceDoc);
}
listeFichiersANePasSupprimer.Add(doc.ReferenceDoc);
listeFichiersToDelete.Remove(doc.ReferenceDoc);//Il ne faut pas le supprimer !
}
}
if (row.RowState == DataRowState.Deleted)
{
CDocumentGED doc = new CDocumentGED(row);
doc.VersionToReturn = DataRowVersion.Original;
string strRefString = doc.ReferenceString;
if (!listeFichiersToValide.Contains(doc.ReferenceDoc) &&
!listeFichiersANePasSupprimer.Contains(doc.ReferenceDoc))
{
listeFichiersToDelete.Add(doc.ReferenceDoc);
}
doc.VersionToReturn = DataRowVersion.Current;
}
}
}
IDatabaseConnexion con = CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, GetType());
if (con != null)
{
con.OnCommitTrans += m_commitEventHandlerNote;
}
result = base.SaveAll(contexteSauvegarde, etatsAPrendreEnCompte);
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur SaveAll(CContexteSauvegardeObjetsDonnees contexteSauvegarde, DataRowState etatsAPrendreEnCompte)
{
return(CResultAErreur.True);
}
