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         [PersistChildren (false)]
  43         [ParseChildren (true)]
  44         [Designer ("System.Web.UI.Design.WebControls.LinqDataSourceDesigner, System.Web.Extensions.Design, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
  45         [DefaultEvent ("Selecting")]
  46         [ToolboxItemFilter ("System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35", ToolboxItemFilterType.Require)]
  47         [DefaultProperty ("ContextTypeName")]
  48         public class LinqDataSource : DataSourceControl, IDynamicDataSource
  49         {
  50                 static readonly string [] empty_names = new string [] { "DefaultView" };
  51
  52                 public LinqDataSource ()
  53                 {
  54                 }
  55
  56                 protected internal override void OnInit (EventArgs e)
  57                 {
  58                         Page.LoadComplete += OnPageLoadComplete;
  59                 }
  60
  61                 void OnPageLoadComplete (object sender, EventArgs e)
  62                 {
  63                         SelectParameters.UpdateValues (Context, this);
  64                         WhereParameters.UpdateValues (Context, this);
  65                         GroupByParameters.UpdateValues (Context, this);
  66                         OrderByParameters.UpdateValues (Context, this);
  67                         OrderGroupsByParameters.UpdateValues (Context, this);
  68                 }
  69
  70                 protected internal override void OnUnload (EventArgs e)
  71                 {
  72                         base.OnUnload (e);
  73
  74                         // no further things to do?
  75                 }
  76
  77                 #region View
  78
  79                 LinqDataSourceView view;
  80                 LinqDataSourceView View {
  81                         get {
  82                                 if (view == null) {
  83                                         view = CreateView ();
  84                                         if (IsTrackingViewState)
  85                                                 ((IStateManager) view).TrackViewState ();
  86                                 }
  87                                 return view;
  88                         }
  89                 }
  90
  91                 protected virtual LinqDataSourceView CreateView ()
  92                 {
  93                         var view = new LinqDataSourceView (this, Guid.NewGuid ().ToString (), HttpContext.Current);
  94                         if (IsTrackingViewState)
  95                                 ((IStateManager) view).TrackViewState ();
  96                         return view;
  97                 }
  98
  99                 protected override DataSourceView GetView (string viewName)
 100                 {
 101                         if (String.IsNullOrEmpty (viewName) || (String.Compare (viewName, empty_names [0], StringComparison.InvariantCultureIgnoreCase) == 0))
 102                                 return View;
 103                         throw new ArgumentException ("viewName must be 'DefaultView' in LinqDataSource");
 104                 }
 105
 106                 protected override ICollection GetViewNames ()
 107                 {
 108                         return empty_names;
 109                 }
 110
 111                 #endregion
 112
 113                 [Category ("Behavior")]
 114                 [DefaultValue (false)]
 115                 public bool AutoGenerateOrderByClause {
 116                         get { return View.AutoGenerateOrderByClause; }
 117                         set { View.AutoGenerateOrderByClause = value; }
 118                 }
 119
 120                 [Category ("Behavior")]
 121                 [DefaultValue (false)]
 122                 public bool AutoGenerateWhereClause {
 123                         get { return View.AutoGenerateWhereClause; }
 124                         set { View.AutoGenerateWhereClause = value; }
 125                 }
 126
 127                 [Category ("Behavior")]
 128                 [DefaultValue (true)]
 129                 public bool AutoPage {
 130                         get { return View.AutoPage; }
 131                         set { View.AutoPage = value; }
 132                 }
 133
 134                 [Category ("Behavior")]
 135                 [DefaultValue (true)]
 136                 public bool AutoSort {
 137                         get { return View.AutoSort; }
 138                         set { View.AutoSort = value; }
 139                 }
 140
 141                 [Category ("Data")]
 142                 [DefaultValue ("")]
 143                 public string ContextTypeName { get; set; }
 144
 145                 Type context_type;
 146
 147                 [MonoTODO ("looks like we need System.Web.Query.Dynamic stuff or alternative")]
 148                 Type IDynamicDataSource.ContextType {
 149                         get {
 150                                 if (context_type != null && context_type.FullName == ContextTypeName)
 151                                         return context_type;
 152
 153                                 if (String.IsNullOrEmpty (ContextTypeName))
 154                                         return null;
 155
 156                                 // FIXME: retrieve type from BuildProvider or whatever.
 157                                 context_type = LoadType (ContextTypeName);
 158                                 if (context_type == null)
 159                                         throw new ArgumentException (String.Format ("Type '{0}' cannot be loaded", ContextTypeName));
 160                                 return context_type;
 161                         }
 162                         set {
 163                                 if (value == null)
 164                                         throw new ArgumentNullException ("value");
 165                                 context_type = value;
 166                                 ContextTypeName = context_type.FullName;
 167                         }
 168                 }
 169
 170                 private Type LoadType (string name)
 171                 {
 172                         foreach (var ass in AppDomain.CurrentDomain.GetAssemblies ())
 173                                 foreach (var type in ass.GetTypes ())
 174                                         if (type.FullName == name)
 175                                                 return type;
 176                         return null;
 177                 }
 178
 179                 string IDynamicDataSource.EntitySetName {
 180                         get { return TableName; }
 181                         set { TableName = value; }
 182                 }
 183
 184                 [Category ("Data")]
 185                 [DefaultValue ("")]
 186                 public string TableName {
 187                         get { return View.TableName; }
 188                         set { View.TableName = value; }
 189                 }
 190
 191                 [Category ("Behavior")]
 192                 [DefaultValue (false)]
 193                 public bool EnableDelete {
 194                         get { return View.EnableDelete; }
 195                         set { View.EnableDelete = value; }
 196                 }
 197
 198                 [Category ("Behavior")]
 199                 [DefaultValue (false)]
 200                 public bool EnableInsert {
 201                         get { return View.EnableInsert; }
 202                         set { View.EnableInsert = value; }
 203                 }
 204
 205                 [Category ("Behavior")]
 206                 [DefaultValue (false)]
 207                 public bool EnableObjectTracking {
 208                         get { return View.EnableObjectTracking; }
 209                         set { View.EnableObjectTracking = value; }
 210                 }
 211
 212                 [Category ("Behavior")]
 213                 [DefaultValue (false)]
 214                 public bool EnableUpdate {
 215                         get { return View.EnableUpdate; }
 216                         set { View.EnableUpdate = value; }
 217                 }
 218
 219                 [Category ("Data")]
 220                 [DefaultValue ("")]
 221                 public string GroupBy {
 222                         get { return View.GroupBy; }
 223                         set { View.GroupBy = value; }
 224                 }
 225
 226                 [Category ("Data")]
 227                 [DefaultValue ("")]
 228                 public string OrderBy {
 229                         get { return View.OrderBy; }
 230                         set { View.OrderBy = value; }
 231                 }
 232
 233                 [Category ("Data")]
 234                 [DefaultValue ("")]
 235                 public string OrderGroupsBy {
 236                         get { return View.OrderGroupsBy; }
 237                         set { View.OrderGroupsBy = value; }
 238                 }
 239
 240                 [Category ("Data")]
 241                 [DefaultValue ("")]
 242                 public string Select {
 243                         get { return View.SelectNew; }
 244                         set { View.SelectNew = value; }
 245                 }
 246
 247                 [Category ("Data")]
 248                 [DefaultValue ("")]
 249                 public string Where {
 250                         get { return View.Where; }
 251                         set { View.Where = value; }
 252                 }
 253
 254                 [MergableProperty (false)]
 255                 [Category ("Data")]
 256                 [DefaultValue (null)]
 257                 [PersistenceMode (PersistenceMode.InnerProperty)]
 258                 [Browsable (false)]
 259                 public ParameterCollection SelectParameters {
 260                         get { return View.SelectNewParameters; }
 261                 }
 262
 263                 [MergableProperty (false)]
 264                 [Category ("Data")]
 265                 [DefaultValue (null)]
 266                 [Browsable (false)]
 267                 [PersistenceMode (PersistenceMode.InnerProperty)]
 268                 public ParameterCollection WhereParameters {
 269                         get { return View.WhereParameters; }
 270                 }
 271
 272                 [MergableProperty (false)]
 273                 [Category ("Data")]
 274                 [DefaultValue (null)]
 275                 [Browsable (false)]
 276                 [PersistenceMode (PersistenceMode.InnerProperty)]
 277                 public ParameterCollection GroupByParameters {
 278                         get { return View.GroupByParameters; }
 279                 }
 280
 281                 [MergableProperty (false)]
 282                 [Category ("Data")]
 283                 [DefaultValue (null)]
 284                 [Browsable (false)]
 285                 [PersistenceMode (PersistenceMode.InnerProperty)]
 286                 public ParameterCollection OrderByParameters {
 287                         get { return View.OrderByParameters; }
 288                 }
 289
 290                 [MergableProperty (false)]
 291                 [Category ("Data")]
 292                 [DefaultValue (null)]
 293                 [PersistenceMode (PersistenceMode.InnerProperty)]
 294                 [Browsable (false)]
 295                 public ParameterCollection OrderGroupsByParameters {
 296                         get { return View.OrderGroupsByParameters; }
 297                 }
 298
 299                 [MergableProperty (false)]
 300                 [Category ("Data")]
 301                 [DefaultValue (null)]
 302                 [PersistenceMode (PersistenceMode.InnerProperty)]
 303                 [Browsable (false)]
 304                 public ParameterCollection DeleteParameters {
 305                         get { return View.DeleteParameters; }
 306                 }
 307
 308                 [MergableProperty (false)]
 309                 [Category ("Data")]
 310                 [DefaultValue (null)]
 311                 [PersistenceMode (PersistenceMode.InnerProperty)]
 312                 [Browsable (false)]
 313                 public ParameterCollection InsertParameters {
 314                         get { return View.InsertParameters; }
 315                 }
 316
 317                 [MergableProperty (false)]
 318                 [Category ("Data")]
 319                 [DefaultValue (null)]
 320                 [PersistenceMode (PersistenceMode.InnerProperty)]
 321                 [Browsable (false)]
 322                 public ParameterCollection UpdateParameters {
 323                         get { return View.UpdateParameters; }
 324                 }
 325
 326                 public int Delete (IDictionary keys, IDictionary oldValues)
 327                 {
 328                         return View.Delete (keys, oldValues);
 329                 }
 330
 331                 public int Insert (IDictionary values)
 332                 {
 333                         return View.Insert (values);
 334                 }
 335
 336                 public int Update (IDictionary keys, IDictionary values, IDictionary oldValues)
 337                 {
 338                         return View.Update (keys, values, oldValues);
 339                 }
 340
 341                 #region ViewState
 342
 343                 [Category ("Behavior")]
 344                 [DefaultValue (true)]
 345                 public bool StoreOriginalValuesInViewState {
 346                         get { return View.StoreOriginalValuesInViewState; }
 347                         set { View.StoreOriginalValuesInViewState = value; }
 348                 }
 349
 350                 protected override void LoadViewState (object savedState)
 351                 {
 352                         Pair p = savedState as Pair;
 353                         if (p != null) {
 354                                 base.LoadViewState (p.First);
 355                                 ((IStateManager) View).LoadViewState (p.Second);
 356                         }
 357                 }
 358
 359                 protected override object SaveViewState ()
 360                 {
 361                         object me = base.SaveViewState (), view = ((IStateManager) View).SaveViewState ();
 362                         if (me != null || view != null)
 363                                 return new Pair (me, view);
 364                         else
 365                                 return null;
 366                 }
 367
 368                 protected override void TrackViewState ()
 369                 {
 370                         base.TrackViewState ();
 371                         if (view != null)
 372                                 ((IStateManager) view).TrackViewState ();
 373                 }
 374
 375                 #endregion
 376
 377                 #region Events (Dispatching)
 378
 379                 public event EventHandler<LinqDataSourceStatusEventArgs> ContextCreated {
 380                         add { View.ContextCreated += value; }
 381                         remove { View.ContextCreated -= value; }
 382                 }
 383
 384                 public event EventHandler<LinqDataSourceContextEventArgs> ContextCreating {
 385                         add { View.ContextCreating += value; }
 386                         remove { View.ContextCreating -= value; }
 387                 }
 388
 389                 public event EventHandler<LinqDataSourceDisposeEventArgs> ContextDisposing {
 390                         add { View.ContextDisposing += value; }
 391                         remove { View.ContextDisposing -= value; }
 392                 }
 393
 394                 public event EventHandler<LinqDataSourceStatusEventArgs> Deleted {
 395                         add { View.Deleted += value; }
 396                         remove { View.Deleted -= value; }
 397                 }
 398
 399                 public event EventHandler<LinqDataSourceDeleteEventArgs> Deleting {
 400                         add { View.Deleting += value; }
 401                         remove { View.Deleting -= value; }
 402                 }
 403
 404                 event EventHandler<DynamicValidatorEventArgs> IDynamicDataSource.Exception {
 405                         add { View.Exception += value; }
 406                         remove { View.Exception -= value; }
 407                 }
 408
 409                 public event EventHandler<LinqDataSourceStatusEventArgs> Inserted {
 410                         add { View.Inserted += value; }
 411                         remove { View.Inserted -= value; }
 412                 }
 413
 414                 public event EventHandler<LinqDataSourceInsertEventArgs> Inserting {
 415                         add { View.Inserting += value; }
 416                         remove { View.Inserting -= value; }
 417                 }
 418
 419                 public event EventHandler<LinqDataSourceStatusEventArgs> Selected {
 420                         add { View.Selected += value; }
 421                         remove { View.Selected -= value; }
 422                 }
 423
 424                 public event EventHandler<LinqDataSourceSelectEventArgs> Selecting {
 425                         add { View.Selecting += value; }
 426                         remove { View.Selecting -= value; }
 427                 }
 428
 429                 public event EventHandler<LinqDataSourceStatusEventArgs> Updated {
 430                         add { View.Updated += value; }
 431                         remove { View.Updated -= value; }
 432                 }
 433
 434                 public event EventHandler<LinqDataSourceUpdateEventArgs> Updating {
 435                         add { View.Updating += value; }
 436                         remove { View.Updating -= value; }
 437                 }
 438
 439                 #endregion
 440         }
 441 }
 442 #endif