void AddColumns()
{
DataColumn dc = Columns.Add(CountColumn, typeof(int));
dc.DefaultValue = 1;
RowChanged += new DataRowChangeEventHandler(SessionBundlePackRelation_RowChanged);
}
/// <summary>
/// Constructor to initialise a new provider with the business object
/// collection provided
/// </summary>
/// <param name="col">The business object collection</param>
public EditableDataSetProvider(IBusinessObjectCollection col) : base(col)
{
_rowChangedHandler = RowChangedHandler;
_rowDeletedHandler = RowDeletedHandler;
_newRowHandler = NewRowHandler;
_boAddedHandler = BOAddedHandler;
}
/// <summary>
/// Constructor to initialise a new provider with the business object
/// collection provided
/// </summary>
/// <param name="col">The business object collection</param>
public EditableDataSetProvider(IBusinessObjectCollection col) : base(col)
{
_rowChangedHandler = RowChangedHandler;
_rowDeletedHandler = RowDeletedHandler;
_newRowHandler = NewRowHandler;
_boAddedHandler = BOAddedHandler;
}
private void InitDelegateFields()
{
columnChanged = new DataColumnChangeEventHandler(OnDataTableColumnChanged);
rowDeleted = new DataRowChangeEventHandler(OnDataTableRowDeleted);
rowChanged = new DataRowChangeEventHandler(OnDataTableRowChanged);
tablesChanged = new CollectionChangeEventHandler(OnDataTableChanged);
}
public override void Load()
{
locationTableEventHandler = new DataRowChangeEventHandler(LocationTable_RowChanged);
locationTableClearEventHandler = new DataTableClearEventHandler(LocationTable_TableClearing);
DB.LocationTable.RowChanged += locationTableEventHandler;
DB.LocationTable.RowDeleting += locationTableEventHandler;
DB.LocationTable.TableClearing += locationTableClearEventHandler;
}
public override void Unload()
{
DB.NPCTable.RowChanged -= mobTableEventHandler;
DB.NPCTable.RowDeleting -= mobTableEventHandler;
DB.NPCTable.TableClearing -= mobTableClearEventHandler;
mobTableEventHandler = null;
mobTableClearEventHandler = null;
}
public override void Load()
{
mobTableEventHandler = new DataRowChangeEventHandler(MobTable_RowChanged);
mobTableClearEventHandler = new DataTableClearEventHandler(NPCTable_TableClearing);
DB.NPCTable.RowDeleting += mobTableEventHandler;
DB.NPCTable.RowChanged += mobTableEventHandler;
DB.NPCTable.TableClearing += mobTableClearEventHandler;
}
public override void Load()
{
mobTableEventHandler = new DataRowChangeEventHandler(MobTable_RowChanged);
mobTableClearEventHandler = new DataTableClearEventHandler(NPCTable_TableClearing);
DB.NPCTable.RowDeleting += mobTableEventHandler;
DB.NPCTable.RowChanged += mobTableEventHandler;
DB.NPCTable.TableClearing += mobTableClearEventHandler;
}
public override void Load()
{
areaTableEventHandler = new DataRowChangeEventHandler(AreaTable_RowChanged);
areaTableClearEventHandler = new DataTableClearEventHandler(AreaTable_TableClearing);
DB.AreaTable.RowChanged += areaTableEventHandler;
DB.AreaTable.RowDeleting += areaTableEventHandler;
DB.AreaTable.TableClearing += areaTableClearEventHandler;
}
public override void Load()
{
locationTableEventHandler = new DataRowChangeEventHandler(LocationTable_RowChanged);
locationTableClearEventHandler = new DataTableClearEventHandler(LocationTable_TableClearing);
DB.LocationTable.RowChanged += locationTableEventHandler;
DB.LocationTable.RowDeleting += locationTableEventHandler;
DB.LocationTable.TableClearing += locationTableClearEventHandler;
}
public override void Load()
{
areaTableEventHandler = new DataRowChangeEventHandler(AreaTable_RowChanged);
areaTableClearEventHandler = new DataTableClearEventHandler(AreaTable_TableClearing);
DB.AreaTable.RowChanged += areaTableEventHandler;
DB.AreaTable.RowDeleting += areaTableEventHandler;
DB.AreaTable.TableClearing += areaTableClearEventHandler;
}
/// <summary>Выполнить sql, вернуть таблицу</summary>
/// <param name="sql">SQL</param>
/// <param name="pars">Словарь параметров</param>
/// <param name="trassa">Метод для трассировки</param>
/// <returns>Таблица (пустая если нет resultset) или null, если ошибка</returns>
public static DataTable GetTable(this SqlConnection conn, string sql, Dictionary <string, object> pars = null,
Action <string, List <SqlParameter>, string> trassa = null,
SynchronizationContext sync = null, DataRowChangeEventHandler onRowChange = null, Action <object> onFinish = null)
{
var dt = conn.ExecSql(ExecSqlType.Table, sql, pars, trassa, sync, onRowChange, onFinish);
return(dt is DataTable ? (DataTable)dt : null);
}
public override void Unload()
{
DB.LocationTable.RowChanged -= locationTableEventHandler;
DB.LocationTable.RowDeleting -= locationTableEventHandler;
DB.LocationTable.TableClearing -= locationTableClearEventHandler;
locationTableEventHandler = null;
locationTableClearEventHandler = null;
}
/// <summary>
/// Extends BeginInvoke so that when a state object is not needed, null does not need to be passed.
/// <example>
/// datarowchangeeventhandler.BeginInvoke(sender, e, callback);
/// </example>
/// </summary>
public static IAsyncResult BeginInvoke(this DataRowChangeEventHandler datarowchangeeventhandler, Object sender, DataRowChangeEventArgs e, AsyncCallback callback)
{
if (datarowchangeeventhandler == null)
{
throw new ArgumentNullException("datarowchangeeventhandler");
}
return(datarowchangeeventhandler.BeginInvoke(sender, e, callback, null));
}
/*=========================*/
#endregion
#region Internal Methods
/*=========================*/
/// <summary>
/// Populates the collection with DataItem objects by binding to the data source.
/// </summary>
///
/// <remarks>
/// Calling this method clears the inner table before re-populating the list, which means
/// items contained in the collection before the binding call are disassociated from the collection
/// (their <c>DataState</c> changes to <c>DataRowState.Detached</c>). Changes to detached items
/// will not be saved when the collection is saved (unless they are re-added).
/// </remarks>
protected void Bind()
{
// Clear the table
_table.Rows.Clear();
// Clear items
_innerList.Clear();
if (_hash != null)
{
_hash.Clear();
}
if (!DataManager.ProxyMode)
{
// Attach an event handler to the table so we can create DataItems for each row added
DataRowChangeEventHandler addedHandler = new DataRowChangeEventHandler(_table_RowChanged);
_table.RowChanged += addedHandler;
SqlDataAdapter adapter = DataManager.CreateAdapter(this);
ConnectionKey ckey = null;
try
{
ckey = DataManager.Current.OpenConnection(this);
// Fill the table
adapter.Fill(this._table);
}
finally
{
DataManager.Current.CloseConnection(ckey);
}
// Detach the event so it doesn't get raised in future changes
_table.RowChanged -= addedHandler;
if (ProxyServer.InProgress)
{
ProxyServer.Current.Result[ProxyServer.Current.CurrentAction].AddData("_table", _table);
}
}
else
{
ProxyRequestAction action = ProxyClient.Request.AddAction(this, MethodInfo.GetCurrentMethod());
action.OnComplete = delegate()
{
DataTable table = ProxyClient.Result[action].GetData <DataTable>("_table");
_table = table;
// Create new items for each row using the existing handler
foreach (DataRow row in _table.Rows)
{
_table_RowChanged(_table, new DataRowChangeEventArgs(row, DataRowAction.Add));
}
};
}
}
public Aggregation (bool cacheResults, DataRow[] rows, AggregationFunction function, ColumnReference column)
{
this.cacheResults = cacheResults;
this.rows = rows;
this.column = column;
this.function = function;
this.result = null;
if (cacheResults)
RowChangeHandler = new DataRowChangeEventHandler (InvalidateCache);
}
public void DefaultFill()
{
DataRow nogroup_row = NewRow();
if (Columns[PrimaryKey].DataType == typeof(Guid))
{
nogroup_row[PrimaryKey] = Guid.Empty;
}
nogroup_row[NameColumn] = "No Group";
Rows.Add(nogroup_row);
RowDeleting += new DataRowChangeEventHandler(GameGroupTable_RowDeleting);
}
public Aggregation(bool cacheResults, DataRow[] rows, AggregationFunction function, ColumnReference column)
{
this.cacheResults = cacheResults;
this.rows = rows;
this.column = column;
this.function = function;
this.result = null;
if (cacheResults)
{
RowChangeHandler = new DataRowChangeEventHandler(InvalidateCache);
}
}
public void BindDataGrid(DataGrid dataGrid, DataRowChangeEventHandler onRowChanged)
{
if (dataGrid != null)
{
dataGrid.DataContext = this.DataTable;
dataGrid.ItemsSource = this.DataTable.DefaultView;
}
// refresh data grid binding
if (onRowChanged != null)
{
this.DataTable.RowChanged += onRowChanged;
}
}
public void DefaultFill()
{
if (Rows.Count == 0)
{
DataRow nogroup_row = NewRow();
if (Columns[PrimaryKey].DataType == typeof(Guid))
{
nogroup_row[PrimaryKey] = Guid.Empty;
}
nogroup_row[NameColumn] = "No Prize";
Rows.Add(nogroup_row);
RowDeleting += new DataRowChangeEventHandler(PrizeLevelNames_RowDeleting);
}
}
public CurrentPackCardsetRanges(DataSet set)
{
cardset_ranges = set.Tables[CardsetRange.TableName];
packs = set.Tables[PackTable.TableName];
pack_cardsets = set.Tables[PackCardsetRange.TableName];
TableName = "current_pack_cardsets";
Columns.Add(cardset_keyname = XDataTable.ID(cardset_ranges), typeof(int));
Columns.Add(XDataTable.Name(this), typeof(String));
Columns.Add(pack_keyname = PackTable.PrimaryKey, typeof(int));
Columns.Add("name", typeof(String));
set.Tables.Add(this);
RowDeleting += new DataRowChangeEventHandler(CurrentPackCardsetRanges_RowDeleting);
cardset_ranges.ColumnChanging += new DataColumnChangeEventHandler(cardset_ranges_ColumnChanging);
set.Tables[CardsetInfo.TableName].ColumnChanging += new DataColumnChangeEventHandler(CurrentPackCardsetRanges_ColumnChanging);
}
internal void SubscribeOnChangeEvents()
{
var collectionChanged = new CollectionChangeEventHandler(OnDataSetChanged);
var rowChanged = new DataRowChangeEventHandler(OnDataSetChanged);
Tables.CollectionChanged += collectionChanged;
foreach (DataTable t in Tables)
{
t.Columns.CollectionChanged += collectionChanged;
t.TableNewRow += new DataTableNewRowEventHandler(OnDataSetChanged);
t.TableCleared += new DataTableClearEventHandler(OnDataSetChanged);
t.Constraints.CollectionChanged += collectionChanged;
t.RowDeleting += rowChanged;
t.RowDeleted += rowChanged;
t.RowChanging += rowChanged;
t.RowChanged += rowChanged;
}
}
/// <summary>Выполнить sql, вернуть скалярный результат</summary>
/// <param name="sql">SQL</param>
/// <param name="pars">Словарь параметров</param>
/// <param name="trassa">Метод для трассировки</param>
/// <returns>Скалярный результат (object) или null, если ошибка или нет результата</returns>
public static object GetValue(this SqlConnection conn, string sql, Dictionary <string, object> pars = null,
Action <string, List <SqlParameter>, string> trassa = null,
SynchronizationContext sync = null, DataRowChangeEventHandler onRowChange = null, Action <object> onFinish = null)
{
return(conn.ExecSql(ExecSqlType.Scalar, sql, pars, trassa));
}
public ObjectInspector()
{
InitializeComponent();
rowchangeevent = new DataRowChangeEventHandler(RowChange);
ColumnHeadersVisible = false;
}
public void BindToDataGrid(DataGrid dataGrid, DataRowChangeEventHandler onRowChanged)
{
this.boundDataGrid = dataGrid;
this.onFileDataTableRowChanged = onRowChanged;
this.Files.BindDataGrid(dataGrid, onRowChanged);
}
public override void Unload()
{
DB.LocationTable.RowChanged -= areaTableEventHandler;
DB.LocationTable.RowDeleting-= areaTableEventHandler;
DB.AreaTable.TableClearing -= areaTableClearEventHandler;
areaTableEventHandler = null;
areaTableClearEventHandler = null;
}
public void BindToEditorDataGrid(DataGrid dataGrid, DataRowChangeEventHandler onRowChanged)
{
this.editorDataGrid = dataGrid;
this.onTemplateTableRowChanged = onRowChanged;
this.GetControlsSortedByControlOrder();
}
public override void Unload()
{
DB.NPCTable.RowChanged -= mobTableEventHandler;
DB.NPCTable.RowDeleting -= mobTableEventHandler;
DB.NPCTable.TableClearing -= mobTableClearEventHandler;
mobTableEventHandler = null;
mobTableClearEventHandler = null;
}
/// <summary>Выполнить sql, вернуть список строк</summary>
/// <param name="sql">SQL</param>
/// <param name="pars">Словарь параметров</param>
/// <param name="trassa">Метод для трассировки</param>
/// <returns>Строки полученной таблицы в виде списка</returns>
public static List <DataRow> GetTableList(this SqlConnection conn, string sql, Dictionary <string, object> pars = null,
Action <string, List <SqlParameter>, string> trassa = null,
SynchronizationContext sync = null, DataRowChangeEventHandler onRowChange = null, Action <object> onFinish = null)
{
return(conn.GetTable(sql, pars, trassa)?.AsEnumerable().ToList() ?? new List <DataRow>());
}
private void InitDelegateFields ()
{
columnChanged = new DataColumnChangeEventHandler (OnDataTableColumnChanged);
rowDeleted = new DataRowChangeEventHandler (OnDataTableRowDeleted);
rowChanged = new DataRowChangeEventHandler (OnDataTableRowChanged);
tablesChanged = new CollectionChangeEventHandler (OnDataTableChanged);
}
/// <summary>
/// /////////////////////////////////////////////////////////////////////////////////
/// </summary>
/// <param name="table"></param>
/// <param name="result"></param>
///
private static CResultAErreur TraitementAvantSauvegardeExterne(CContexteDonnee contexte, Hashtable tableData)
{
CResultAErreur result = CResultAErreur.True;
///Stef 22/07/08 : l'appel à shouldDeclenche peut
///nécessiter GetValeurChamp (si conditions sur des champs). Or, si un élément n'a pas
///de valeur pour un champ, l'appli va aller chercher la valeur par défaut de ce
///champ, si le champ n'est pas chargé, l'appli va le lire. Comme on est souvent
///dans un contexte sans gestion par tables complètes, on est mal, parce que
///ça va génerer une requête par champ.
///Donc, on lit tous les champs custom avant de commencer
CListeObjetsDonnees listeChamps = new CListeObjetsDonnees(contexte, typeof(CChampCustom));
listeChamps.PreserveChanges = true; //Pour ne pas modifier les champs modifiés
listeChamps.AssureLectureFaite();
DateTime dt = DateTime.Now;
CTraitementApresSauvegarde traitement = new CTraitementApresSauvegarde( );
ArrayList lstTables = CContexteDonnee.GetTablesOrderInsert(contexte);
//Pour empêcher de regarder deux fois les évenements d'un même objet
//Type->Dictionnaire des ids vus
Dictionary <Type, Dictionary <int, bool> > elementsVus = new Dictionary <Type, Dictionary <int, bool> >();
DataRowChangeEventHandler handlerRedo = new DataRowChangeEventHandler(table_RowChanged);
Dictionary <string, Dictionary <int, bool> > listeElementsARepasser = null;
if (!m_listeElementsARepasser.TryGetValue(contexte, out listeElementsARepasser))
{
listeElementsARepasser = new Dictionary <string, Dictionary <int, bool> >();
m_listeElementsARepasser[contexte] = listeElementsARepasser;
}
bool bFirstPasse = true;
int nLimiteurPasses = 0;
while ((bFirstPasse | listeElementsARepasser.Count > 0) && nLimiteurPasses < 5)
{
nLimiteurPasses++;
foreach (DataTable table in lstTables)
{
if (table.Rows.Count > 0 && table.PrimaryKey.Length == 1)
{
string strChampCle = table.PrimaryKey[0].ColumnName;
Type tpObjets = CContexteDonnee.GetTypeForTable(table.TableName);
if (!typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpObjets))
{
continue;
}
Type typeOriginal = tpObjets;
//Lors de la modif de champs custom, l'élement parent n'est pas forcement modifié
//Mais le champ peut l'être
if (tpObjets.IsSubclassOf(typeof(CRelationElementAChamp_ChampCustom)))
{
int nLigne = 0;
bool bGoOut = false;
while (table.Rows.Count > nLigne && !bGoOut)
{
if (table.Rows[nLigne].RowState != DataRowState.Deleted)
{
CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)contexte.GetNewObjetForRow(table.Rows[nLigne]);
tpObjets = rel.ElementAChamps.GetType();
strChampCle = ((CObjetDonnee)rel.ElementAChamps).GetChampsId()[0];
bGoOut = true;
}
nLigne++;
}
}
//Les objets qui n'ont pas de relationTypeId ne peuvent pas avoir d'évenements
if (tpObjets.GetCustomAttributes(typeof(NoRelationTypeIdAttribute), true).Length > 0)
{
continue;
}
ArrayList lstEvenements = GetListeEvenementsAutoSur(tpObjets, contexte.IdVersionDeTravail);
//Id des éléments modifiés
List <int> listeIdsElementsAVerifierHandlers = new List <int>();
string strPrimaryKey = "";
if (table.PrimaryKey.Length == 1 &&
table.PrimaryKey[0].DataType == typeof(int))
{
strPrimaryKey = table.PrimaryKey[0].ColumnName;
}
Dictionary <int, bool> tableIdsVues = null;
if (!elementsVus.TryGetValue(tpObjets, out tableIdsVues))
{
tableIdsVues = new Dictionary <int, bool>();
elementsVus[tpObjets] = tableIdsVues;
}
Dictionary <int, bool> listeARepasserPourTable = null;
if (!listeElementsARepasser.TryGetValue(table.TableName, out listeARepasserPourTable))
{
listeARepasserPourTable = null;
}
List <CObjetDonnee> lstObjetsAvecEvenementsSpecifiques = new List <CObjetDonnee>();
//Stef 16/11/2012 :
//Si c'est un élément à champs, il est consideré comme modifié
//si un de ses champs custom est modifiés
//Ca a été fait parce que les handlers d'évenement n'étaient
//Pas pris en compte sur modif de champ custom
//On n'enlève pas pour autant l'ancienne méthode qui consiste
//à considérer l'élément modifié losrqu'on passe sur la table des
//valeurs de champs custom
if (typeof(IObjetDonneeAChamps).IsAssignableFrom(typeOriginal) && table.Rows.Count > 0)
{
//Regarde s'il y a des relations
IObjetDonneeAChamps objAChamp = contexte.GetNewObjetForRow(table.Rows[0]) as IObjetDonneeAChamps;
string strTableChamps = objAChamp.GetNomTableRelationToChamps();
//Trouve la relation à la table
DataTable tableChamps = contexte.Tables[strTableChamps];
if (tableChamps != null)//Si la table champs n'est pas là, c'est
//qu'elle n'a pas été modifiée !! c'est logique çà
{
DataRelation rel = null;
foreach (DataRelation relTest in tableChamps.ParentRelations)
{
if (relTest.ParentTable.TableName == table.TableName)
{
rel = relTest;
break;
}
}
if (rel != null)//On peut vérifier !
{
foreach (DataRow row in new ArrayList(table.Rows))
{
if (row.RowState == DataRowState.Unchanged)//sinon, ce n'est pas la peine
{
DataRow[] rowsChamps = row.GetChildRows(rel);
foreach (DataRow rowChamp in rowsChamps)
{
if (rowChamp.RowState != DataRowState.Unchanged)
{
//Aloue l'objet pour s'assurer que la ligne est bien pleine
CObjetDonnee objTmp = contexte.GetNewObjetForRow(row);
objTmp.AssureData();
row.SetModified();
string strOldContexte = (string)row[CObjetDonnee.c_champContexteModification];
if (strOldContexte.Length == 0)
{
row[CObjetDonnee.c_champContexteModification] = rowChamp[CObjetDonnee.c_champContexteModification,
rowChamp.RowState == DataRowState.Deleted ? DataRowVersion.Original : DataRowVersion.Current] as string;
}
break;
}
}
}
}
}
}
}
foreach (DataRow row in new ArrayList(table.Rows))
{
CObjetDonneeAIdNumerique objet = null;
if (lstEvenements.Count > 0)
{
if (row.RowState == DataRowState.Added ||
row.RowState == DataRowState.Modified ||
row.RowState == DataRowState.Deleted)
{
objet = (CObjetDonneeAIdNumerique)((CContexteDonnee)table.DataSet).GetNewObjetForRow(row);
if (objet.Row.RowState == DataRowState.Deleted)
{
objet.VersionToReturn = DataRowVersion.Original;
}
if (objet.Row.RowState != DataRowState.Deleted && EvenementAttribute.HasEventsSpecifiques(objet))
{
lstObjetsAvecEvenementsSpecifiques.Add(objet);
}
if (typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(typeOriginal))
{
CRelationElementAChamp_ChampCustom rel = objet as CRelationElementAChamp_ChampCustom;
objet = (CObjetDonneeAIdNumerique)((CRelationElementAChamp_ChampCustom)objet).ElementAChamps;
if (objet.Row.RowState == DataRowState.Unchanged)
{
objet.Row.Row.SetModified();
}
if (objet.Row.RowState == DataRowState.Deleted)
{
objet.VersionToReturn = DataRowVersion.Original;
}
if (rel.ContexteDeModification.Length != 0 &&
objet.ContexteDeModification.Length == 0)
{
objet.ContexteDeModification = rel.ContexteDeModification;
}
}
if (!tableIdsVues.ContainsKey(objet.Id) || (
listeARepasserPourTable != null && listeARepasserPourTable.ContainsKey(objet.Id)))
{
tableIdsVues[objet.Id] = true;
foreach (CEvenement evt in lstEvenements)
{
if (!traitement.ContainsCouple(evt, (CObjetDonneeAIdNumerique)objet))
{
//Attention, si c'est une valeur de champ custom, envoie la valeur,
//c'est elle qui sera testée.
CInfoDeclencheurProcess infoDeclencheur = null;
if (evt.ShouldDeclenche((CObjetDonneeAIdNumerique)objet, ref infoDeclencheur))
{
infoDeclencheur.DbKeyEvenementDeclencheur = evt.DbKey;
infoDeclencheur.Info = evt.Libelle;
traitement.AddCoupleEvenementObjet(evt, (CObjetDonneeAIdNumerique)objet, infoDeclencheur);
}
}
}
}
}
}
//Regarde les handle d'évenement sur l'objet
if (strPrimaryKey != "" && (row.RowState == DataRowState.Modified))
{
listeIdsElementsAVerifierHandlers.Add((int)row[strPrimaryKey]);
}
}
if (listeARepasserPourTable != null)
{
listeARepasserPourTable.Clear();
}
if (listeIdsElementsAVerifierHandlers.Count > 0 && bFirstPasse)
{
//traitement par paquet de 500
for (int nIndexLot = 0; nIndexLot < listeIdsElementsAVerifierHandlers.Count; nIndexLot += 500)
{
int nMin = Math.Min(nIndexLot + 500, listeIdsElementsAVerifierHandlers.Count);
StringBuilder bl = new StringBuilder();
for (int nIndex = nIndexLot; nIndex < nMin; nIndex++)
{
bl.Append(listeIdsElementsAVerifierHandlers[nIndex].ToString());
bl.Append(",");
}
string strIdsElementsAVerifierHandlers = bl.ToString().Substring(0, bl.ToString().Length - 1);
//Recherche tous les handlers d'évenement pour les objets concernés
CListeObjetsDonnees listeHandler = new CListeObjetsDonnees(contexte, typeof(CHandlerEvenement));
listeHandler.Filtre = new CFiltreData(
CHandlerEvenement.c_champIdCible + " in (" + strIdsElementsAVerifierHandlers + ") and " +
CHandlerEvenement.c_champTypeCible + "=@1 and " +
CHandlerEvenement.c_champTypeEvenement + "=@2",
tpObjets.ToString(),
(int)TypeEvenement.Modification);
listeHandler.PreserveChanges = true;
foreach (CHandlerEvenement handler in listeHandler)
{
if (handler.Row.RowState != DataRowState.Deleted)
{
CObjetDonneeAIdNumerique objetTmp = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tpObjets, new object[] { contexte });
if (objetTmp.ReadIfExists(handler.IdElementCible))
{
CInfoDeclencheurProcess infoDeclencheur = null;
if (handler.ShoulDeclenche(objetTmp, ref infoDeclencheur))
{
if (infoDeclencheur != null && handler.EvenementLie != null)
{
infoDeclencheur.Info = handler.EvenementLie.Libelle;
}
traitement.AddCoupleHandlerObjet(handler, (CObjetDonneeAIdNumerique)objetTmp, infoDeclencheur);
}
}
}
}
}
}
//Annule les évenements spécifiques, ils ont été traités !
foreach (CObjetDonnee objet in lstObjetsAvecEvenementsSpecifiques)
{
EvenementAttribute.ClearEvenements(objet);
}
}
}
//Execute ce qui peut être executé tout de suite
foreach (DataTable table in contexte.Tables)
{
table.RowChanged += handlerRedo;
}
listeElementsARepasser.Clear();
foreach (CTraitementApresSauvegarde.CCoupleDeclencheurObjet couple in traitement.CouplesEvenementOuHandlerObjet)
{
if (couple.Objet is CObjetDonneeAIdNumerique &&
couple.PeutEtreExecuteSurLePosteClient)
{
result = couple.OnDeclencheSurClient();
if (!result)
{
return(result);
}
}
}
foreach (DataTable table in contexte.Tables)
{
table.RowChanged -= handlerRedo;
}
bFirstPasse = false;
}
if (traitement.CouplesEvenementOuHandlerObjet.Count != 0)
{
tableData[c_cleDonneeListeTraitements] = traitement;
}
m_listeElementsARepasser.Remove(contexte);
return(result);
}
public override void BeginInit()
{
base.BeginInit();
RowChanging += new DataRowChangeEventHandler(tblPeopleDataTable_RowChanging);
}
/// <summary>Выполнить sql, вернуть кол-во обработанных строк</summary>
/// <param name="sql">SQL</param>
/// <param name="pars">Словарь параметров ключ-значение</param>
/// <param name="trassa">Метод для трассировки</param>
/// <returns>Количество обработанных строк, -1 если ошибка</returns>
public static int ExecCommand(this SqlConnection conn, string sql, Dictionary <string, object> pars = null,
Action <string, List <SqlParameter>, string> trassa = null,
SynchronizationContext sync = null, DataRowChangeEventHandler onRowChange = null, Action <object> onFinish = null)
{
return((int)conn.ExecSql(ExecSqlType.NonQuery, sql, pars, trassa));
}
/// <summary>Выполнить sql</summary>
/// <param name="execType">Определяет тип выполнения и результат (Table - через DataAdapter вернет DataTable, Scalar - через ExecuteScalar вернет object, NonQuery - через ExecuteNonQuery вернет int)</param>
/// <param name="sql">SQL</param>
/// <param name="pars">Словарь параметров</param>
/// <param name="trassa">Метод для трассировки</param>
/// <returns>В зависимости от execType. В случае ошибки вернет null или -1 для NonQuery</returns>
public static object ExecSql(this SqlConnection conn, ExecSqlType execType, string sql, Dictionary <string, object> pars,
Action <string, List <SqlParameter>, string> trassa = null,
SynchronizationContext sync = null, DataRowChangeEventHandler onRowChange = null, Action <object> onFinish = null,
int?cmdTimeout = null)
{
object res = null;
if (sync == null)
{
sync = SynchronizationContext.Current;
}
if (cmdTimeout == null)
{
int t;
if (int.TryParse(AppConfig.GetPropValue("CommandTimeout"), out t))
{
cmdTimeout = t;
}
}
if (string.IsNullOrWhiteSpace(sql))
{
sync.Send(o => Loger.SendMess($"Не указан запрос", true), null);
return(res);
}
try {
List <SqlParameter> ps = null;
if (pars != null)
{
ps = new List <SqlParameter>();
foreach (var p in pars)
{
object value = p.Value;
if (value is DateTime && ((DateTime)value).Equals(DateTime.MinValue))
{
value = null;
}
if (value is bool)
{
value = ((bool)value ? 1 : 0);
}
ps.Add(new SqlParameter(p.Key, value ?? DBNull.Value));
}
}
sync.Send(o => trassa?.Invoke(sql, ps, conn.ConnectionString), null);
if (execType == ExecSqlType.NonQuery || execType == ExecSqlType.Scalar)
{
var cmd = new SqlCommand(sql, conn);
if (cmdTimeout != null)
{
cmd.CommandTimeout = (int)cmdTimeout;
}
if (ps != null)
{
cmd.Parameters.AddRange(ps.ToArray());
}
conn.Open();
res = (execType == ExecSqlType.NonQuery ? cmd.ExecuteNonQuery() : cmd.ExecuteScalar());
}
if (execType == ExecSqlType.Table)
{
using (SqlDataAdapter da = new SqlDataAdapter(sql, conn)) {
if (cmdTimeout != null)
{
da.SelectCommand.CommandTimeout = (int)cmdTimeout;
}
if (ps != null)
{
da.SelectCommand.Parameters.AddRange(ps.ToArray());
}
res = new DataTable();
if (onRowChange != null)
{
((DataTable)res).RowChanged += onRowChange;
}
da.Fill((DataTable)res);
}
}
}
catch (ThreadAbortException) {
//
}
catch (Exception e) {
sync.Send(o => Loger.SendMess(e, "Ошибка выполнения запроса"), null);
res = null;
}
finally {
if (res is DataTable && onRowChange != null)
{
((DataTable)res).RowChanged -= onRowChange;
}
conn.Close();
if (onFinish != null)
{
sync.Send(o => onFinish(res), null);
}
}
if (execType == ExecSqlType.NonQuery && res == null)
{
res = -1;
}
return(res);
}
