mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
838 lines
34 KiB
C#
838 lines
34 KiB
C#
namespace System.Web.UI.WebControls {
|
|
using System.Web.UI.WebControls.Expressions;
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Specialized;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Security.Permissions;
|
|
using System.Web;
|
|
using System.Web.Resources;
|
|
using System.Web.UI;
|
|
using System.Web.UI.WebControls;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.ComponentModel;
|
|
|
|
|
|
public abstract class QueryableDataSourceView : DataSourceView, IStateManager {
|
|
//basic query parameters for any Queryable source
|
|
private ParameterCollection _whereParameters;
|
|
private ParameterCollection _orderByParameters;
|
|
private ParameterCollection _orderGroupsByParameters;
|
|
private ParameterCollection _selectNewParameters;
|
|
private ParameterCollection _groupByParameters;
|
|
|
|
// CUD operations
|
|
private ParameterCollection _deleteParameters;
|
|
private ParameterCollection _updateParameters;
|
|
private ParameterCollection _insertParameters;
|
|
|
|
private HttpContext _context;
|
|
private DataSourceControl _owner;
|
|
private IDynamicQueryable _queryable;
|
|
|
|
private string _groupBy;
|
|
private string _orderBy;
|
|
private string _orderGroupsBy;
|
|
private string _selectNew;
|
|
private string _where;
|
|
|
|
private bool _autoGenerateOrderByClause;
|
|
private bool _autoGenerateWhereClause;
|
|
private bool _autoPage = true;
|
|
private bool _autoSort = true;
|
|
private bool _isTracking;
|
|
|
|
protected static readonly object EventSelected = new object();
|
|
protected static readonly object EventSelecting = new object();
|
|
private static readonly object EventQueryCreated = new object();
|
|
|
|
// using Hashtable for original values so that ObjectStateFormatter will serialize it properly in ViewState.
|
|
private Hashtable _originalValues;
|
|
|
|
|
|
protected QueryableDataSourceView(DataSourceControl owner, string viewName, HttpContext context)
|
|
: this(owner, viewName, context, new DynamicQueryableWrapper()) {
|
|
_context = context;
|
|
_owner = owner;
|
|
}
|
|
|
|
internal QueryableDataSourceView(DataSourceControl owner, string viewName, HttpContext context, IDynamicQueryable queryable)
|
|
: base(owner, viewName) {
|
|
_context = context;
|
|
_queryable = queryable;
|
|
_owner = owner;
|
|
}
|
|
|
|
public bool AutoGenerateOrderByClause {
|
|
get {
|
|
return _autoGenerateOrderByClause;
|
|
}
|
|
set {
|
|
if (_autoGenerateOrderByClause != value) {
|
|
_autoGenerateOrderByClause = value;
|
|
OnDataSourceViewChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool AutoGenerateWhereClause {
|
|
get {
|
|
return _autoGenerateWhereClause;
|
|
}
|
|
set {
|
|
if (_autoGenerateWhereClause != value) {
|
|
_autoGenerateWhereClause = value;
|
|
OnDataSourceViewChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual bool AutoPage {
|
|
get {
|
|
return _autoPage;
|
|
}
|
|
set {
|
|
if (_autoPage != value) {
|
|
_autoPage = value;
|
|
OnDataSourceViewChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual bool AutoSort {
|
|
get {
|
|
return _autoSort;
|
|
}
|
|
set {
|
|
if (_autoSort != value) {
|
|
_autoSort = value;
|
|
OnDataSourceViewChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override bool CanDelete {
|
|
get {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public override bool CanInsert {
|
|
get {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// When AutoPage is false the user should manually page in the Selecting event.
|
|
public override bool CanPage {
|
|
get {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// When AutoPage is false the user must set the total row count in the Selecting event.
|
|
public override bool CanRetrieveTotalRowCount {
|
|
get {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// When AutoSort is false the user should manually sort in the Selecting event.
|
|
public override bool CanSort {
|
|
get {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public override bool CanUpdate {
|
|
get {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public virtual ParameterCollection DeleteParameters {
|
|
get {
|
|
if (_deleteParameters == null) {
|
|
_deleteParameters = new ParameterCollection();
|
|
}
|
|
return _deleteParameters;
|
|
}
|
|
}
|
|
|
|
protected abstract Type EntityType {
|
|
get;
|
|
}
|
|
|
|
public virtual ParameterCollection GroupByParameters {
|
|
get {
|
|
if (_groupByParameters == null) {
|
|
_groupByParameters = new ParameterCollection();
|
|
_groupByParameters.ParametersChanged += new EventHandler(OnQueryParametersChanged);
|
|
if (_isTracking) {
|
|
DataSourceHelper.TrackViewState(_groupByParameters);
|
|
}
|
|
}
|
|
return _groupByParameters;
|
|
}
|
|
}
|
|
|
|
protected bool IsTrackingViewState {
|
|
get {
|
|
return _isTracking;
|
|
}
|
|
}
|
|
|
|
public virtual ParameterCollection InsertParameters {
|
|
get {
|
|
if (_insertParameters == null) {
|
|
_insertParameters = new ParameterCollection();
|
|
}
|
|
return _insertParameters;
|
|
}
|
|
}
|
|
|
|
public virtual ParameterCollection OrderByParameters {
|
|
get {
|
|
if (_orderByParameters == null) {
|
|
_orderByParameters = new ParameterCollection();
|
|
_orderByParameters.ParametersChanged += new EventHandler(OnQueryParametersChanged);
|
|
if (_isTracking) {
|
|
DataSourceHelper.TrackViewState(_orderByParameters);
|
|
}
|
|
}
|
|
return _orderByParameters;
|
|
}
|
|
}
|
|
|
|
public virtual ParameterCollection OrderGroupsByParameters {
|
|
get {
|
|
if (_orderGroupsByParameters == null) {
|
|
_orderGroupsByParameters = new ParameterCollection();
|
|
_orderGroupsByParameters.ParametersChanged += new EventHandler(OnQueryParametersChanged);
|
|
if (_isTracking) {
|
|
DataSourceHelper.TrackViewState(_orderGroupsByParameters);
|
|
}
|
|
}
|
|
return _orderGroupsByParameters;
|
|
}
|
|
}
|
|
|
|
|
|
public virtual string OrderBy {
|
|
get {
|
|
return _orderBy ?? String.Empty;
|
|
}
|
|
set {
|
|
if (_orderBy != value) {
|
|
_orderBy = value;
|
|
OnDataSourceViewChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public virtual string OrderGroupsBy {
|
|
get {
|
|
return _orderGroupsBy ?? String.Empty;
|
|
}
|
|
set {
|
|
if (_orderGroupsBy != value) {
|
|
_orderGroupsBy = value;
|
|
OnDataSourceViewChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual string GroupBy {
|
|
get {
|
|
return _groupBy ?? String.Empty;
|
|
}
|
|
set {
|
|
if (_groupBy != value) {
|
|
_groupBy = value;
|
|
OnDataSourceViewChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual ParameterCollection SelectNewParameters {
|
|
get {
|
|
if (_selectNewParameters == null) {
|
|
_selectNewParameters = new ParameterCollection();
|
|
_selectNewParameters.ParametersChanged += new EventHandler(OnQueryParametersChanged);
|
|
if (_isTracking) {
|
|
DataSourceHelper.TrackViewState(_selectNewParameters);
|
|
}
|
|
}
|
|
return _selectNewParameters;
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Naming", "CA1711:IdentifiersShouldNotHaveIncorrectSuffix",
|
|
Justification = "SelectNew refers to a projection and 'New' is not used as a suffix in this case")]
|
|
public virtual string SelectNew {
|
|
get {
|
|
return _selectNew ?? String.Empty;
|
|
}
|
|
set {
|
|
if (_selectNew != value) {
|
|
_selectNew = value;
|
|
OnDataSourceViewChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual ParameterCollection WhereParameters {
|
|
get {
|
|
if (_whereParameters == null) {
|
|
_whereParameters = new ParameterCollection();
|
|
_whereParameters.ParametersChanged += new EventHandler(OnQueryParametersChanged);
|
|
if (_isTracking) {
|
|
DataSourceHelper.TrackViewState(_whereParameters);
|
|
}
|
|
}
|
|
return _whereParameters;
|
|
}
|
|
}
|
|
|
|
public virtual string Where {
|
|
get {
|
|
return _where ?? String.Empty;
|
|
}
|
|
set {
|
|
if (_where != value) {
|
|
_where = value;
|
|
OnDataSourceViewChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public virtual ParameterCollection UpdateParameters {
|
|
get {
|
|
if (_updateParameters == null) {
|
|
_updateParameters = new ParameterCollection();
|
|
}
|
|
return _updateParameters;
|
|
}
|
|
}
|
|
|
|
|
|
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", Justification = "Derived classes will use this to as the ParametersChanged EventHandler")]
|
|
protected void OnQueryParametersChanged(object sender, EventArgs e) {
|
|
RaiseViewChanged();
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Design", "CA1030:UseEventsWhereAppropriate", Justification = "An event exists already and it it protected")]
|
|
public void RaiseViewChanged() {
|
|
OnDataSourceViewChanged(EventArgs.Empty);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the result to apply query
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
protected abstract object GetSource(QueryContext context);
|
|
|
|
protected QueryContext CreateQueryContext(DataSourceSelectArguments arguments) {
|
|
IDictionary<string, object> whereParameters = WhereParameters.ToDictionary(_context, _owner);
|
|
IOrderedDictionary orderByParameters = OrderByParameters.GetValues(_context, _owner).ToCaseInsensitiveDictionary();
|
|
IDictionary<string, object> orderGroupsByParameters = OrderGroupsByParameters.ToDictionary(_context, _owner);
|
|
IDictionary<string, object> selectNewParameters = SelectNewParameters.ToDictionary(_context, _owner);
|
|
IDictionary<string, object> groupByParameters = GroupByParameters.ToDictionary(_context, _owner);
|
|
|
|
return new QueryContext(
|
|
whereParameters,
|
|
orderGroupsByParameters,
|
|
orderByParameters,
|
|
groupByParameters,
|
|
selectNewParameters,
|
|
arguments);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a select expression based on parameters and properties
|
|
/// </summary>
|
|
protected virtual IQueryable BuildQuery(DataSourceSelectArguments arguments) {
|
|
if (arguments == null) {
|
|
throw new ArgumentNullException("arguments");
|
|
}
|
|
|
|
// Create the query context
|
|
QueryContext context = CreateQueryContext(arguments);
|
|
|
|
// Clear out old values before selecting new data
|
|
_originalValues = null;
|
|
|
|
// Get the source of the query(root IQueryable)
|
|
object result = GetSource(context);
|
|
|
|
if (result != null) {
|
|
IQueryable source = QueryableDataSourceHelper.AsQueryable(result);
|
|
// Apply additional filterting
|
|
return ExecuteQuery(source, context);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
protected virtual IQueryable ExecuteQuery(IQueryable source, QueryContext context) {
|
|
// Execute Query
|
|
source = ExecuteQueryExpressions(source, context);
|
|
|
|
// Execute Sorting
|
|
source = ExecuteSorting(source, context);
|
|
|
|
// Execute Paging
|
|
source = ExecutePaging(source, context);
|
|
|
|
return source;
|
|
}
|
|
|
|
protected IQueryable ExecuteQueryExpressions(IQueryable source, QueryContext context) {
|
|
if (source != null) {
|
|
QueryCreatedEventArgs queryArgs = new QueryCreatedEventArgs(source);
|
|
OnQueryCreated(queryArgs);
|
|
source = queryArgs.Query ?? source;
|
|
|
|
// Support the Dynamic Expression language used by LinqDataSource
|
|
if (AutoGenerateWhereClause) {
|
|
if (!String.IsNullOrEmpty(Where)) {
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.LinqDataSourceView_WhereAlreadySpecified, _owner.ID));
|
|
}
|
|
source = QueryableDataSourceHelper.CreateWhereExpression(context.WhereParameters, source, _queryable);
|
|
}
|
|
else if (!String.IsNullOrEmpty(Where)) {
|
|
source = _queryable.Where(source, Where, context.WhereParameters.ToEscapedParameterKeys(_owner));
|
|
}
|
|
|
|
if (AutoGenerateOrderByClause) {
|
|
if (!String.IsNullOrEmpty(OrderBy)) {
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.LinqDataSourceView_OrderByAlreadySpecified, _owner.ID));
|
|
}
|
|
source = QueryableDataSourceHelper.CreateOrderByExpression(context.OrderByParameters, source, _queryable);
|
|
}
|
|
else if (!String.IsNullOrEmpty(OrderBy)) {
|
|
source = _queryable.OrderBy(source, OrderBy, context.OrderByParameters.ToEscapedParameterKeys(_owner));
|
|
}
|
|
|
|
|
|
string groupBy = GroupBy;
|
|
if (String.IsNullOrEmpty(groupBy)) {
|
|
if (!String.IsNullOrEmpty(OrderGroupsBy)) {
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.LinqDataSourceView_OrderGroupsByRequiresGroupBy, _owner.ID));
|
|
}
|
|
}
|
|
else {
|
|
source = _queryable.GroupBy(source, groupBy, "it", context.GroupByParameters.ToEscapedParameterKeys(_owner));
|
|
if (!String.IsNullOrEmpty(OrderGroupsBy)) {
|
|
source = _queryable.OrderBy(source, OrderGroupsBy, context.OrderGroupsByParameters.ToEscapedParameterKeys(_owner));
|
|
}
|
|
}
|
|
|
|
if (!String.IsNullOrEmpty(SelectNew)) {
|
|
source = _queryable.Select(source, SelectNew, context.SelectParameters.ToEscapedParameterKeys(_owner));
|
|
}
|
|
|
|
return source;
|
|
}
|
|
|
|
return source;
|
|
}
|
|
|
|
protected IQueryable ExecuteSorting(IQueryable source, QueryContext context) {
|
|
string sortExpression = context.Arguments.SortExpression;
|
|
|
|
if (CanSort && AutoSort && !String.IsNullOrEmpty(sortExpression)) {
|
|
source = _queryable.OrderBy(source, sortExpression);
|
|
}
|
|
return source;
|
|
}
|
|
|
|
protected IQueryable ExecutePaging(IQueryable source, QueryContext context) {
|
|
if (CanPage && AutoPage) {
|
|
if (CanRetrieveTotalRowCount && context.Arguments.RetrieveTotalRowCount) {
|
|
context.Arguments.TotalRowCount = _queryable.Count(source);
|
|
}
|
|
|
|
if ((context.Arguments.MaximumRows > 0) && (context.Arguments.StartRowIndex >= 0)) {
|
|
source = _queryable.Skip(source, context.Arguments.StartRowIndex);
|
|
source = _queryable.Take(source, context.Arguments.MaximumRows);
|
|
}
|
|
}
|
|
else if (context.Arguments.RetrieveTotalRowCount && (context.Arguments.TotalRowCount == -1)) {
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.LinqDataSourceView_PagingNotHandled, _owner.ID));
|
|
}
|
|
return source;
|
|
}
|
|
|
|
protected virtual void LoadViewState(object savedState) {
|
|
if (savedState != null) {
|
|
object[] myState = (object[])savedState;
|
|
|
|
if (myState[0] != null) {
|
|
((IStateManager)WhereParameters).LoadViewState(myState[0]);
|
|
}
|
|
if (myState[1] != null) {
|
|
((IStateManager)OrderByParameters).LoadViewState(myState[1]);
|
|
}
|
|
if (myState[2] != null) {
|
|
((IStateManager)GroupByParameters).LoadViewState(myState[2]);
|
|
}
|
|
if (myState[3] != null) {
|
|
((IStateManager)OrderGroupsByParameters).LoadViewState(myState[3]);
|
|
}
|
|
if (myState[4] != null) {
|
|
((IStateManager)SelectNewParameters).LoadViewState(myState[4]);
|
|
}
|
|
if (myState[5] != null) {
|
|
_originalValues = (Hashtable)myState[5];
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual object SaveViewState() {
|
|
object[] myState = new object[6];
|
|
myState[0] = DataSourceHelper.SaveViewState(_whereParameters);
|
|
myState[1] = DataSourceHelper.SaveViewState(_orderByParameters);
|
|
myState[2] = DataSourceHelper.SaveViewState(_groupByParameters);
|
|
myState[3] = DataSourceHelper.SaveViewState(_orderGroupsByParameters);
|
|
myState[4] = DataSourceHelper.SaveViewState(_selectNewParameters);
|
|
if ((_originalValues != null) && (_originalValues.Count > 0)) {
|
|
myState[5] = _originalValues;
|
|
}
|
|
|
|
return myState;
|
|
}
|
|
|
|
|
|
protected virtual void TrackViewState() {
|
|
_isTracking = true;
|
|
DataSourceHelper.TrackViewState(_whereParameters);
|
|
DataSourceHelper.TrackViewState(_orderByParameters);
|
|
DataSourceHelper.TrackViewState(_groupByParameters);
|
|
DataSourceHelper.TrackViewState(_orderGroupsByParameters);
|
|
DataSourceHelper.TrackViewState(_selectNewParameters);
|
|
}
|
|
|
|
protected internal override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments) {
|
|
ClearOriginalValues();
|
|
|
|
IQueryable source = BuildQuery(arguments);
|
|
|
|
IList results = source.ToList(source.ElementType);
|
|
|
|
// Store original values for concurrency
|
|
StoreOriginalValues(results);
|
|
|
|
return results;
|
|
}
|
|
|
|
protected void ClearOriginalValues() {
|
|
_originalValues = null;
|
|
}
|
|
|
|
protected virtual IDictionary GetOriginalValues(IDictionary keys) {
|
|
// Table data is stored in a hashtable with column names for keys and an ArrayList of row data for values.
|
|
// i.e, Hashtable { ID = ArrayList { 0, 1, 2 }, Name = ArrayList { "A", "B", "C" } }
|
|
if (_originalValues != null) {
|
|
// matches list keeps track of row indexes which match.
|
|
List<bool> matches = new List<bool>();
|
|
foreach (DictionaryEntry entry in keys) {
|
|
string propertyName = (String)entry.Key;
|
|
if (_originalValues.ContainsKey(propertyName)) {
|
|
object propertyValue = entry.Value;
|
|
// get the row values for the current column.
|
|
ArrayList values = (ArrayList)_originalValues[propertyName];
|
|
for (int i = 0; i < values.Count; i++) {
|
|
if (matches.Count <= i) { // first column
|
|
matches.Add(OriginalValueMatches(values[i], propertyValue));
|
|
}
|
|
else if (matches[i] == true) { // subsequent columns
|
|
matches[i] = OriginalValueMatches(values[i], propertyValue);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int rowIndex = matches.IndexOf(true);
|
|
// no rows match or too many rows match.
|
|
if ((rowIndex < 0) || (matches.IndexOf(true, rowIndex + 1) >= 0)) {
|
|
throw new InvalidOperationException(AtlasWeb.LinqDataSourceView_OriginalValuesNotFound);
|
|
}
|
|
// get original values for the matching row.
|
|
Dictionary<string, object> rowValues = new Dictionary<string, object>(_originalValues.Count,
|
|
StringComparer.OrdinalIgnoreCase);
|
|
foreach (DictionaryEntry entry in _originalValues) {
|
|
ArrayList value = (ArrayList)entry.Value;
|
|
rowValues.Add((string)entry.Key, value[rowIndex]);
|
|
}
|
|
return rowValues;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
protected virtual void StoreOriginalValues(IList results) {
|
|
// Derived classes can override this function and call the overload
|
|
// to determine which columns it should store for optimistic concurrency
|
|
}
|
|
|
|
protected void StoreOriginalValues(IList results, Func<PropertyDescriptor, bool> include) {
|
|
PropertyDescriptorCollection props = TypeDescriptor.GetProperties(EntityType);
|
|
int numRows = results.Count;
|
|
int maxColumns = props.Count;
|
|
_originalValues = new Hashtable(maxColumns, StringComparer.OrdinalIgnoreCase);
|
|
foreach (PropertyDescriptor p in props) {
|
|
if (include(p) && p.PropertyType.IsSerializable) {
|
|
ArrayList values = new ArrayList(numRows);
|
|
_originalValues[p.Name] = values;
|
|
foreach (object currentRow in results) {
|
|
values.Add(p.GetValue(currentRow));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public int Update(IDictionary keys, IDictionary values, IDictionary oldValues) {
|
|
return ExecuteUpdate(keys, values, oldValues);
|
|
}
|
|
|
|
public int Delete(IDictionary keys, IDictionary oldValues) {
|
|
return ExecuteDelete(keys, oldValues);
|
|
}
|
|
|
|
public int Insert(IDictionary values) {
|
|
return ExecuteInsert(values);
|
|
}
|
|
|
|
protected QueryableDataSourceEditData BuildDeleteObject(IDictionary keys, IDictionary oldValues, IDictionary<string, Exception> validationErrors) {
|
|
QueryableDataSourceEditData editData = new QueryableDataSourceEditData();
|
|
Type dataObjectType = EntityType;
|
|
IDictionary caseInsensitiveOldValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
|
|
IDictionary originalValues = GetOriginalValues(keys);
|
|
|
|
ParameterCollection deleteParameters = DeleteParameters;
|
|
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
|
|
deleteParameters,
|
|
keys,
|
|
caseInsensitiveOldValues,
|
|
validationErrors)) {
|
|
return editData;
|
|
}
|
|
|
|
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
|
|
deleteParameters,
|
|
oldValues,
|
|
caseInsensitiveOldValues,
|
|
validationErrors)) {
|
|
return editData;
|
|
|
|
}
|
|
|
|
if (originalValues != null) {
|
|
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
|
|
deleteParameters,
|
|
originalValues,
|
|
caseInsensitiveOldValues,
|
|
validationErrors)) {
|
|
return editData;
|
|
}
|
|
}
|
|
|
|
editData.OriginalDataObject = DataSourceHelper.BuildDataObject(dataObjectType, caseInsensitiveOldValues, validationErrors);
|
|
return editData;
|
|
}
|
|
|
|
protected QueryableDataSourceEditData BuildInsertObject(IDictionary values, IDictionary<string, Exception> validationErrors) {
|
|
QueryableDataSourceEditData editData = new QueryableDataSourceEditData();
|
|
Type dataObjectType = EntityType;
|
|
IDictionary caseInsensitiveNewValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
|
|
|
|
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
|
|
InsertParameters,
|
|
InsertParameters.GetValues(_context, _owner),
|
|
caseInsensitiveNewValues,
|
|
validationErrors)) {
|
|
return editData;
|
|
}
|
|
|
|
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
|
|
InsertParameters,
|
|
values,
|
|
caseInsensitiveNewValues, validationErrors)) {
|
|
return editData;
|
|
}
|
|
|
|
editData.NewDataObject = DataSourceHelper.BuildDataObject(dataObjectType, caseInsensitiveNewValues, validationErrors);
|
|
return editData;
|
|
}
|
|
|
|
protected QueryableDataSourceEditData BuildUpdateObjects(IDictionary keys, IDictionary values, IDictionary oldValues, IDictionary<string, Exception> validationErrors) {
|
|
QueryableDataSourceEditData editData = new QueryableDataSourceEditData();
|
|
Type dataObjectType = EntityType;
|
|
IDictionary caseInsensitiveNewValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
|
|
IDictionary caseInsensitiveOldValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
|
|
IDictionary originalValues = GetOriginalValues(keys);
|
|
|
|
// We start out with the old values, just to pre-populate the list with items
|
|
// that might not have corresponding new values. For example if a GridView has
|
|
// a read-only field, there will be an old value, but no new value. The data object
|
|
// still has to have *some* value for a given field, so we just use the old value.
|
|
ParameterCollection updateParameters = UpdateParameters;
|
|
|
|
// If we have validation errors bail out while merging bailout
|
|
|
|
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
|
|
updateParameters,
|
|
oldValues,
|
|
caseInsensitiveOldValues,
|
|
caseInsensitiveNewValues,
|
|
validationErrors)) {
|
|
return editData;
|
|
}
|
|
|
|
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
|
|
updateParameters,
|
|
keys,
|
|
caseInsensitiveOldValues,
|
|
caseInsensitiveNewValues,
|
|
validationErrors)) {
|
|
return editData;
|
|
}
|
|
|
|
if (originalValues != null) {
|
|
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
|
|
updateParameters,
|
|
originalValues,
|
|
caseInsensitiveOldValues,
|
|
caseInsensitiveNewValues,
|
|
validationErrors)) {
|
|
return editData;
|
|
}
|
|
}
|
|
|
|
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
|
|
updateParameters,
|
|
values,
|
|
caseInsensitiveNewValues,
|
|
validationErrors)) {
|
|
return editData;
|
|
}
|
|
|
|
editData.NewDataObject = DataSourceHelper.BuildDataObject(dataObjectType, caseInsensitiveNewValues, validationErrors);
|
|
|
|
if (editData.NewDataObject != null) {
|
|
editData.OriginalDataObject = DataSourceHelper.BuildDataObject(dataObjectType, caseInsensitiveOldValues, validationErrors);
|
|
}
|
|
return editData;
|
|
}
|
|
|
|
protected virtual int DeleteObject(object oldEntity) {
|
|
return 0;
|
|
}
|
|
|
|
protected virtual int UpdateObject(object oldEntity, object newEntity) {
|
|
return 0;
|
|
}
|
|
|
|
protected virtual int InsertObject(object newEntity) {
|
|
return 0;
|
|
}
|
|
|
|
protected abstract void HandleValidationErrors(IDictionary<string, Exception> errors, DataSourceOperation operation);
|
|
|
|
protected override int ExecuteDelete(IDictionary keys, IDictionary oldValues) {
|
|
IDictionary<string, Exception> errors = new Dictionary<string, Exception>(StringComparer.OrdinalIgnoreCase);
|
|
QueryableDataSourceEditData editData = BuildDeleteObject(keys, oldValues, errors);
|
|
|
|
if (errors.Any()) {
|
|
HandleValidationErrors(errors, DataSourceOperation.Delete);
|
|
}
|
|
else {
|
|
return DeleteObject(editData.OriginalDataObject);
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
protected override int ExecuteInsert(IDictionary values) {
|
|
IDictionary<string, Exception> errors = new Dictionary<string, Exception>(StringComparer.OrdinalIgnoreCase);
|
|
QueryableDataSourceEditData editData = BuildInsertObject(values, errors);
|
|
if (errors.Any()) {
|
|
HandleValidationErrors(errors, DataSourceOperation.Insert);
|
|
}
|
|
else {
|
|
return InsertObject(editData.NewDataObject);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
protected override int ExecuteUpdate(IDictionary keys, IDictionary values, IDictionary oldValues) {
|
|
IDictionary<string, Exception> errors = new Dictionary<string, Exception>(StringComparer.OrdinalIgnoreCase);
|
|
QueryableDataSourceEditData editData = BuildUpdateObjects(keys, values, oldValues, errors);
|
|
if (errors.Any()) {
|
|
HandleValidationErrors(errors, DataSourceOperation.Update);
|
|
}
|
|
else {
|
|
return UpdateObject(editData.OriginalDataObject, editData.NewDataObject);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public event EventHandler<QueryCreatedEventArgs> QueryCreated {
|
|
add {
|
|
Events.AddHandler(EventQueryCreated, value);
|
|
}
|
|
remove {
|
|
Events.RemoveHandler(EventQueryCreated, value);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
|
|
protected virtual void OnQueryCreated(QueryCreatedEventArgs e) {
|
|
EventHandler<QueryCreatedEventArgs> handler = (EventHandler<QueryCreatedEventArgs>)Events[EventQueryCreated];
|
|
if (handler != null) {
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
private bool OriginalValueMatches(object originalValue, object value) {
|
|
// NOTE: Comparing IEnumerable contents instead of instances to ensure that
|
|
// timestamp columns (of type byte[]) can be matched appropriately.
|
|
IEnumerable originalValueEnumerable = originalValue as IEnumerable;
|
|
IEnumerable valueEnumerable = value as IEnumerable;
|
|
if ((originalValueEnumerable != null) && (valueEnumerable != null)) {
|
|
return QueryableDataSourceHelper.EnumerableContentEquals(originalValueEnumerable, valueEnumerable);
|
|
}
|
|
return originalValue.Equals(value);
|
|
}
|
|
|
|
#region IStateManager Members
|
|
|
|
bool IStateManager.IsTrackingViewState {
|
|
get { return IsTrackingViewState; }
|
|
}
|
|
|
|
void IStateManager.LoadViewState(object state) {
|
|
LoadViewState(state);
|
|
}
|
|
|
|
object IStateManager.SaveViewState() {
|
|
return SaveViewState();
|
|
}
|
|
|
|
void IStateManager.TrackViewState() {
|
|
TrackViewState();
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|