Files
mono/mcs/class/System.Web.Extensions/System.Web.UI.WebControls/LinqDataSource.cs
T
Atsushi Eno 30dfcbfa2d 2008-10-08 Atsushi Enomoto <[email protected]>
* Makefile: add reference to S.D.Linq.

	* LinqDataSource.cs, LinqDataSourceView.cs :
	  some more implementation.


svn path=/trunk/mcs/; revision=115240
2008-10-08 16:17:05 +00:00

413 lines
11 KiB
C#

//
// LinqDataSource.cs
//
// Author:
// Atsushi Enomoto <[email protected]>
//
// Copyright (C) 2008 Novell, Inc http://novell.com
//
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
#if NET_3_5
using System;
using System.Collections;
using System.ComponentModel;
using System.Security.Permissions;
using System.Web;
using System.Web.DynamicData;
using System.Web.UI;
namespace System.Web.UI.WebControls
{
// [ToolboxBitmap (typeof (LinqDataSource), "LinqDataSource.ico")]
[AspNetHostingPermission (SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
[AspNetHostingPermission (SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
[ParseChildren (true)]
[PersistChildren (false)]
public class LinqDataSource : DataSourceControl, IDynamicDataSource
{
static readonly string [] empty_names = new string [] { "DefaultView" };
public LinqDataSource ()
{
}
protected internal override void OnInit (EventArgs e)
{
Page.LoadComplete += OnPageLoadComplete;
}
void OnPageLoadComplete (object sender, EventArgs e)
{
SelectParameters.UpdateValues (Context, this);
WhereParameters.UpdateValues (Context, this);
GroupByParameters.UpdateValues (Context, this);
OrderByParameters.UpdateValues (Context, this);
OrderGroupsByParameters.UpdateValues (Context, this);
}
protected internal override void OnUnload (EventArgs e)
{
base.OnUnload (e);
// no further things to do?
}
#region View
LinqDataSourceView view;
LinqDataSourceView View {
get {
if (view == null) {
view = CreateView ();
if (IsTrackingViewState)
((IStateManager) view).TrackViewState ();
}
return view;
}
}
protected virtual LinqDataSourceView CreateView ()
{
var view = new LinqDataSourceView (this, Guid.NewGuid ().ToString (), HttpContext.Current);
if (IsTrackingViewState)
((IStateManager) view).TrackViewState ();
return view;
}
protected override DataSourceView GetView (string viewName)
{
if (String.IsNullOrEmpty (viewName) || (String.Compare (viewName, empty_names [0], StringComparison.InvariantCultureIgnoreCase) == 0))
return View;
throw new ArgumentException ("viewName must be 'DefaultView' in LinqDataSource");
}
protected override ICollection GetViewNames ()
{
return empty_names;
}
#endregion
[Category ("Behavior")]
[DefaultValue (false)]
public bool AutoGenerateOrderByClause {
get { return View.AutoGenerateOrderByClause; }
set { View.AutoGenerateOrderByClause = value; }
}
[Category ("Behavior")]
[DefaultValue (false)]
public bool AutoGenerateWhereClause {
get { return View.AutoGenerateWhereClause; }
set { View.AutoGenerateWhereClause = value; }
}
[Category ("Behavior")]
[DefaultValue (true)]
public bool AutoPage {
get { return View.AutoPage; }
set { View.AutoPage = value; }
}
[Category ("Behavior")]
[DefaultValue (true)]
public bool AutoSort {
get { return View.AutoSort; }
set { View.AutoSort = value; }
}
[Category ("Data")]
[DefaultValue ("")]
public string ContextTypeName { get; set; }
[MonoTODO ("looks like we need System.Web.Query.Dynamic stuff or alternative")]
Type IDynamicDataSource.ContextType {
get { throw new NotImplementedException (); }
set { throw new NotImplementedException (value.FullName); }
}
string IDynamicDataSource.EntitySetName {
get { return TableName; }
set { TableName = value; }
}
[Category ("Data")]
[DefaultValue ("")]
public string TableName {
get { return View.TableName; }
set { View.TableName = value; }
}
[Category ("Behavior")]
[DefaultValue (false)]
public bool EnableDelete {
get { return View.EnableDelete; }
set { View.EnableDelete = value; }
}
[Category ("Behavior")]
[DefaultValue (false)]
public bool EnableInsert {
get { return View.EnableInsert; }
set { View.EnableInsert = value; }
}
[Category ("Behavior")]
[DefaultValue (false)]
public bool EnableObjectTracking {
get { return View.EnableObjectTracking; }
set { View.EnableObjectTracking = value; }
}
[Category ("Behavior")]
[DefaultValue (false)]
public bool EnableUpdate {
get { return View.EnableUpdate; }
set { View.EnableUpdate = value; }
}
[Category ("Data")]
[DefaultValue ("")]
public string GroupBy {
get { return View.GroupBy; }
set { View.GroupBy = value; }
}
[Category ("Data")]
[DefaultValue ("")]
public string OrderBy {
get { return View.OrderBy; }
set { View.OrderBy = value; }
}
[Category ("Data")]
[DefaultValue ("")]
public string OrderGroupsBy {
get { return View.OrderGroupsBy; }
set { View.OrderGroupsBy = value; }
}
[Category ("Data")]
[DefaultValue ("")]
public string Select {
get { return View.SelectNew; }
set { View.SelectNew = value; }
}
[Category ("Data")]
[DefaultValue ("")]
public string Where {
get { return View.Where; }
set { View.Where = value; }
}
[MergableProperty (false)]
[Category ("Data")]
[DefaultValue (null)]
[PersistenceMode (PersistenceMode.InnerProperty)]
[Browsable (false)]
public ParameterCollection SelectParameters {
get { return View.SelectNewParameters; }
}
[MergableProperty (false)]
[Category ("Data")]
[DefaultValue (null)]
[Browsable (false)]
[PersistenceMode (PersistenceMode.InnerProperty)]
public ParameterCollection WhereParameters {
get { return View.WhereParameters; }
}
[MergableProperty (false)]
[Category ("Data")]
[DefaultValue (null)]
[Browsable (false)]
[PersistenceMode (PersistenceMode.InnerProperty)]
public ParameterCollection GroupByParameters {
get { return View.GroupByParameters; }
}
[MergableProperty (false)]
[Category ("Data")]
[DefaultValue (null)]
[Browsable (false)]
[PersistenceMode (PersistenceMode.InnerProperty)]
public ParameterCollection OrderByParameters {
get { return View.OrderByParameters; }
}
[MergableProperty (false)]
[Category ("Data")]
[DefaultValue (null)]
[PersistenceMode (PersistenceMode.InnerProperty)]
[Browsable (false)]
public ParameterCollection OrderGroupsByParameters {
get { return View.OrderGroupsByParameters; }
}
[MergableProperty (false)]
[Category ("Data")]
[DefaultValue (null)]
[PersistenceMode (PersistenceMode.InnerProperty)]
[Browsable (false)]
public ParameterCollection DeleteParameters {
get { return View.DeleteParameters; }
}
[MergableProperty (false)]
[Category ("Data")]
[DefaultValue (null)]
[PersistenceMode (PersistenceMode.InnerProperty)]
[Browsable (false)]
public ParameterCollection InsertParameters {
get { return View.InsertParameters; }
}
[MergableProperty (false)]
[Category ("Data")]
[DefaultValue (null)]
[PersistenceMode (PersistenceMode.InnerProperty)]
[Browsable (false)]
public ParameterCollection UpdateParameters {
get { return View.UpdateParameters; }
}
public int Delete (IDictionary keys, IDictionary oldValues)
{
return View.Delete (keys, oldValues);
}
public int Insert (IDictionary values)
{
return View.Insert (values);
}
public int Update (IDictionary keys, IDictionary values, IDictionary oldValues)
{
return View.Update (keys, values, oldValues);
}
#region ViewState
[Category ("Behavior")]
[DefaultValue (true)]
public bool StoreOriginalValuesInViewState {
get { return View.StoreOriginalValuesInViewState; }
set { View.StoreOriginalValuesInViewState = value; }
}
protected override void LoadViewState (object savedState)
{
Pair p = savedState as Pair;
if (p != null) {
base.LoadViewState (p.First);
((IStateManager) View).LoadViewState (p.Second);
}
}
protected override object SaveViewState ()
{
object me = base.SaveViewState (), view = ((IStateManager) View).SaveViewState ();
if (me != null || view != null)
return new Pair (me, view);
else
return null;
}
protected override void TrackViewState ()
{
base.TrackViewState ();
if (view != null)
((IStateManager) view).TrackViewState ();
}
#endregion
#region Events (Dispatching)
public event EventHandler<LinqDataSourceStatusEventArgs> ContextCreated {
add { View.ContextCreated += value; }
remove { View.ContextCreated -= value; }
}
public event EventHandler<LinqDataSourceContextEventArgs> ContextCreating {
add { View.ContextCreating += value; }
remove { View.ContextCreating -= value; }
}
public event EventHandler<LinqDataSourceDisposeEventArgs> ContextDisposing {
add { View.ContextDisposing += value; }
remove { View.ContextDisposing -= value; }
}
public event EventHandler<LinqDataSourceStatusEventArgs> Deleted {
add { View.Deleted += value; }
remove { View.Deleted -= value; }
}
public event EventHandler<LinqDataSourceDeleteEventArgs> Deleting {
add { View.Deleting += value; }
remove { View.Deleting -= value; }
}
event EventHandler<DynamicValidatorEventArgs> IDynamicDataSource.Exception {
add { View.Exception += value; }
remove { View.Exception -= value; }
}
public event EventHandler<LinqDataSourceStatusEventArgs> Inserted {
add { View.Inserted += value; }
remove { View.Inserted -= value; }
}
public event EventHandler<LinqDataSourceInsertEventArgs> Inserting {
add { View.Inserting += value; }
remove { View.Inserting -= value; }
}
public event EventHandler<LinqDataSourceStatusEventArgs> Selected {
add { View.Selected += value; }
remove { View.Selected -= value; }
}
public event EventHandler<LinqDataSourceSelectEventArgs> Selecting {
add { View.Selecting += value; }
remove { View.Selecting -= value; }
}
public event EventHandler<LinqDataSourceStatusEventArgs> Updated {
add { View.Updated += value; }
remove { View.Updated -= value; }
}
public event EventHandler<LinqDataSourceUpdateEventArgs> Updating {
add { View.Updating += value; }
remove { View.Updating -= value; }
}
#endregion
}
}
#endif