mcs/class/System.Web.Extensions/System.Web.UI.WebControls/LinqDataSource.cs

   1 //
   2 // LinqDataSource.cs
   3 //
   4 // Author:
   5 //   Atsushi Enomoto  <atsushi@ximian.com>
   6 //
   7 // Copyright (C) 2008 Novell, Inc  http://novell.com
   8 //
   9
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining
  12 // a copy of this software and associated documentation files (the
  13 // "Software"), to deal in the Software without restriction, including
  14 // without limitation the rights to use, copy, modify, merge, publish,
  15 // distribute, sublicense, and/or sell copies of the Software, and to
  16 // permit persons to whom the Software is furnished to do so, subject to
  17 // the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be
  20 // included in all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 //
  30 #if NET_3_5
  31 using System;
  32 using System.Collections;
  33 using System.ComponentModel;
  34 using System.Security.Permissions;
  35 using System.Web;
  36 using System.Web.DynamicData;
  37 using System.Web.UI;
  38
  39 namespace System.Web.UI.WebControls
  40 {
  41 //      [ToolboxBitmap (typeof (LinqDataSource), "LinqDataSource.ico")]
  42         [AspNetHostingPermission (SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
  43         [AspNetHostingPermission (SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
  44         [ParseChildren (true)]
  45         [PersistChildren (false)]
  46         public class LinqDataSource : DataSourceControl, IDynamicDataSource
  47         {
  48                 static readonly string [] empty_names = new string [] { "DefaultView" };
  49
  50                 public LinqDataSource ()
  51                 {
  52                 }
  53
  54                 protected internal override void OnInit (EventArgs e)
  55                 {
  56                         Page.LoadComplete += OnPageLoadComplete;
  57                 }
  58
  59                 void OnPageLoadComplete (object sender, EventArgs e)
  60                 {
  61                         SelectParameters.UpdateValues (Context, this);
  62                         WhereParameters.UpdateValues (Context, this);
  63                         GroupByParameters.UpdateValues (Context, this);
  64                         OrderByParameters.UpdateValues (Context, this);
  65                         OrderGroupsByParameters.UpdateValues (Context, this);
  66                 }
  67
  68                 protected internal override void OnUnload (EventArgs e)
  69                 {
  70                         base.OnUnload (e);
  71
  72                         // no further things to do?
  73                 }
  74
  75                 #region View
  76
  77                 LinqDataSourceView view;
  78                 LinqDataSourceView View {
  79                         get {
  80                                 if (view == null) {
  81                                         view = CreateView ();
  82                                         if (IsTrackingViewState)
  83                                                 ((IStateManager) view).TrackViewState ();
  84                                 }
  85                                 return view;
  86                         }
  87                 }
  88
  89                 protected virtual LinqDataSourceView CreateView ()
  90                 {
  91                         var view = new LinqDataSourceView (this, Guid.NewGuid ().ToString (), HttpContext.Current);
  92                         if (IsTrackingViewState)
  93                                 ((IStateManager) view).TrackViewState ();
  94                         return view;
  95                 }
  96
  97                 protected override DataSourceView GetView (string viewName)
  98                 {
  99                         if (String.IsNullOrEmpty (viewName) || (String.Compare (viewName, empty_names [0], StringComparison.InvariantCultureIgnoreCase) == 0))
 100                                 return View;
 101                         throw new ArgumentException ("viewName must be 'DefaultView' in LinqDataSource");
 102                 }
 103
 104                 protected override ICollection GetViewNames ()
 105                 {
 106                         return empty_names;
 107                 }
 108
 109                 #endregion
 110
 111                 [Category ("Behavior")]
 112                 [DefaultValue (false)]
 113                 public bool AutoGenerateOrderByClause {
 114                         get { return View.AutoGenerateOrderByClause; }
 115                         set { View.AutoGenerateOrderByClause = value; }
 116                 }
 117
 118                 [Category ("Behavior")]
 119                 [DefaultValue (false)]
 120                 public bool AutoGenerateWhereClause {
 121                         get { return View.AutoGenerateWhereClause; }
 122                         set { View.AutoGenerateWhereClause = value; }
 123                 }
 124
 125                 [Category ("Behavior")]
 126                 [DefaultValue (true)]
 127                 public bool AutoPage {
 128                         get { return View.AutoPage; }
 129                         set { View.AutoPage = value; }
 130                 }
 131
 132                 [Category ("Behavior")]
 133                 [DefaultValue (true)]
 134                 public bool AutoSort {
 135                         get { return View.AutoSort; }
 136                         set { View.AutoSort = value; }
 137                 }
 138
 139                 [Category ("Data")]
 140                 [DefaultValue ("")]
 141                 public string ContextTypeName { get; set; }
 142
 143                 Type context_type;
 144
 145                 [MonoTODO ("looks like we need System.Web.Query.Dynamic stuff or alternative")]
 146                 Type IDynamicDataSource.ContextType {
 147                         get {
 148                                 if (context_type != null && context_type.FullName == ContextTypeName)
 149                                         return context_type;
 150
 151                                 if (String.IsNullOrEmpty (ContextTypeName))
 152                                         throw new ArgumentException ("ContextTypeName is not set");
 153                                 // FIXME: retrieve type from BuildProvider or whatever.
 154                                 context_type = LoadType (ContextTypeName);
 155                                 if (context_type == null)
 156                                         throw new ArgumentException (String.Format ("Type '{0}' cannot be loaded", ContextTypeName));
 157                                 return context_type;
 158                         }
 159                         set {
 160                                 if (value == null)
 161                                         throw new ArgumentNullException ("value");
 162                                 context_type = value;
 163                                 ContextTypeName = context_type.FullName;
 164                         }
 165                 }
 166
 167                 private Type LoadType (string name)
 168                 {
 169                         foreach (var ass in AppDomain.CurrentDomain.GetAssemblies ())
 170                                 foreach (var type in ass.GetTypes ())
 171                                         if (type.FullName == name)
 172                                                 return type;
 173                         return null;
 174                 }
 175
 176                 string IDynamicDataSource.EntitySetName {
 177                         get { return TableName; }
 178                         set { TableName = value; }
 179                 }
 180
 181                 [Category ("Data")]
 182                 [DefaultValue ("")]
 183                 public string TableName {
 184                         get { return View.TableName; }
 185                         set { View.TableName = value; }
 186                 }
 187
 188                 [Category ("Behavior")]
 189                 [DefaultValue (false)]
 190                 public bool EnableDelete {
 191                         get { return View.EnableDelete; }
 192                         set { View.EnableDelete = value; }
 193                 }
 194
 195                 [Category ("Behavior")]
 196                 [DefaultValue (false)]
 197                 public bool EnableInsert {
 198                         get { return View.EnableInsert; }
 199                         set { View.EnableInsert = value; }
 200                 }
 201
 202                 [Category ("Behavior")]
 203                 [DefaultValue (false)]
 204                 public bool EnableObjectTracking {
 205                         get { return View.EnableObjectTracking; }
 206                         set { View.EnableObjectTracking = value; }
 207                 }
 208
 209                 [Category ("Behavior")]
 210                 [DefaultValue (false)]
 211                 public bool EnableUpdate {
 212                         get { return View.EnableUpdate; }
 213                         set { View.EnableUpdate = value; }
 214                 }
 215
 216                 [Category ("Data")]
 217                 [DefaultValue ("")]
 218                 public string GroupBy {
 219                         get { return View.GroupBy; }
 220                         set { View.GroupBy = value; }
 221                 }
 222
 223                 [Category ("Data")]
 224                 [DefaultValue ("")]
 225                 public string OrderBy {
 226                         get { return View.OrderBy; }
 227                         set { View.OrderBy = value; }
 228                 }
 229
 230                 [Category ("Data")]
 231                 [DefaultValue ("")]
 232                 public string OrderGroupsBy {
 233                         get { return View.OrderGroupsBy; }
 234                         set { View.OrderGroupsBy = value; }
 235                 }
 236
 237                 [Category ("Data")]
 238                 [DefaultValue ("")]
 239                 public string Select {
 240                         get { return View.SelectNew; }
 241                         set { View.SelectNew = value; }
 242                 }
 243
 244                 [Category ("Data")]
 245                 [DefaultValue ("")]
 246                 public string Where {
 247                         get { return View.Where; }
 248                         set { View.Where = value; }
 249                 }
 250
 251                 [MergableProperty (false)]
 252                 [Category ("Data")]
 253                 [DefaultValue (null)]
 254                 [PersistenceMode (PersistenceMode.InnerProperty)]
 255                 [Browsable (false)]
 256                 public ParameterCollection SelectParameters {
 257                         get { return View.SelectNewParameters; }
 258                 }
 259
 260                 [MergableProperty (false)]
 261                 [Category ("Data")]
 262                 [DefaultValue (null)]
 263                 [Browsable (false)]
 264                 [PersistenceMode (PersistenceMode.InnerProperty)]
 265                 public ParameterCollection WhereParameters {
 266                         get { return View.WhereParameters; }
 267                 }
 268
 269                 [MergableProperty (false)]
 270                 [Category ("Data")]
 271                 [DefaultValue (null)]
 272                 [Browsable (false)]
 273                 [PersistenceMode (PersistenceMode.InnerProperty)]
 274                 public ParameterCollection GroupByParameters {
 275                         get { return View.GroupByParameters; }
 276                 }
 277
 278                 [MergableProperty (false)]
 279                 [Category ("Data")]
 280                 [DefaultValue (null)]
 281                 [Browsable (false)]
 282                 [PersistenceMode (PersistenceMode.InnerProperty)]
 283                 public ParameterCollection OrderByParameters {
 284                         get { return View.OrderByParameters; }
 285                 }
 286
 287                 [MergableProperty (false)]
 288                 [Category ("Data")]
 289                 [DefaultValue (null)]
 290                 [PersistenceMode (PersistenceMode.InnerProperty)]
 291                 [Browsable (false)]
 292                 public ParameterCollection OrderGroupsByParameters {
 293                         get { return View.OrderGroupsByParameters; }
 294                 }
 295
 296                 [MergableProperty (false)]
 297                 [Category ("Data")]
 298                 [DefaultValue (null)]
 299                 [PersistenceMode (PersistenceMode.InnerProperty)]
 300                 [Browsable (false)]
 301                 public ParameterCollection DeleteParameters {
 302                         get { return View.DeleteParameters; }
 303                 }
 304
 305                 [MergableProperty (false)]
 306                 [Category ("Data")]
 307                 [DefaultValue (null)]
 308                 [PersistenceMode (PersistenceMode.InnerProperty)]
 309                 [Browsable (false)]
 310                 public ParameterCollection InsertParameters {
 311                         get { return View.InsertParameters; }
 312                 }
 313
 314                 [MergableProperty (false)]
 315                 [Category ("Data")]
 316                 [DefaultValue (null)]
 317                 [PersistenceMode (PersistenceMode.InnerProperty)]
 318                 [Browsable (false)]
 319                 public ParameterCollection UpdateParameters {
 320                         get { return View.UpdateParameters; }
 321                 }
 322
 323                 public int Delete (IDictionary keys, IDictionary oldValues)
 324                 {
 325                         return View.Delete (keys, oldValues);
 326                 }
 327
 328                 public int Insert (IDictionary values)
 329                 {
 330                         return View.Insert (values);
 331                 }
 332
 333                 public int Update (IDictionary keys, IDictionary values, IDictionary oldValues)
 334                 {
 335                         return View.Update (keys, values, oldValues);
 336                 }
 337
 338                 #region ViewState
 339
 340                 [Category ("Behavior")]
 341                 [DefaultValue (true)]
 342                 public bool StoreOriginalValuesInViewState {
 343                         get { return View.StoreOriginalValuesInViewState; }
 344                         set { View.StoreOriginalValuesInViewState = value; }
 345                 }
 346
 347                 protected override void LoadViewState (object savedState)
 348                 {
 349                         Pair p = savedState as Pair;
 350                         if (p != null) {
 351                                 base.LoadViewState (p.First);
 352                                 ((IStateManager) View).LoadViewState (p.Second);
 353                         }
 354                 }
 355
 356                 protected override object SaveViewState ()
 357                 {
 358                         object me = base.SaveViewState (), view = ((IStateManager) View).SaveViewState ();
 359                         if (me != null || view != null)
 360                                 return new Pair (me, view);
 361                         else
 362                                 return null;
 363                 }
 364
 365                 protected override void TrackViewState ()
 366                 {
 367                         base.TrackViewState ();
 368                         if (view != null)
 369                                 ((IStateManager) view).TrackViewState ();
 370                 }
 371
 372                 #endregion
 373
 374                 #region Events (Dispatching)
 375
 376                 public event EventHandler<LinqDataSourceStatusEventArgs> ContextCreated {
 377                         add { View.ContextCreated += value; }
 378                         remove { View.ContextCreated -= value; }
 379                 }
 380
 381                 public event EventHandler<LinqDataSourceContextEventArgs> ContextCreating {
 382                         add { View.ContextCreating += value; }
 383                         remove { View.ContextCreating -= value; }
 384                 }
 385
 386                 public event EventHandler<LinqDataSourceDisposeEventArgs> ContextDisposing {
 387                         add { View.ContextDisposing += value; }
 388                         remove { View.ContextDisposing -= value; }
 389                 }
 390
 391                 public event EventHandler<LinqDataSourceStatusEventArgs> Deleted {
 392                         add { View.Deleted += value; }
 393                         remove { View.Deleted -= value; }
 394                 }
 395
 396                 public event EventHandler<LinqDataSourceDeleteEventArgs> Deleting {
 397                         add { View.Deleting += value; }
 398                         remove { View.Deleting -= value; }
 399                 }
 400
 401                 event EventHandler<DynamicValidatorEventArgs> IDynamicDataSource.Exception {
 402                         add { View.Exception += value; }
 403                         remove { View.Exception -= value; }
 404                 }
 405
 406                 public event EventHandler<LinqDataSourceStatusEventArgs> Inserted {
 407                         add { View.Inserted += value; }
 408                         remove { View.Inserted -= value; }
 409                 }
 410
 411                 public event EventHandler<LinqDataSourceInsertEventArgs> Inserting {
 412                         add { View.Inserting += value; }
 413                         remove { View.Inserting -= value; }
 414                 }
 415
 416                 public event EventHandler<LinqDataSourceStatusEventArgs> Selected {
 417                         add { View.Selected += value; }
 418                         remove { View.Selected -= value; }
 419                 }
 420
 421                 public event EventHandler<LinqDataSourceSelectEventArgs> Selecting {
 422                         add { View.Selecting += value; }
 423                         remove { View.Selecting -= value; }
 424                 }
 425
 426                 public event EventHandler<LinqDataSourceStatusEventArgs> Updated {
 427                         add { View.Updated += value; }
 428                         remove { View.Updated -= value; }
 429                 }
 430
 431                 public event EventHandler<LinqDataSourceUpdateEventArgs> Updating {
 432                         add { View.Updating += value; }
 433                         remove { View.Updating -= value; }
 434                 }
 435
 436                 #endregion
 437         }
 438 }
 439 #endif