//---------------------------------------------------------------------
public CResultAErreur AppliqueValeur(int?nIdVersion, IChampPourVersion champ, CObjetDonneeAIdNumerique objet, object valeur)
{
CResultAErreur result = CResultAErreur.True;
if (objet.Row.Table.Columns.Contains(champ.FieldKey))
{
try
{
if (valeur is byte[])
{
CDonneeBinaireInRow data = new CDonneeBinaireInRow(objet.ContexteDonnee.IdSession, objet.Row.Row, champ.FieldKey);
data.Donnees = (byte[])valeur;
objet.Row[champ.FieldKey] = data;
}
else if (valeur is IDifferencesBlob)
{
CContexteDonnee ctx = new CContexteDonnee(objet.ContexteDonnee.IdSession, true, false);
result = ctx.SetVersionDeTravail(nIdVersion, false);
if (!result)
{
return(result);
}
CObjetDonneeAIdNumerique objetDansVersion = (CObjetDonneeAIdNumerique)Activator.CreateInstance(objet.GetType(), new object[] { ctx });
if (objetDansVersion.ReadIfExists(objet.Id))
{
CDonneeBinaireInRow dataInVersion = new CDonneeBinaireInRow(ctx.IdSession, objetDansVersion.Row.Row, champ.FieldKey);
CDonneeBinaireInRow data = new CDonneeBinaireInRow(objet.ContexteDonnee.IdSession, objet.Row.Row, champ.FieldKey);
data.Donnees = dataInVersion.Donnees;
objet.Row[champ.FieldKey] = data;
}
else
{
throw new Exception(I.T("Error|199"));
}
}
else
{
objet.Row[champ.FieldKey] = valeur == null ? DBNull.Value : valeur;
}
}
catch
{
try
{
bool bOldEnforce = objet.ContexteDonnee.EnforceConstraints;
objet.ContexteDonnee.EnforceConstraints = false;
objet.Row[champ.FieldKey] = valeur == null ? DBNull.Value : valeur;
objet.ContexteDonnee.AssureParents(objet.Row.Row);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error while applying value for field @1|189", champ.NomConvivial));
}
}
}
return(result);
}
//---------------------------------------------
protected override CResultAErreur MyCanDelete()
{
CResultAErreur result = base.MyCanDelete();
if (!result)
{
return(result);
}
if (VersionDonnees.CodeTypeVersion != (int)CTypeVersion.TypeVersion.Previsionnelle)
{
return(result);
}
//Vérifie qu'il n'y a pas d'objet dans la base associé à la version et
//à cet objet
CObjetDonneeAIdNumerique objet = Element;
if (objet != null)
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(ContexteDonnee, Element.GetType());
liste.Filtre = new CFiltreData(
"(" + Element.GetChampId() + "=@1 or " +
CSc2iDataConst.c_champOriginalId + "=@1) and " +
CSc2iDataConst.c_champIdVersion + "=@2",
IdElement,
VersionDonnees.Id);
liste.Filtre.IgnorerVersionDeContexte = true;
liste.PreserveChanges = true;
if (liste.Count > 0)
{
result.EmpileErreur(I.T("You should cancel the modifications before deleting this version|188"));
return(result);
}
}
return(result);
}
/// <summary>
/// Retourne vrai si l'objet est utilisé dans une version future
/// </summary>
/// <param name="objet"></param>
/// <returns></returns>
public bool IsUtiliseDansVersionFuture(CObjetDonneeAIdNumerique objet)
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(objet.ContexteDonnee, objet.GetType(), false);
liste.Filtre = new CFiltreData(objet.GetChampId() + "=@1", objet.Id);
liste.InterditLectureInDB = true;
return(IsUtiliseDansVersionFuture(liste, objet.Id.ToString()));
}
public static object GetValeur(
DataRow row,
string strChampString,
string strChampBlob,
string strChampType,
CContexteDonnee ctx)
{
Type t = CActivatorSurChaine.GetType((string)row[strChampType]);
if (t == typeof(IDifferencesBlob))
{
CDonneeBinaireInRow blob = GetBlob(row, strChampBlob, ctx);
MemoryStream stream = new MemoryStream(blob.Donnees);
BinaryReader reader = new BinaryReader(stream);
CSerializerReadBinaire serializer = new CSerializerReadBinaire(reader);
I2iSerializable objet = null;
CResultAErreur result = serializer.TraiteObject(ref objet);
reader.Close();
stream.Close();
if (result)
{
return(objet);
}
System.Console.WriteLine(I.T("Error while deserializing blob diffs|30000"));
return(null);
}
else if (t == typeof(byte[]))
{
CDonneeBinaireInRow blob = GetBlob(row, strChampBlob, ctx);
if (blob != null)
{
return(blob.Donnees);
}
else
{
return(null);
}
}
else if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(t))
{
int nId = Int32.Parse((string)row[strChampString]);
CObjetDonneeAIdNumerique obj = (CObjetDonneeAIdNumerique)Activator.CreateInstance(t, new object[] { ctx });
if (obj.ReadIfExists(nId))
{
return(obj);
}
return(null);
}
else if (t != null && row[strChampString] != DBNull.Value)
{
return(CUtilTexte.FromUniversalString((string)row[strChampString], t));
}
return(null);
}
/// /////////////////////////////////////////////////////////////
public CObjetDonneeAIdNumerique GetObjet( )
{
if (TypeModif == TypeModifLogSynchro.tDelete)
{
return(null);
}
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)ContexteDonnee.GetNewObjetForTable(ContexteDonnee.GetTableSafe(TableConcernee));
objet.Id = IdElement;
return(objet);
}
public CResultAErreur AppliqueModifications(CObjetDonneeAIdNumerique objetDest)
{
CResultAErreur result = CResultAErreur.True;
foreach (CVersionDonneesObjetOperation data in Modifications)
{
result = data.AppliqueModification(objetDest);
if (!result)
{
return(result);
}
}
return(result);
}
//-------------------------------------------------------
public CResultAErreur AppliqueModification(CObjetDonneeAIdNumerique objet)
{
CResultAErreur result = CResultAErreur.True;
IJournaliseurDonneesChamp journaliseur = CGestionnaireAChampPourVersion.GetJournaliseur(TypeChamp);
if (journaliseur == null)
{
result.EmpileErreur(I.T("Can not apply modifications for field @1 (@2)|30002",
FieldKey, TypeChamp));
return(result);
}
result = journaliseur.AppliqueValeur(VersionObjet.VersionDonnees.Id, Champ, objet, GetValeur());
return(result);
}
public object GetValeur(CObjetDonneeAIdNumerique obj, IChampPourVersion champ)
{
if (obj.Row.Table.Columns[champ.FieldKey].DataType == typeof(CDonneeBinaireInRow))
{
if (obj.Row[champ.FieldKey] == DBNull.Value)
{
CDonneeBinaireInRow donnee = new CDonneeBinaireInRow(obj.ContexteDonnee.IdSession, obj.Row.Row, champ.FieldKey);
CContexteDonnee.ChangeRowSansDetectionModification(obj.Row.Row, champ.FieldKey, donnee);
}
/*DataRow row = obj.Row;
* DataTable tb = row.Table;
* IObjetServeur loader = ((CContexteDonnee)tb.DataSet).GetTableLoader(tb.TableName);
* CFiltreData filtre = CFiltreData.CreateFiltreAndSurRow(tb.PrimaryKey, row);
* ArrayList lstKeys = new ArrayList();
* foreach (DataColumn col in tb.PrimaryKey)
* lstKeys.Add(row[col]);
* CResultAErreur result = loader.ReadBlob(champ.FieldKey, lstKeys.ToArray());
* if ( result )*/
}
return(obj.Row[champ.FieldKey] == DBNull.Value ? null : obj.Row[champ.FieldKey]);
}
public List <IChampPourVersion> GetChampsJournalisables(CObjetDonneeAIdNumerique objet)
{
List <IChampPourVersion> champs = null;
if (!m_dicTypeToChamps.TryGetValue(objet.GetType(), out champs))
{
champs = new List <IChampPourVersion>();
CStructureTable structure = CStructureTable.GetStructure(objet.GetType());
CInfoChampTable[] allchamps = structure.Champs;
List <string> lstChampsSys = CSc2iDataConst.GetNomsChampsSysteme();
foreach (CInfoChampTable c in allchamps)
{
if (c.m_bIsInDB && !lstChampsSys.Contains(c.NomChamp))
{
champs.Add(new CChampPourVersionInDb(c.NomChamp, c.NomConvivial));
}
}
m_dicTypeToChamps[objet.GetType()] = champs;
}
return(champs);
}
/// //////////////////////////////////////////
///<summary>
///Charge les données de la table qui vont devoir être mise à jour
///à partir des données modifiées dans la table source
///</summary>
public CResultAErreur ChargeDonneesAMettreAJour(DataSet donneesSources)
{
CResultAErreur result = CResultAErreur.True;
ArrayList lstTables = CContexteDonnee.GetTablesOrderInsert(donneesSources);
foreach (DataTable table in lstTables)
{
DataTable tableDest = null;
//S'assure que la table est bien chargée
try
{
tableDest = GetTableSafe(table.TableName);
}
catch
{
//La table n'existe pas
}
if (tableDest != null && m_mappeurTablesToClass.IsSynchronisable(table.TableName) && table.Rows.Count != 0)
{
IObjetServeur serveur = CContexteDonnee.GetTableLoader(tableDest.TableName, null, IdSession);
string strNomTableInDb = CContexteDonnee.GetNomTableInDbForNomTable(tableDest.TableName);
if (serveur.CountRecords(strNomTableInDb, new CFiltreData("1=1")) != 0) //Première maj : copie complète
{
string strColPrim = table.PrimaryKey[0].ColumnName;
string strFiltre = "";
foreach (DataRow row in table.Rows)
{
strFiltre += row[strColPrim].ToString() + ",";
}
if (strFiltre.Length != 0)
{
//Supprime la dernière virgule;
strFiltre = strFiltre.Substring(0, strFiltre.Length - 1);
strFiltre = strColPrim += " in (" + strFiltre + ")";
IObjetServeur loader = GetTableLoader(table.TableName);
DataTable tableNew = loader.Read(new CFiltreData(strFiltre));
if (table == null)
{
result.EmpileErreur(I.T("Error while reading table @1|128", table.TableName));
return(result);
}
IntegreTable(tableNew, false);
}
}
}
}
//Charge les éléments à supprimer
CContexteDonnee contexteForListe = new CContexteDonnee(IdSession, true, false);
DataTable tableSync = donneesSources.Tables[CEntreeLogSynchronisation.c_nomTable];
DataTable tableCopie = CUtilDataSet.AddTableCopie(donneesSources.Tables[CEntreeLogSynchronisation.c_nomTable], contexteForListe);
foreach (DataRow row in tableSync.Rows)
{
tableCopie.ImportRow(row);
}
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexteForListe, typeof(CEntreeLogSynchronisation));
liste.InterditLectureInDB = true;
liste.Filtre = new CFiltreData(CEntreeLogSynchronisation.c_champType + "=@1", (int)CEntreeLogSynchronisation.TypeModifLogSynchro.tDelete);
foreach (CEntreeLogSynchronisation entree in liste)
{
DataTable table = GetTableSafe(entree.TableConcernee);
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)GetNewObjetForTable(table);
objet.ReadIfExists(entree.IdElement);
}
return(result);
}
//-------------------------------------
/// <summary>
/// Retourne tous les fils qui étaient affecté à l'objet à l'époque
/// </summary>
/// <param name="objet"></param>
/// <param name="relationFille"></param>
/// <returns></returns>
public int[] GetIdsChildsHistoriques(CObjetDonneeAIdNumerique objet, CInfoRelation relationFille)
{
Type tpFils = CContexteDonnee.GetTypeForTable(relationFille.TableFille);
if (!typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpFils))
{
return(new int[0]);
}
CChampPourVersionInDb champFille = new CChampPourVersionInDb(relationFille.ChampsFille[0], "");
//Recherche toutes les modifications de la propriété fille
CListeObjetsDonnees listeModifsFilles = new CListeObjetsDonnees(objet.ContexteDonnee, typeof(CVersionDonneesObjetOperation));
listeModifsFilles.Filtre = new CFiltreDataAvance(
CVersionDonneesObjetOperation.c_nomTable,
CVersionDonneesObjetOperation.c_champChamp + "=@1 and " +
CVersionDonneesObjetOperation.c_champTypeChamp + "=@2 and " +
CVersionDonneesObjet.c_nomTable + "." +
CVersionDonneesObjet.c_champTypeElement + "=@3 and " +
CVersionDonneesObjet.c_nomTable + "." +
CVersionDonnees.c_nomTable + "." +
CVersionDonnees.c_champTypeVersion + "=@4 and " +
CVersionDonneesObjet.c_nomTable + "." +
CVersionDonnees.c_champId + ">=@5",
champFille.FieldKey,
champFille.TypeChampString,
tpFils.ToString(),
(int)CTypeVersion.TypeVersion.Archive,
Id);
listeModifsFilles.Tri = CVersionDonneesObjetOperation.c_champId + " desc";
listeModifsFilles.ReadDependances("VersionObjet");
ArrayList lstFils = new ArrayList();
//Remplit la liste des fils avec les fils actuels
//Récupère la liste de tous les fils actuels
//et supprimés depuis. En effet, un element supprimé depuis cette version mais qui est
//toujours lié à l'objet était donc lié à l'objet à l'époque
C2iRequeteAvancee requete = new C2iRequeteAvancee(-1);
requete.TableInterrogee = relationFille.TableFille;
C2iChampDeRequete champDeRequete = new C2iChampDeRequete("ID",
new CSourceDeChampDeRequete(objet.ContexteDonnee.GetTableSafe(relationFille.TableFille).PrimaryKey[0].ColumnName),
typeof(int),
OperationsAgregation.None,
true);
requete.ListeChamps.Add(champDeRequete);
CFiltreData filtre = new CFiltreData(relationFille.ChampsFille[0] + "=@1 and (" +
CSc2iDataConst.c_champIdVersion + " is null or " +
CSc2iDataConst.c_champIdVersion + ">=@2)",
objet.Id,
Id);
filtre.IgnorerVersionDeContexte = true;
requete.FiltreAAppliquer = filtre;
CResultAErreur result = requete.ExecuteRequete(objet.ContexteDonnee.IdSession);
if (result)
{
foreach (DataRow row in ((DataTable)result.Data).Rows)
{
lstFils.Add(row[0]);
}
}
foreach (CVersionDonneesObjetOperation data in listeModifsFilles)
{
if (data.GetValeur() is int && (int)data.GetValeur() == objet.Id)
{
if (!lstFils.Contains(data.VersionObjet.IdElement))
{
lstFils.Add(data.VersionObjet.IdElement);
}
}
else
{
lstFils.Remove(data.VersionObjet.IdElement);
}
}
//Toutes les entités créées après la version ont également été ajoutées,
//Donc n'y étaient pas
if (lstFils.Count > 0)
{
StringBuilder builder = new StringBuilder();
foreach (int nId in lstFils)
{
builder.Append(nId.ToString());
builder.Append(",");
}
string strIds = builder.ToString();
strIds = strIds.Substring(0, strIds.Length - 1);
requete = new C2iRequeteAvancee(-1);
requete.TableInterrogee = CVersionDonneesObjet.c_nomTable;
requete.FiltreAAppliquer = new CFiltreData(
CVersionDonneesObjet.c_champIdElement + " in (" + strIds + ") and " +
CVersionDonneesObjet.c_champTypeElement + "=@1 and " +
CVersionDonneesObjet.c_champTypeOperation + "=@2 and " +
CVersionDonnees.c_champId + ">=@3",
tpFils.ToString(),
CTypeOperationSurObjet.TypeOperation.Ajout,
Id);
requete.FiltreAAppliquer.IgnorerVersionDeContexte = true;
requete.ListeChamps.Add(new C2iChampDeRequete("Id",
new CSourceDeChampDeRequete(CVersionDonneesObjet.c_champIdElement),
typeof(int),
OperationsAgregation.None,
true));
result = requete.ExecuteRequete(ContexteDonnee.IdSession);
if (result)
{
foreach (DataRow row in ((DataTable)result.Data).Rows)
{
lstFils.Remove(row[0]);
}
}
}
return((int[])lstFils.ToArray(typeof(int)));
}
//-------------------------------------
/// <summary>
/// Retourne toutes les valeurs qui ont été modifiées
/// </summary>
/// <param name="objet"></param>
/// <returns></returns>
public CValeursHistorique GetValeursModifiees(CObjetDonneeAIdNumerique objet, CVersionDonnees versionButoire)
{
CListeObjetsDonnees listeVersions = new CListeObjetsDonnees(objet.ContexteDonnee, typeof(CVersionDonneesObjet));
CValeursHistorique listeValeurs = new CValeursHistorique();
if (TypeVersion.Code != CTypeVersion.TypeVersion.Previsionnelle)
{
listeVersions.Filtre = new CFiltreDataAvance(
CVersionDonneesObjet.c_nomTable,
CVersionDonneesObjet.c_champIdElement + "=@1 and " +
CVersionDonneesObjet.c_champTypeElement + "=@2 and " +
CVersionDonnees.c_nomTable + "." +
CVersionDonnees.c_champTypeVersion + "=@3 and " +
CVersionDonnees.c_champId + ">=@4",
objet.Id,
objet.GetType().ToString(),
(int)CTypeVersion.TypeVersion.Archive,
Id);
listeVersions.Tri = CVersionDonneesObjet.c_champId + " desc";
}
else
{
CVersionDonnees versionDerivee = this;
if (versionButoire != null)
{
if (versionButoire.Id > versionDerivee.Id)
{
CVersionDonnees versionTmp = versionButoire;
versionButoire = versionDerivee;
versionDerivee = versionTmp;
}
}
StringBuilder blIds = new StringBuilder();
blIds.Append(versionDerivee.Id);
CVersionDonnees versionParente = versionDerivee.VersionParente;
while (VersionParente != null && versionButoire != null && !versionParente.Equals(versionButoire))
{
blIds.Append(",");
blIds.Append(versionParente.Id);
versionParente = versionParente.VersionParente;
}
listeVersions.Filtre = new CFiltreData(
CVersionDonnees.c_champId + " in (" + blIds + ") and " +
CVersionDonneesObjet.c_champIdElement + "=@1 and " +
CVersionDonneesObjet.c_champTypeElement + "=@2",
objet.Id,
objet.GetType().ToString());
listeVersions.Tri = CVersionDonnees.c_champId + " asc";
}
foreach (CVersionDonneesObjet version in listeVersions)
{
foreach (CVersionDonneesObjetOperation data in version.Modifications)
{
IChampPourVersion champ = data.Champ;
if (champ != null)
{
listeValeurs[champ] = data.GetValeur();
}
}
}
return(listeValeurs);
}
