Free cookie consent management tool by TermsFeed Policy Generator

source: branches/ClientUserManagement/HeuristicLab.Services.Access.DataAccess/3.3/ClientManagement.designer.cs @ 7356

Last change on this file since 7356 was 6858, checked in by ascheibe, 13 years ago

#1648 worked on webservice and added more unit tests
File size: 64.3 KB
Line 
1#pragma warning disable 1591
2//------------------------------------------------------------------------------
3// <auto-generated>
4//     This code was generated by a tool.
5//     Runtime Version:4.0.30319.237
6//
7//     Changes to this file may cause incorrect behavior and will be lost if
8//     the code is regenerated.
9// </auto-generated>
10//------------------------------------------------------------------------------
11
12namespace HeuristicLab.Services.Access.DataAccess
13{
14  using System.Data.Linq;
15  using System.Data.Linq.Mapping;
16  using System.Data;
17  using System.Collections.Generic;
18  using System.Reflection;
19  using System.Linq;
20  using System.Linq.Expressions;
21  using System.ComponentModel;
22  using System;
23 
24 
25  [global::System.Data.Linq.Mapping.DatabaseAttribute(Name="HeuristicLab.ClientManagement")]
26  public partial class ClientManagementDataContext : System.Data.Linq.DataContext
27  {
28   
29    private static System.Data.Linq.Mapping.MappingSource mappingSource = new AttributeMappingSource();
30   
31    #region Extensibility Method Definitions
32    partial void OnCreated();
33    partial void InsertResource(Resource instance);
34    partial void UpdateResource(Resource instance);
35    partial void DeleteResource(Resource instance);
36    partial void InsertResourceResourceGroup(ResourceResourceGroup instance);
37    partial void UpdateResourceResourceGroup(ResourceResourceGroup instance);
38    partial void DeleteResourceResourceGroup(ResourceResourceGroup instance);
39    partial void InsertClientLog(ClientLog instance);
40    partial void UpdateClientLog(ClientLog instance);
41    partial void DeleteClientLog(ClientLog instance);
42    partial void InsertClientError(ClientError instance);
43    partial void UpdateClientError(ClientError instance);
44    partial void DeleteClientError(ClientError instance);
45    partial void InsertUserGroupBase(UserGroupBase instance);
46    partial void UpdateUserGroupBase(UserGroupBase instance);
47    partial void DeleteUserGroupBase(UserGroupBase instance);
48    partial void InsertClientType(ClientType instance);
49    partial void UpdateClientType(ClientType instance);
50    partial void DeleteClientType(ClientType instance);
51    partial void InsertOperatingSystem(OperatingSystem instance);
52    partial void UpdateOperatingSystem(OperatingSystem instance);
53    partial void DeleteOperatingSystem(OperatingSystem instance);
54    partial void InsertCountry(Country instance);
55    partial void UpdateCountry(Country instance);
56    partial void DeleteCountry(Country instance);
57    partial void InsertClientConfiguration(ClientConfiguration instance);
58    partial void UpdateClientConfiguration(ClientConfiguration instance);
59    partial void DeleteClientConfiguration(ClientConfiguration instance);
60    partial void InsertPlugin(Plugin instance);
61    partial void UpdatePlugin(Plugin instance);
62    partial void DeletePlugin(Plugin instance);
63    partial void InsertResourcePlugin(ResourcePlugin instance);
64    partial void UpdateResourcePlugin(ResourcePlugin instance);
65    partial void DeleteResourcePlugin(ResourcePlugin instance);
66    partial void InsertUserGroupUserGroup(UserGroupUserGroup instance);
67    partial void UpdateUserGroupUserGroup(UserGroupUserGroup instance);
68    partial void DeleteUserGroupUserGroup(UserGroupUserGroup instance);
69    #endregion
70   
71    public ClientManagementDataContext() :
72        base(global::HeuristicLab.Services.Access.DataAccess.Properties.Settings.Default.HeuristicLab_ClientManagementConnectionString, mappingSource)
73    {
74      OnCreated();
75    }
76   
77    public ClientManagementDataContext(string connection) :
78        base(connection, mappingSource)
79    {
80      OnCreated();
81    }
82   
83    public ClientManagementDataContext(System.Data.IDbConnection connection) :
84        base(connection, mappingSource)
85    {
86      OnCreated();
87    }
88   
89    public ClientManagementDataContext(string connection, System.Data.Linq.Mapping.MappingSource mappingSource) :
90        base(connection, mappingSource)
91    {
92      OnCreated();
93    }
94   
95    public ClientManagementDataContext(System.Data.IDbConnection connection, System.Data.Linq.Mapping.MappingSource mappingSource) :
96        base(connection, mappingSource)
97    {
98      OnCreated();
99    }
100   
101    public System.Data.Linq.Table<Resource> Resources
102    {
103      get
104      {
105        return this.GetTable<Resource>();
106      }
107    }
108   
109    public System.Data.Linq.Table<ResourceResourceGroup> ResourceResourceGroups
110    {
111      get
112      {
113        return this.GetTable<ResourceResourceGroup>();
114      }
115    }
116   
117    public System.Data.Linq.Table<ClientLog> ClientLogs
118    {
119      get
120      {
121        return this.GetTable<ClientLog>();
122      }
123    }
124   
125    public System.Data.Linq.Table<ClientError> ClientErrors
126    {
127      get
128      {
129        return this.GetTable<ClientError>();
130      }
131    }
132   
133    public System.Data.Linq.Table<UserGroupBase> UserGroupBases
134    {
135      get
136      {
137        return this.GetTable<UserGroupBase>();
138      }
139    }
140   
141    public System.Data.Linq.Table<ClientType> ClientTypes
142    {
143      get
144      {
145        return this.GetTable<ClientType>();
146      }
147    }
148   
149    public System.Data.Linq.Table<OperatingSystem> OperatingSystems
150    {
151      get
152      {
153        return this.GetTable<OperatingSystem>();
154      }
155    }
156   
157    public System.Data.Linq.Table<Country> Countries
158    {
159      get
160      {
161        return this.GetTable<Country>();
162      }
163    }
164   
165    public System.Data.Linq.Table<ClientConfiguration> ClientConfigurations
166    {
167      get
168      {
169        return this.GetTable<ClientConfiguration>();
170      }
171    }
172   
173    public System.Data.Linq.Table<Plugin> Plugins
174    {
175      get
176      {
177        return this.GetTable<Plugin>();
178      }
179    }
180   
181    public System.Data.Linq.Table<ResourcePlugin> ResourcePlugins
182    {
183      get
184      {
185        return this.GetTable<ResourcePlugin>();
186      }
187    }
188   
189    public System.Data.Linq.Table<UserGroupUserGroup> UserGroupUserGroups
190    {
191      get
192      {
193        return this.GetTable<UserGroupUserGroup>();
194      }
195    }
196  }
197 
198  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Resource")]
199  [global::System.Data.Linq.Mapping.InheritanceMappingAttribute(Code="Resource", Type=typeof(Resource), IsDefault=true)]
200  [global::System.Data.Linq.Mapping.InheritanceMappingAttribute(Code="Client", Type=typeof(Client))]
201  [global::System.Data.Linq.Mapping.InheritanceMappingAttribute(Code="ClientGroup", Type=typeof(ClientGroup))]
202  public partial class Resource : INotifyPropertyChanging, INotifyPropertyChanged
203  {
204   
205    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
206   
207    private System.Guid _Id;
208   
209    private string _Name;
210   
211    private string _Description;
212   
213    private string _Type;
214   
215    private EntitySet<ResourceResourceGroup> _ResourceResourceGroups;
216   
217    private EntitySet<ResourceResourceGroup> _ResourceResourceGroups1;
218   
219    private EntitySet<ClientLog> _ClientLogs;
220   
221    private EntitySet<ResourcePlugin> _ResourcePlugins;
222   
223    #region Extensibility Method Definitions
224    partial void OnLoaded();
225    partial void OnValidate(System.Data.Linq.ChangeAction action);
226    partial void OnCreated();
227    partial void OnIdChanging(System.Guid value);
228    partial void OnIdChanged();
229    partial void OnNameChanging(string value);
230    partial void OnNameChanged();
231    partial void OnDescriptionChanging(string value);
232    partial void OnDescriptionChanged();
233    partial void OnTypeChanging(string value);
234    partial void OnTypeChanged();
235    #endregion
236   
237    public Resource()
238    {
239      this._ResourceResourceGroups = new EntitySet<ResourceResourceGroup>(new Action<ResourceResourceGroup>(this.attach_ResourceResourceGroups), new Action<ResourceResourceGroup>(this.detach_ResourceResourceGroups));
240      this._ResourceResourceGroups1 = new EntitySet<ResourceResourceGroup>(new Action<ResourceResourceGroup>(this.attach_ResourceResourceGroups1), new Action<ResourceResourceGroup>(this.detach_ResourceResourceGroups1));
241      this._ClientLogs = new EntitySet<ClientLog>(new Action<ClientLog>(this.attach_ClientLogs), new Action<ClientLog>(this.detach_ClientLogs));
242      this._ResourcePlugins = new EntitySet<ResourcePlugin>(new Action<ResourcePlugin>(this.attach_ResourcePlugins), new Action<ResourcePlugin>(this.detach_ResourcePlugins));
243      OnCreated();
244    }
245   
246    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
247    public System.Guid Id
248    {
249      get
250      {
251        return this._Id;
252      }
253      set
254      {
255        if ((this._Id != value))
256        {
257          this.OnIdChanging(value);
258          this.SendPropertyChanging();
259          this._Id = value;
260          this.SendPropertyChanged("Id");
261          this.OnIdChanged();
262        }
263      }
264    }
265   
266    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(MAX) NOT NULL", CanBeNull=false)]
267    public string Name
268    {
269      get
270      {
271        return this._Name;
272      }
273      set
274      {
275        if ((this._Name != value))
276        {
277          this.OnNameChanging(value);
278          this.SendPropertyChanging();
279          this._Name = value;
280          this.SendPropertyChanged("Name");
281          this.OnNameChanged();
282        }
283      }
284    }
285   
286    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Description", DbType="NVarChar(MAX)", CanBeNull=false)]
287    public string Description
288    {
289      get
290      {
291        return this._Description;
292      }
293      set
294      {
295        if ((this._Description != value))
296        {
297          this.OnDescriptionChanging(value);
298          this.SendPropertyChanging();
299          this._Description = value;
300          this.SendPropertyChanged("Description");
301          this.OnDescriptionChanged();
302        }
303      }
304    }
305   
306    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Type", DbType="NVarChar(MAX) NOT NULL", CanBeNull=false, IsDiscriminator=true)]
307    public string Type
308    {
309      get
310      {
311        return this._Type;
312      }
313      set
314      {
315        if ((this._Type != value))
316        {
317          this.OnTypeChanging(value);
318          this.SendPropertyChanging();
319          this._Type = value;
320          this.SendPropertyChanged("Type");
321          this.OnTypeChanged();
322        }
323      }
324    }
325   
326    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_ResourceResourceGroup", Storage="_ResourceResourceGroups", ThisKey="Id", OtherKey="ResourceGroupId")]
327    public EntitySet<ResourceResourceGroup> ResourceResourceGroupsChilds
328    {
329      get
330      {
331        return this._ResourceResourceGroups;
332      }
333      set
334      {
335        this._ResourceResourceGroups.Assign(value);
336      }
337    }
338   
339    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_ResourceResourceGroup1", Storage="_ResourceResourceGroups1", ThisKey="Id", OtherKey="ResourceId")]
340    public EntitySet<ResourceResourceGroup> ResourceResourceGroupsParents
341    {
342      get
343      {
344        return this._ResourceResourceGroups1;
345      }
346      set
347      {
348        this._ResourceResourceGroups1.Assign(value);
349      }
350    }
351   
352    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_ClientLog", Storage="_ClientLogs", ThisKey="Id", OtherKey="ResourceId")]
353    public EntitySet<ClientLog> ClientLogs
354    {
355      get
356      {
357        return this._ClientLogs;
358      }
359      set
360      {
361        this._ClientLogs.Assign(value);
362      }
363    }
364   
365    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_ResourcePlugin", Storage="_ResourcePlugins", ThisKey="Id", OtherKey="ResourceId")]
366    public EntitySet<ResourcePlugin> ResourcePlugins
367    {
368      get
369      {
370        return this._ResourcePlugins;
371      }
372      set
373      {
374        this._ResourcePlugins.Assign(value);
375      }
376    }
377   
378    public event PropertyChangingEventHandler PropertyChanging;
379   
380    public event PropertyChangedEventHandler PropertyChanged;
381   
382    protected virtual void SendPropertyChanging()
383    {
384      if ((this.PropertyChanging != null))
385      {
386        this.PropertyChanging(this, emptyChangingEventArgs);
387      }
388    }
389   
390    protected virtual void SendPropertyChanged(String propertyName)
391    {
392      if ((this.PropertyChanged != null))
393      {
394        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
395      }
396    }
397   
398    private void attach_ResourceResourceGroups(ResourceResourceGroup entity)
399    {
400      this.SendPropertyChanging();
401      entity.ParentResource = this;
402    }
403   
404    private void detach_ResourceResourceGroups(ResourceResourceGroup entity)
405    {
406      this.SendPropertyChanging();
407      entity.ParentResource = null;
408    }
409   
410    private void attach_ResourceResourceGroups1(ResourceResourceGroup entity)
411    {
412      this.SendPropertyChanging();
413      entity.Resource = this;
414    }
415   
416    private void detach_ResourceResourceGroups1(ResourceResourceGroup entity)
417    {
418      this.SendPropertyChanging();
419      entity.Resource = null;
420    }
421   
422    private void attach_ClientLogs(ClientLog entity)
423    {
424      this.SendPropertyChanging();
425      entity.Resource = this;
426    }
427   
428    private void detach_ClientLogs(ClientLog entity)
429    {
430      this.SendPropertyChanging();
431      entity.Resource = null;
432    }
433   
434    private void attach_ResourcePlugins(ResourcePlugin entity)
435    {
436      this.SendPropertyChanging();
437      entity.Resource = this;
438    }
439   
440    private void detach_ResourcePlugins(ResourcePlugin entity)
441    {
442      this.SendPropertyChanging();
443      entity.Resource = null;
444    }
445  }
446 
447  public partial class Client : Resource
448  {
449   
450    private string _HeuristicLabVersion;
451   
452    private System.Nullable<int> _MemorySize;
453   
454    private System.Nullable<System.DateTime> _Timestamp;
455   
456    private System.Nullable<int> _NumberOfCores;
457   
458    private string _ProcessorType;
459   
460    private System.Nullable<System.Guid> _ClientTypeId;
461   
462    private System.Nullable<System.Guid> _OperatingSystemId;
463   
464    private System.Nullable<System.Guid> _ClientConfigurationId;
465   
466    private System.Nullable<System.Guid> _CountryId;
467   
468    private EntityRef<ClientType> _ClientType;
469   
470    private EntityRef<OperatingSystem> _OperatingSystem;
471   
472    private EntityRef<Country> _Country;
473   
474    private EntityRef<ClientConfiguration> _ClientConfiguration;
475   
476    #region Extensibility Method Definitions
477    partial void OnLoaded();
478    partial void OnValidate(System.Data.Linq.ChangeAction action);
479    partial void OnCreated();
480    partial void OnHeuristicLabVersionChanging(string value);
481    partial void OnHeuristicLabVersionChanged();
482    partial void OnMemorySizeChanging(System.Nullable<int> value);
483    partial void OnMemorySizeChanged();
484    partial void OnTimestampChanging(System.Nullable<System.DateTime> value);
485    partial void OnTimestampChanged();
486    partial void OnNumberOfCoresChanging(System.Nullable<int> value);
487    partial void OnNumberOfCoresChanged();
488    partial void OnProcessorTypeChanging(string value);
489    partial void OnProcessorTypeChanged();
490    partial void OnClientTypeIdChanging(System.Nullable<System.Guid> value);
491    partial void OnClientTypeIdChanged();
492    partial void OnOperatingSystemIdChanging(System.Nullable<System.Guid> value);
493    partial void OnOperatingSystemIdChanged();
494    partial void OnClientConfigurationIdChanging(System.Nullable<System.Guid> value);
495    partial void OnClientConfigurationIdChanged();
496    partial void OnCountryIdChanging(System.Nullable<System.Guid> value);
497    partial void OnCountryIdChanged();
498    #endregion
499   
500    public Client()
501    {
502      this._ClientType = default(EntityRef<ClientType>);
503      this._OperatingSystem = default(EntityRef<OperatingSystem>);
504      this._Country = default(EntityRef<Country>);
505      this._ClientConfiguration = default(EntityRef<ClientConfiguration>);
506      OnCreated();
507    }
508   
509    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_HeuristicLabVersion", DbType="NVarChar(MAX)", CanBeNull=false)]
510    public string HeuristicLabVersion
511    {
512      get
513      {
514        return this._HeuristicLabVersion;
515      }
516      set
517      {
518        if ((this._HeuristicLabVersion != value))
519        {
520          this.OnHeuristicLabVersionChanging(value);
521          this.SendPropertyChanging();
522          this._HeuristicLabVersion = value;
523          this.SendPropertyChanged("HeuristicLabVersion");
524          this.OnHeuristicLabVersionChanged();
525        }
526      }
527    }
528   
529    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_MemorySize", DbType="Int")]
530    public System.Nullable<int> MemorySize
531    {
532      get
533      {
534        return this._MemorySize;
535      }
536      set
537      {
538        if ((this._MemorySize != value))
539        {
540          this.OnMemorySizeChanging(value);
541          this.SendPropertyChanging();
542          this._MemorySize = value;
543          this.SendPropertyChanged("MemorySize");
544          this.OnMemorySizeChanged();
545        }
546      }
547    }
548   
549    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Timestamp", DbType="DateTime")]
550    public System.Nullable<System.DateTime> Timestamp
551    {
552      get
553      {
554        return this._Timestamp;
555      }
556      set
557      {
558        if ((this._Timestamp != value))
559        {
560          this.OnTimestampChanging(value);
561          this.SendPropertyChanging();
562          this._Timestamp = value;
563          this.SendPropertyChanged("Timestamp");
564          this.OnTimestampChanged();
565        }
566      }
567    }
568   
569    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumberOfCores", DbType="Int")]
570    public System.Nullable<int> NumberOfCores
571    {
572      get
573      {
574        return this._NumberOfCores;
575      }
576      set
577      {
578        if ((this._NumberOfCores != value))
579        {
580          this.OnNumberOfCoresChanging(value);
581          this.SendPropertyChanging();
582          this._NumberOfCores = value;
583          this.SendPropertyChanged("NumberOfCores");
584          this.OnNumberOfCoresChanged();
585        }
586      }
587    }
588   
589    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ProcessorType", DbType="NVarChar(MAX)")]
590    public string ProcessorType
591    {
592      get
593      {
594        return this._ProcessorType;
595      }
596      set
597      {
598        if ((this._ProcessorType != value))
599        {
600          this.OnProcessorTypeChanging(value);
601          this.SendPropertyChanging();
602          this._ProcessorType = value;
603          this.SendPropertyChanged("ProcessorType");
604          this.OnProcessorTypeChanged();
605        }
606      }
607    }
608   
609    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ClientTypeId", DbType="UniqueIdentifier")]
610    public System.Nullable<System.Guid> ClientTypeId
611    {
612      get
613      {
614        return this._ClientTypeId;
615      }
616      set
617      {
618        if ((this._ClientTypeId != value))
619        {
620          if (this._ClientType.HasLoadedOrAssignedValue)
621          {
622            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
623          }
624          this.OnClientTypeIdChanging(value);
625          this.SendPropertyChanging();
626          this._ClientTypeId = value;
627          this.SendPropertyChanged("ClientTypeId");
628          this.OnClientTypeIdChanged();
629        }
630      }
631    }
632   
633    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_OperatingSystemId", DbType="UniqueIdentifier")]
634    public System.Nullable<System.Guid> OperatingSystemId
635    {
636      get
637      {
638        return this._OperatingSystemId;
639      }
640      set
641      {
642        if ((this._OperatingSystemId != value))
643        {
644          if (this._OperatingSystem.HasLoadedOrAssignedValue)
645          {
646            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
647          }
648          this.OnOperatingSystemIdChanging(value);
649          this.SendPropertyChanging();
650          this._OperatingSystemId = value;
651          this.SendPropertyChanged("OperatingSystemId");
652          this.OnOperatingSystemIdChanged();
653        }
654      }
655    }
656   
657    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ClientConfigurationId", DbType="UniqueIdentifier")]
658    public System.Nullable<System.Guid> ClientConfigurationId
659    {
660      get
661      {
662        return this._ClientConfigurationId;
663      }
664      set
665      {
666        if ((this._ClientConfigurationId != value))
667        {
668          if (this._ClientConfiguration.HasLoadedOrAssignedValue)
669          {
670            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
671          }
672          this.OnClientConfigurationIdChanging(value);
673          this.SendPropertyChanging();
674          this._ClientConfigurationId = value;
675          this.SendPropertyChanged("ClientConfigurationId");
676          this.OnClientConfigurationIdChanged();
677        }
678      }
679    }
680   
681    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CountryId", DbType="UniqueIdentifier")]
682    public System.Nullable<System.Guid> CountryId
683    {
684      get
685      {
686        return this._CountryId;
687      }
688      set
689      {
690        if ((this._CountryId != value))
691        {
692          if (this._Country.HasLoadedOrAssignedValue)
693          {
694            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
695          }
696          this.OnCountryIdChanging(value);
697          this.SendPropertyChanging();
698          this._CountryId = value;
699          this.SendPropertyChanged("CountryId");
700          this.OnCountryIdChanged();
701        }
702      }
703    }
704   
705    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="ClientType_Client", Storage="_ClientType", ThisKey="ClientTypeId", OtherKey="Id", IsForeignKey=true)]
706    public ClientType ClientType
707    {
708      get
709      {
710        return this._ClientType.Entity;
711      }
712      set
713      {
714        if ((this._ClientType.Entity != value))
715        {
716          this.SendPropertyChanging();
717          this._ClientType.Entity = value;
718          this.SendPropertyChanged("ClientType");
719        }
720      }
721    }
722   
723    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="OperatingSystem_Client", Storage="_OperatingSystem", ThisKey="OperatingSystemId", OtherKey="Id", IsForeignKey=true)]
724    public OperatingSystem OperatingSystem
725    {
726      get
727      {
728        return this._OperatingSystem.Entity;
729      }
730      set
731      {
732        if ((this._OperatingSystem.Entity != value))
733        {
734          this.SendPropertyChanging();
735          this._OperatingSystem.Entity = value;
736          this.SendPropertyChanged("OperatingSystem");
737        }
738      }
739    }
740   
741    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Country_Client", Storage="_Country", ThisKey="CountryId", OtherKey="Id", IsForeignKey=true)]
742    public Country Country
743    {
744      get
745      {
746        return this._Country.Entity;
747      }
748      set
749      {
750        if ((this._Country.Entity != value))
751        {
752          this.SendPropertyChanging();
753          this._Country.Entity = value;
754          this.SendPropertyChanged("Country");
755        }
756      }
757    }
758   
759    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="ClientConfiguration_Client", Storage="_ClientConfiguration", ThisKey="ClientConfigurationId", OtherKey="Id", IsForeignKey=true)]
760    public ClientConfiguration ClientConfiguration
761    {
762      get
763      {
764        return this._ClientConfiguration.Entity;
765      }
766      set
767      {
768        if ((this._ClientConfiguration.Entity != value))
769        {
770          this.SendPropertyChanging();
771          this._ClientConfiguration.Entity = value;
772          this.SendPropertyChanged("ClientConfiguration");
773        }
774      }
775    }
776  }
777 
778  public partial class ClientGroup : Resource
779  {
780   
781    #region Extensibility Method Definitions
782    partial void OnLoaded();
783    partial void OnValidate(System.Data.Linq.ChangeAction action);
784    partial void OnCreated();
785    #endregion
786   
787    public ClientGroup()
788    {
789      OnCreated();
790    }
791  }
792 
793  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.ResourceResourceGroup")]
794  public partial class ResourceResourceGroup : INotifyPropertyChanging, INotifyPropertyChanged
795  {
796   
797    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
798   
799    private System.Guid _ResourceId;
800   
801    private System.Guid _ResourceGroupId;
802   
803    private EntityRef<Resource> _Resource;
804   
805    private EntityRef<Resource> _Resource1;
806   
807    #region Extensibility Method Definitions
808    partial void OnLoaded();
809    partial void OnValidate(System.Data.Linq.ChangeAction action);
810    partial void OnCreated();
811    partial void OnResourceIdChanging(System.Guid value);
812    partial void OnResourceIdChanged();
813    partial void OnResourceGroupIdChanging(System.Guid value);
814    partial void OnResourceGroupIdChanged();
815    #endregion
816   
817    public ResourceResourceGroup()
818    {
819      this._Resource = default(EntityRef<Resource>);
820      this._Resource1 = default(EntityRef<Resource>);
821      OnCreated();
822    }
823   
824    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
825    public System.Guid ResourceId
826    {
827      get
828      {
829        return this._ResourceId;
830      }
831      set
832      {
833        if ((this._ResourceId != value))
834        {
835          if (this._Resource1.HasLoadedOrAssignedValue)
836          {
837            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
838          }
839          this.OnResourceIdChanging(value);
840          this.SendPropertyChanging();
841          this._ResourceId = value;
842          this.SendPropertyChanged("ResourceId");
843          this.OnResourceIdChanged();
844        }
845      }
846    }
847   
848    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceGroupId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
849    public System.Guid ResourceGroupId
850    {
851      get
852      {
853        return this._ResourceGroupId;
854      }
855      set
856      {
857        if ((this._ResourceGroupId != value))
858        {
859          if (this._Resource.HasLoadedOrAssignedValue)
860          {
861            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
862          }
863          this.OnResourceGroupIdChanging(value);
864          this.SendPropertyChanging();
865          this._ResourceGroupId = value;
866          this.SendPropertyChanged("ResourceGroupId");
867          this.OnResourceGroupIdChanged();
868        }
869      }
870    }
871   
872    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_ResourceResourceGroup", Storage="_Resource", ThisKey="ResourceGroupId", OtherKey="Id", IsForeignKey=true)]
873    public Resource ParentResource
874    {
875      get
876      {
877        return this._Resource.Entity;
878      }
879      set
880      {
881        Resource previousValue = this._Resource.Entity;
882        if (((previousValue != value)
883              || (this._Resource.HasLoadedOrAssignedValue == false)))
884        {
885          this.SendPropertyChanging();
886          if ((previousValue != null))
887          {
888            this._Resource.Entity = null;
889            previousValue.ResourceResourceGroupsChilds.Remove(this);
890          }
891          this._Resource.Entity = value;
892          if ((value != null))
893          {
894            value.ResourceResourceGroupsChilds.Add(this);
895            this._ResourceGroupId = value.Id;
896          }
897          else
898          {
899            this._ResourceGroupId = default(System.Guid);
900          }
901          this.SendPropertyChanged("ParentResource");
902        }
903      }
904    }
905   
906    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_ResourceResourceGroup1", Storage="_Resource1", ThisKey="ResourceId", OtherKey="Id", IsForeignKey=true)]
907    public Resource Resource
908    {
909      get
910      {
911        return this._Resource1.Entity;
912      }
913      set
914      {
915        Resource previousValue = this._Resource1.Entity;
916        if (((previousValue != value)
917              || (this._Resource1.HasLoadedOrAssignedValue == false)))
918        {
919          this.SendPropertyChanging();
920          if ((previousValue != null))
921          {
922            this._Resource1.Entity = null;
923            previousValue.ResourceResourceGroupsParents.Remove(this);
924          }
925          this._Resource1.Entity = value;
926          if ((value != null))
927          {
928            value.ResourceResourceGroupsParents.Add(this);
929            this._ResourceId = value.Id;
930          }
931          else
932          {
933            this._ResourceId = default(System.Guid);
934          }
935          this.SendPropertyChanged("Resource");
936        }
937      }
938    }
939   
940    public event PropertyChangingEventHandler PropertyChanging;
941   
942    public event PropertyChangedEventHandler PropertyChanged;
943   
944    protected virtual void SendPropertyChanging()
945    {
946      if ((this.PropertyChanging != null))
947      {
948        this.PropertyChanging(this, emptyChangingEventArgs);
949      }
950    }
951   
952    protected virtual void SendPropertyChanged(String propertyName)
953    {
954      if ((this.PropertyChanged != null))
955      {
956        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
957      }
958    }
959  }
960 
961  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.ClientLog")]
962  public partial class ClientLog : INotifyPropertyChanging, INotifyPropertyChanged
963  {
964   
965    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
966   
967    private System.DateTime _Timestamp;
968   
969    private System.Guid _ResourceId;
970   
971    private string _Message;
972   
973    private EntityRef<Resource> _Resource;
974   
975    #region Extensibility Method Definitions
976    partial void OnLoaded();
977    partial void OnValidate(System.Data.Linq.ChangeAction action);
978    partial void OnCreated();
979    partial void OnTimestampChanging(System.DateTime value);
980    partial void OnTimestampChanged();
981    partial void OnResourceIdChanging(System.Guid value);
982    partial void OnResourceIdChanged();
983    partial void OnMessageChanging(string value);
984    partial void OnMessageChanged();
985    #endregion
986   
987    public ClientLog()
988    {
989      this._Resource = default(EntityRef<Resource>);
990      OnCreated();
991    }
992   
993    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Timestamp", DbType="DateTime NOT NULL", IsPrimaryKey=true)]
994    public System.DateTime Timestamp
995    {
996      get
997      {
998        return this._Timestamp;
999      }
1000      set
1001      {
1002        if ((this._Timestamp != value))
1003        {
1004          this.OnTimestampChanging(value);
1005          this.SendPropertyChanging();
1006          this._Timestamp = value;
1007          this.SendPropertyChanged("Timestamp");
1008          this.OnTimestampChanged();
1009        }
1010      }
1011    }
1012   
1013    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
1014    public System.Guid ResourceId
1015    {
1016      get
1017      {
1018        return this._ResourceId;
1019      }
1020      set
1021      {
1022        if ((this._ResourceId != value))
1023        {
1024          if (this._Resource.HasLoadedOrAssignedValue)
1025          {
1026            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
1027          }
1028          this.OnResourceIdChanging(value);
1029          this.SendPropertyChanging();
1030          this._ResourceId = value;
1031          this.SendPropertyChanged("ResourceId");
1032          this.OnResourceIdChanged();
1033        }
1034      }
1035    }
1036   
1037    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Message", DbType="NVarChar(MAX)")]
1038    public string Message
1039    {
1040      get
1041      {
1042        return this._Message;
1043      }
1044      set
1045      {
1046        if ((this._Message != value))
1047        {
1048          this.OnMessageChanging(value);
1049          this.SendPropertyChanging();
1050          this._Message = value;
1051          this.SendPropertyChanged("Message");
1052          this.OnMessageChanged();
1053        }
1054      }
1055    }
1056   
1057    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_ClientLog", Storage="_Resource", ThisKey="ResourceId", OtherKey="Id", IsForeignKey=true)]
1058    public Resource Resource
1059    {
1060      get
1061      {
1062        return this._Resource.Entity;
1063      }
1064      set
1065      {
1066        Resource previousValue = this._Resource.Entity;
1067        if (((previousValue != value)
1068              || (this._Resource.HasLoadedOrAssignedValue == false)))
1069        {
1070          this.SendPropertyChanging();
1071          if ((previousValue != null))
1072          {
1073            this._Resource.Entity = null;
1074            previousValue.ClientLogs.Remove(this);
1075          }
1076          this._Resource.Entity = value;
1077          if ((value != null))
1078          {
1079            value.ClientLogs.Add(this);
1080            this._ResourceId = value.Id;
1081          }
1082          else
1083          {
1084            this._ResourceId = default(System.Guid);
1085          }
1086          this.SendPropertyChanged("Resource");
1087        }
1088      }
1089    }
1090   
1091    public event PropertyChangingEventHandler PropertyChanging;
1092   
1093    public event PropertyChangedEventHandler PropertyChanged;
1094   
1095    protected virtual void SendPropertyChanging()
1096    {
1097      if ((this.PropertyChanging != null))
1098      {
1099        this.PropertyChanging(this, emptyChangingEventArgs);
1100      }
1101    }
1102   
1103    protected virtual void SendPropertyChanged(String propertyName)
1104    {
1105      if ((this.PropertyChanged != null))
1106      {
1107        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1108      }
1109    }
1110  }
1111 
1112  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.ClientError")]
1113  public partial class ClientError : INotifyPropertyChanging, INotifyPropertyChanged
1114  {
1115   
1116    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1117   
1118    private System.Guid _Id;
1119   
1120    private System.DateTime _Timestamp;
1121   
1122    private string _Exception;
1123   
1124    private string _UserComment;
1125   
1126    private string _ConfigDump;
1127   
1128    private System.Nullable<System.Guid> _ClientId;
1129   
1130    private System.Nullable<System.Guid> _UserId;
1131   
1132    #region Extensibility Method Definitions
1133    partial void OnLoaded();
1134    partial void OnValidate(System.Data.Linq.ChangeAction action);
1135    partial void OnCreated();
1136    partial void OnIdChanging(System.Guid value);
1137    partial void OnIdChanged();
1138    partial void OnTimestampChanging(System.DateTime value);
1139    partial void OnTimestampChanged();
1140    partial void OnExceptionChanging(string value);
1141    partial void OnExceptionChanged();
1142    partial void OnUserCommentChanging(string value);
1143    partial void OnUserCommentChanged();
1144    partial void OnConfigDumpChanging(string value);
1145    partial void OnConfigDumpChanged();
1146    partial void OnClientIdChanging(System.Nullable<System.Guid> value);
1147    partial void OnClientIdChanged();
1148    partial void OnUserIdChanging(System.Nullable<System.Guid> value);
1149    partial void OnUserIdChanged();
1150    #endregion
1151   
1152    public ClientError()
1153    {
1154      OnCreated();
1155    }
1156   
1157    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
1158    public System.Guid Id
1159    {
1160      get
1161      {
1162        return this._Id;
1163      }
1164      set
1165      {
1166        if ((this._Id != value))
1167        {
1168          this.OnIdChanging(value);
1169          this.SendPropertyChanging();
1170          this._Id = value;
1171          this.SendPropertyChanged("Id");
1172          this.OnIdChanged();
1173        }
1174      }
1175    }
1176   
1177    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Timestamp", DbType="DateTime NOT NULL")]
1178    public System.DateTime Timestamp
1179    {
1180      get
1181      {
1182        return this._Timestamp;
1183      }
1184      set
1185      {
1186        if ((this._Timestamp != value))
1187        {
1188          this.OnTimestampChanging(value);
1189          this.SendPropertyChanging();
1190          this._Timestamp = value;
1191          this.SendPropertyChanged("Timestamp");
1192          this.OnTimestampChanged();
1193        }
1194      }
1195    }
1196   
1197    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Exception", DbType="NVarChar(MAX)")]
1198    public string Exception
1199    {
1200      get
1201      {
1202        return this._Exception;
1203      }
1204      set
1205      {
1206        if ((this._Exception != value))
1207        {
1208          this.OnExceptionChanging(value);
1209          this.SendPropertyChanging();
1210          this._Exception = value;
1211          this.SendPropertyChanged("Exception");
1212          this.OnExceptionChanged();
1213        }
1214      }
1215    }
1216   
1217    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserComment", DbType="NVarChar(MAX)")]
1218    public string UserComment
1219    {
1220      get
1221      {
1222        return this._UserComment;
1223      }
1224      set
1225      {
1226        if ((this._UserComment != value))
1227        {
1228          this.OnUserCommentChanging(value);
1229          this.SendPropertyChanging();
1230          this._UserComment = value;
1231          this.SendPropertyChanged("UserComment");
1232          this.OnUserCommentChanged();
1233        }
1234      }
1235    }
1236   
1237    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ConfigDump", DbType="NVarChar(MAX)")]
1238    public string ConfigDump
1239    {
1240      get
1241      {
1242        return this._ConfigDump;
1243      }
1244      set
1245      {
1246        if ((this._ConfigDump != value))
1247        {
1248          this.OnConfigDumpChanging(value);
1249          this.SendPropertyChanging();
1250          this._ConfigDump = value;
1251          this.SendPropertyChanged("ConfigDump");
1252          this.OnConfigDumpChanged();
1253        }
1254      }
1255    }
1256   
1257    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ClientId", DbType="UniqueIdentifier")]
1258    public System.Nullable<System.Guid> ClientId
1259    {
1260      get
1261      {
1262        return this._ClientId;
1263      }
1264      set
1265      {
1266        if ((this._ClientId != value))
1267        {
1268          this.OnClientIdChanging(value);
1269          this.SendPropertyChanging();
1270          this._ClientId = value;
1271          this.SendPropertyChanged("ClientId");
1272          this.OnClientIdChanged();
1273        }
1274      }
1275    }
1276   
1277    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier")]
1278    public System.Nullable<System.Guid> UserId
1279    {
1280      get
1281      {
1282        return this._UserId;
1283      }
1284      set
1285      {
1286        if ((this._UserId != value))
1287        {
1288          this.OnUserIdChanging(value);
1289          this.SendPropertyChanging();
1290          this._UserId = value;
1291          this.SendPropertyChanged("UserId");
1292          this.OnUserIdChanged();
1293        }
1294      }
1295    }
1296   
1297    public event PropertyChangingEventHandler PropertyChanging;
1298   
1299    public event PropertyChangedEventHandler PropertyChanged;
1300   
1301    protected virtual void SendPropertyChanging()
1302    {
1303      if ((this.PropertyChanging != null))
1304      {
1305        this.PropertyChanging(this, emptyChangingEventArgs);
1306      }
1307    }
1308   
1309    protected virtual void SendPropertyChanged(String propertyName)
1310    {
1311      if ((this.PropertyChanged != null))
1312      {
1313        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1314      }
1315    }
1316  }
1317 
1318  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.UserGroup")]
1319  [global::System.Data.Linq.Mapping.InheritanceMappingAttribute(Code="UserGroupBase", Type=typeof(UserGroupBase), IsDefault=true)]
1320  [global::System.Data.Linq.Mapping.InheritanceMappingAttribute(Code="User", Type=typeof(User))]
1321  [global::System.Data.Linq.Mapping.InheritanceMappingAttribute(Code="UserGroup", Type=typeof(UserGroup))]
1322  public partial class UserGroupBase : INotifyPropertyChanging, INotifyPropertyChanged
1323  {
1324   
1325    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1326   
1327    private System.Guid _Id;
1328   
1329    private string _Type;
1330   
1331    private EntitySet<UserGroupUserGroup> _UserGroupUserGroups;
1332   
1333    private EntitySet<UserGroupUserGroup> _UserGroupUserGroups1;
1334   
1335    #region Extensibility Method Definitions
1336    partial void OnLoaded();
1337    partial void OnValidate(System.Data.Linq.ChangeAction action);
1338    partial void OnCreated();
1339    partial void OnIdChanging(System.Guid value);
1340    partial void OnIdChanged();
1341    partial void OnTypeChanging(string value);
1342    partial void OnTypeChanged();
1343    #endregion
1344   
1345    public UserGroupBase()
1346    {
1347      this._UserGroupUserGroups = new EntitySet<UserGroupUserGroup>(new Action<UserGroupUserGroup>(this.attach_UserGroupUserGroups), new Action<UserGroupUserGroup>(this.detach_UserGroupUserGroups));
1348      this._UserGroupUserGroups1 = new EntitySet<UserGroupUserGroup>(new Action<UserGroupUserGroup>(this.attach_UserGroupUserGroups1), new Action<UserGroupUserGroup>(this.detach_UserGroupUserGroups1));
1349      OnCreated();
1350    }
1351   
1352    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
1353    public System.Guid Id
1354    {
1355      get
1356      {
1357        return this._Id;
1358      }
1359      set
1360      {
1361        if ((this._Id != value))
1362        {
1363          this.OnIdChanging(value);
1364          this.SendPropertyChanging();
1365          this._Id = value;
1366          this.SendPropertyChanged("Id");
1367          this.OnIdChanged();
1368        }
1369      }
1370    }
1371   
1372    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Type", DbType="NVarChar(10) NOT NULL", CanBeNull=false, IsDiscriminator=true)]
1373    public string Type
1374    {
1375      get
1376      {
1377        return this._Type;
1378      }
1379      set
1380      {
1381        if ((this._Type != value))
1382        {
1383          this.OnTypeChanging(value);
1384          this.SendPropertyChanging();
1385          this._Type = value;
1386          this.SendPropertyChanged("Type");
1387          this.OnTypeChanged();
1388        }
1389      }
1390    }
1391   
1392    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="UserGroupBase_UserGroupUserGroup", Storage="_UserGroupUserGroups", ThisKey="Id", OtherKey="UserGroupId")]
1393    public EntitySet<UserGroupUserGroup> UserGroupUserGroupsChilds
1394    {
1395      get
1396      {
1397        return this._UserGroupUserGroups;
1398      }
1399      set
1400      {
1401        this._UserGroupUserGroups.Assign(value);
1402      }
1403    }
1404   
1405    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="UserGroupBase_UserGroupUserGroup1", Storage="_UserGroupUserGroups1", ThisKey="Id", OtherKey="UserGroupUserGroupId")]
1406    public EntitySet<UserGroupUserGroup> UserGroupUserGroupsParents
1407    {
1408      get
1409      {
1410        return this._UserGroupUserGroups1;
1411      }
1412      set
1413      {
1414        this._UserGroupUserGroups1.Assign(value);
1415      }
1416    }
1417   
1418    public event PropertyChangingEventHandler PropertyChanging;
1419   
1420    public event PropertyChangedEventHandler PropertyChanged;
1421   
1422    protected virtual void SendPropertyChanging()
1423    {
1424      if ((this.PropertyChanging != null))
1425      {
1426        this.PropertyChanging(this, emptyChangingEventArgs);
1427      }
1428    }
1429   
1430    protected virtual void SendPropertyChanged(String propertyName)
1431    {
1432      if ((this.PropertyChanged != null))
1433      {
1434        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1435      }
1436    }
1437   
1438    private void attach_UserGroupUserGroups(UserGroupUserGroup entity)
1439    {
1440      this.SendPropertyChanging();
1441      entity.UserGroup = this;
1442    }
1443   
1444    private void detach_UserGroupUserGroups(UserGroupUserGroup entity)
1445    {
1446      this.SendPropertyChanging();
1447      entity.UserGroup = null;
1448    }
1449   
1450    private void attach_UserGroupUserGroups1(UserGroupUserGroup entity)
1451    {
1452      this.SendPropertyChanging();
1453      entity.UserGroupBase = this;
1454    }
1455   
1456    private void detach_UserGroupUserGroups1(UserGroupUserGroup entity)
1457    {
1458      this.SendPropertyChanging();
1459      entity.UserGroupBase = null;
1460    }
1461  }
1462 
1463  public partial class User : UserGroupBase
1464  {
1465   
1466    private string _FullName;
1467   
1468    #region Extensibility Method Definitions
1469    partial void OnLoaded();
1470    partial void OnValidate(System.Data.Linq.ChangeAction action);
1471    partial void OnCreated();
1472    partial void OnFullNameChanging(string value);
1473    partial void OnFullNameChanged();
1474    #endregion
1475   
1476    public User()
1477    {
1478      OnCreated();
1479    }
1480   
1481    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_FullName", DbType="NVarChar(MAX)")]
1482    public string FullName
1483    {
1484      get
1485      {
1486        return this._FullName;
1487      }
1488      set
1489      {
1490        if ((this._FullName != value))
1491        {
1492          this.OnFullNameChanging(value);
1493          this.SendPropertyChanging();
1494          this._FullName = value;
1495          this.SendPropertyChanged("FullName");
1496          this.OnFullNameChanged();
1497        }
1498      }
1499    }
1500  }
1501 
1502  public partial class UserGroup : UserGroupBase
1503  {
1504   
1505    private string _Name;
1506   
1507    #region Extensibility Method Definitions
1508    partial void OnLoaded();
1509    partial void OnValidate(System.Data.Linq.ChangeAction action);
1510    partial void OnCreated();
1511    partial void OnNameChanging(string value);
1512    partial void OnNameChanged();
1513    #endregion
1514   
1515    public UserGroup()
1516    {
1517      OnCreated();
1518    }
1519   
1520    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(MAX)")]
1521    public string Name
1522    {
1523      get
1524      {
1525        return this._Name;
1526      }
1527      set
1528      {
1529        if ((this._Name != value))
1530        {
1531          this.OnNameChanging(value);
1532          this.SendPropertyChanging();
1533          this._Name = value;
1534          this.SendPropertyChanged("Name");
1535          this.OnNameChanged();
1536        }
1537      }
1538    }
1539  }
1540 
1541  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.ClientType")]
1542  public partial class ClientType : INotifyPropertyChanging, INotifyPropertyChanged
1543  {
1544   
1545    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1546   
1547    private System.Guid _Id;
1548   
1549    private string _Name;
1550   
1551    #region Extensibility Method Definitions
1552    partial void OnLoaded();
1553    partial void OnValidate(System.Data.Linq.ChangeAction action);
1554    partial void OnCreated();
1555    partial void OnIdChanging(System.Guid value);
1556    partial void OnIdChanged();
1557    partial void OnNameChanging(string value);
1558    partial void OnNameChanged();
1559    #endregion
1560   
1561    public ClientType()
1562    {
1563      OnCreated();
1564    }
1565   
1566    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
1567    public System.Guid Id
1568    {
1569      get
1570      {
1571        return this._Id;
1572      }
1573      set
1574      {
1575        if ((this._Id != value))
1576        {
1577          this.OnIdChanging(value);
1578          this.SendPropertyChanging();
1579          this._Id = value;
1580          this.SendPropertyChanged("Id");
1581          this.OnIdChanged();
1582        }
1583      }
1584    }
1585   
1586    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(MAX) NOT NULL", CanBeNull=false)]
1587    public string Name
1588    {
1589      get
1590      {
1591        return this._Name;
1592      }
1593      set
1594      {
1595        if ((this._Name != value))
1596        {
1597          this.OnNameChanging(value);
1598          this.SendPropertyChanging();
1599          this._Name = value;
1600          this.SendPropertyChanged("Name");
1601          this.OnNameChanged();
1602        }
1603      }
1604    }
1605   
1606    public event PropertyChangingEventHandler PropertyChanging;
1607   
1608    public event PropertyChangedEventHandler PropertyChanged;
1609   
1610    protected virtual void SendPropertyChanging()
1611    {
1612      if ((this.PropertyChanging != null))
1613      {
1614        this.PropertyChanging(this, emptyChangingEventArgs);
1615      }
1616    }
1617   
1618    protected virtual void SendPropertyChanged(String propertyName)
1619    {
1620      if ((this.PropertyChanged != null))
1621      {
1622        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1623      }
1624    }
1625  }
1626 
1627  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.OperatingSystem")]
1628  public partial class OperatingSystem : INotifyPropertyChanging, INotifyPropertyChanged
1629  {
1630   
1631    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1632   
1633    private System.Guid _Id;
1634   
1635    private string _Name;
1636   
1637    #region Extensibility Method Definitions
1638    partial void OnLoaded();
1639    partial void OnValidate(System.Data.Linq.ChangeAction action);
1640    partial void OnCreated();
1641    partial void OnIdChanging(System.Guid value);
1642    partial void OnIdChanged();
1643    partial void OnNameChanging(string value);
1644    partial void OnNameChanged();
1645    #endregion
1646   
1647    public OperatingSystem()
1648    {
1649      OnCreated();
1650    }
1651   
1652    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
1653    public System.Guid Id
1654    {
1655      get
1656      {
1657        return this._Id;
1658      }
1659      set
1660      {
1661        if ((this._Id != value))
1662        {
1663          this.OnIdChanging(value);
1664          this.SendPropertyChanging();
1665          this._Id = value;
1666          this.SendPropertyChanged("Id");
1667          this.OnIdChanged();
1668        }
1669      }
1670    }
1671   
1672    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(MAX) NOT NULL", CanBeNull=false)]
1673    public string Name
1674    {
1675      get
1676      {
1677        return this._Name;
1678      }
1679      set
1680      {
1681        if ((this._Name != value))
1682        {
1683          this.OnNameChanging(value);
1684          this.SendPropertyChanging();
1685          this._Name = value;
1686          this.SendPropertyChanged("Name");
1687          this.OnNameChanged();
1688        }
1689      }
1690    }
1691   
1692    public event PropertyChangingEventHandler PropertyChanging;
1693   
1694    public event PropertyChangedEventHandler PropertyChanged;
1695   
1696    protected virtual void SendPropertyChanging()
1697    {
1698      if ((this.PropertyChanging != null))
1699      {
1700        this.PropertyChanging(this, emptyChangingEventArgs);
1701      }
1702    }
1703   
1704    protected virtual void SendPropertyChanged(String propertyName)
1705    {
1706      if ((this.PropertyChanged != null))
1707      {
1708        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1709      }
1710    }
1711  }
1712 
1713  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Country")]
1714  public partial class Country : INotifyPropertyChanging, INotifyPropertyChanged
1715  {
1716   
1717    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1718   
1719    private System.Guid _Id;
1720   
1721    private string _Name;
1722   
1723    #region Extensibility Method Definitions
1724    partial void OnLoaded();
1725    partial void OnValidate(System.Data.Linq.ChangeAction action);
1726    partial void OnCreated();
1727    partial void OnIdChanging(System.Guid value);
1728    partial void OnIdChanged();
1729    partial void OnNameChanging(string value);
1730    partial void OnNameChanged();
1731    #endregion
1732   
1733    public Country()
1734    {
1735      OnCreated();
1736    }
1737   
1738    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
1739    public System.Guid Id
1740    {
1741      get
1742      {
1743        return this._Id;
1744      }
1745      set
1746      {
1747        if ((this._Id != value))
1748        {
1749          this.OnIdChanging(value);
1750          this.SendPropertyChanging();
1751          this._Id = value;
1752          this.SendPropertyChanged("Id");
1753          this.OnIdChanged();
1754        }
1755      }
1756    }
1757   
1758    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(MAX) NOT NULL", CanBeNull=false)]
1759    public string Name
1760    {
1761      get
1762      {
1763        return this._Name;
1764      }
1765      set
1766      {
1767        if ((this._Name != value))
1768        {
1769          this.OnNameChanging(value);
1770          this.SendPropertyChanging();
1771          this._Name = value;
1772          this.SendPropertyChanged("Name");
1773          this.OnNameChanged();
1774        }
1775      }
1776    }
1777   
1778    public event PropertyChangingEventHandler PropertyChanging;
1779   
1780    public event PropertyChangedEventHandler PropertyChanged;
1781   
1782    protected virtual void SendPropertyChanging()
1783    {
1784      if ((this.PropertyChanging != null))
1785      {
1786        this.PropertyChanging(this, emptyChangingEventArgs);
1787      }
1788    }
1789   
1790    protected virtual void SendPropertyChanged(String propertyName)
1791    {
1792      if ((this.PropertyChanged != null))
1793      {
1794        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1795      }
1796    }
1797  }
1798 
1799  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.ClientConfiguration")]
1800  public partial class ClientConfiguration : INotifyPropertyChanging, INotifyPropertyChanged
1801  {
1802   
1803    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1804   
1805    private System.Guid _Id;
1806   
1807    private string _Hash;
1808   
1809    private string _Description;
1810   
1811    #region Extensibility Method Definitions
1812    partial void OnLoaded();
1813    partial void OnValidate(System.Data.Linq.ChangeAction action);
1814    partial void OnCreated();
1815    partial void OnIdChanging(System.Guid value);
1816    partial void OnIdChanged();
1817    partial void OnHashChanging(string value);
1818    partial void OnHashChanged();
1819    partial void OnDescriptionChanging(string value);
1820    partial void OnDescriptionChanged();
1821    #endregion
1822   
1823    public ClientConfiguration()
1824    {
1825      OnCreated();
1826    }
1827   
1828    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
1829    public System.Guid Id
1830    {
1831      get
1832      {
1833        return this._Id;
1834      }
1835      set
1836      {
1837        if ((this._Id != value))
1838        {
1839          this.OnIdChanging(value);
1840          this.SendPropertyChanging();
1841          this._Id = value;
1842          this.SendPropertyChanged("Id");
1843          this.OnIdChanged();
1844        }
1845      }
1846    }
1847   
1848    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Hash", DbType="NVarChar(MAX) NOT NULL", CanBeNull=false)]
1849    public string Hash
1850    {
1851      get
1852      {
1853        return this._Hash;
1854      }
1855      set
1856      {
1857        if ((this._Hash != value))
1858        {
1859          this.OnHashChanging(value);
1860          this.SendPropertyChanging();
1861          this._Hash = value;
1862          this.SendPropertyChanged("Hash");
1863          this.OnHashChanged();
1864        }
1865      }
1866    }
1867   
1868    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Description", DbType="NVarChar(MAX)")]
1869    public string Description
1870    {
1871      get
1872      {
1873        return this._Description;
1874      }
1875      set
1876      {
1877        if ((this._Description != value))
1878        {
1879          this.OnDescriptionChanging(value);
1880          this.SendPropertyChanging();
1881          this._Description = value;
1882          this.SendPropertyChanged("Description");
1883          this.OnDescriptionChanged();
1884        }
1885      }
1886    }
1887   
1888    public event PropertyChangingEventHandler PropertyChanging;
1889   
1890    public event PropertyChangedEventHandler PropertyChanged;
1891   
1892    protected virtual void SendPropertyChanging()
1893    {
1894      if ((this.PropertyChanging != null))
1895      {
1896        this.PropertyChanging(this, emptyChangingEventArgs);
1897      }
1898    }
1899   
1900    protected virtual void SendPropertyChanged(String propertyName)
1901    {
1902      if ((this.PropertyChanged != null))
1903      {
1904        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1905      }
1906    }
1907  }
1908 
1909  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Plugin")]
1910  public partial class Plugin : INotifyPropertyChanging, INotifyPropertyChanged
1911  {
1912   
1913    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1914   
1915    private System.Guid _Id;
1916   
1917    private string _Name;
1918   
1919    private string _StrongName;
1920   
1921    private string _Version;
1922   
1923    private EntitySet<ResourcePlugin> _ResourcePlugins;
1924   
1925    #region Extensibility Method Definitions
1926    partial void OnLoaded();
1927    partial void OnValidate(System.Data.Linq.ChangeAction action);
1928    partial void OnCreated();
1929    partial void OnIdChanging(System.Guid value);
1930    partial void OnIdChanged();
1931    partial void OnNameChanging(string value);
1932    partial void OnNameChanged();
1933    partial void OnStrongNameChanging(string value);
1934    partial void OnStrongNameChanged();
1935    partial void OnVersionChanging(string value);
1936    partial void OnVersionChanged();
1937    #endregion
1938   
1939    public Plugin()
1940    {
1941      this._ResourcePlugins = new EntitySet<ResourcePlugin>(new Action<ResourcePlugin>(this.attach_ResourcePlugins), new Action<ResourcePlugin>(this.detach_ResourcePlugins));
1942      OnCreated();
1943    }
1944   
1945    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
1946    public System.Guid Id
1947    {
1948      get
1949      {
1950        return this._Id;
1951      }
1952      set
1953      {
1954        if ((this._Id != value))
1955        {
1956          this.OnIdChanging(value);
1957          this.SendPropertyChanging();
1958          this._Id = value;
1959          this.SendPropertyChanged("Id");
1960          this.OnIdChanged();
1961        }
1962      }
1963    }
1964   
1965    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(MAX) NOT NULL", CanBeNull=false)]
1966    public string Name
1967    {
1968      get
1969      {
1970        return this._Name;
1971      }
1972      set
1973      {
1974        if ((this._Name != value))
1975        {
1976          this.OnNameChanging(value);
1977          this.SendPropertyChanging();
1978          this._Name = value;
1979          this.SendPropertyChanged("Name");
1980          this.OnNameChanged();
1981        }
1982      }
1983    }
1984   
1985    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StrongName", DbType="NVarChar(MAX)")]
1986    public string StrongName
1987    {
1988      get
1989      {
1990        return this._StrongName;
1991      }
1992      set
1993      {
1994        if ((this._StrongName != value))
1995        {
1996          this.OnStrongNameChanging(value);
1997          this.SendPropertyChanging();
1998          this._StrongName = value;
1999          this.SendPropertyChanged("StrongName");
2000          this.OnStrongNameChanged();
2001        }
2002      }
2003    }
2004   
2005    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Version", DbType="NVarChar(20) NOT NULL", CanBeNull=false)]
2006    public string Version
2007    {
2008      get
2009      {
2010        return this._Version;
2011      }
2012      set
2013      {
2014        if ((this._Version != value))
2015        {
2016          this.OnVersionChanging(value);
2017          this.SendPropertyChanging();
2018          this._Version = value;
2019          this.SendPropertyChanged("Version");
2020          this.OnVersionChanged();
2021        }
2022      }
2023    }
2024   
2025    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Plugin_ResourcePlugin", Storage="_ResourcePlugins", ThisKey="Id", OtherKey="PluginId")]
2026    public EntitySet<ResourcePlugin> ResourcePlugins
2027    {
2028      get
2029      {
2030        return this._ResourcePlugins;
2031      }
2032      set
2033      {
2034        this._ResourcePlugins.Assign(value);
2035      }
2036    }
2037   
2038    public event PropertyChangingEventHandler PropertyChanging;
2039   
2040    public event PropertyChangedEventHandler PropertyChanged;
2041   
2042    protected virtual void SendPropertyChanging()
2043    {
2044      if ((this.PropertyChanging != null))
2045      {
2046        this.PropertyChanging(this, emptyChangingEventArgs);
2047      }
2048    }
2049   
2050    protected virtual void SendPropertyChanged(String propertyName)
2051    {
2052      if ((this.PropertyChanged != null))
2053      {
2054        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2055      }
2056    }
2057   
2058    private void attach_ResourcePlugins(ResourcePlugin entity)
2059    {
2060      this.SendPropertyChanging();
2061      entity.Plugin = this;
2062    }
2063   
2064    private void detach_ResourcePlugins(ResourcePlugin entity)
2065    {
2066      this.SendPropertyChanging();
2067      entity.Plugin = null;
2068    }
2069  }
2070 
2071  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.ResourcePlugin")]
2072  public partial class ResourcePlugin : INotifyPropertyChanging, INotifyPropertyChanged
2073  {
2074   
2075    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2076   
2077    private System.Guid _ResourceId;
2078   
2079    private System.Guid _PluginId;
2080   
2081    private EntityRef<Plugin> _Plugin;
2082   
2083    private EntityRef<Resource> _Resource;
2084   
2085    #region Extensibility Method Definitions
2086    partial void OnLoaded();
2087    partial void OnValidate(System.Data.Linq.ChangeAction action);
2088    partial void OnCreated();
2089    partial void OnResourceIdChanging(System.Guid value);
2090    partial void OnResourceIdChanged();
2091    partial void OnPluginIdChanging(System.Guid value);
2092    partial void OnPluginIdChanged();
2093    #endregion
2094   
2095    public ResourcePlugin()
2096    {
2097      this._Plugin = default(EntityRef<Plugin>);
2098      this._Resource = default(EntityRef<Resource>);
2099      OnCreated();
2100    }
2101   
2102    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
2103    public System.Guid ResourceId
2104    {
2105      get
2106      {
2107        return this._ResourceId;
2108      }
2109      set
2110      {
2111        if ((this._ResourceId != value))
2112        {
2113          if (this._Resource.HasLoadedOrAssignedValue)
2114          {
2115            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2116          }
2117          this.OnResourceIdChanging(value);
2118          this.SendPropertyChanging();
2119          this._ResourceId = value;
2120          this.SendPropertyChanged("ResourceId");
2121          this.OnResourceIdChanged();
2122        }
2123      }
2124    }
2125   
2126    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
2127    public System.Guid PluginId
2128    {
2129      get
2130      {
2131        return this._PluginId;
2132      }
2133      set
2134      {
2135        if ((this._PluginId != value))
2136        {
2137          if (this._Plugin.HasLoadedOrAssignedValue)
2138          {
2139            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2140          }
2141          this.OnPluginIdChanging(value);
2142          this.SendPropertyChanging();
2143          this._PluginId = value;
2144          this.SendPropertyChanged("PluginId");
2145          this.OnPluginIdChanged();
2146        }
2147      }
2148    }
2149   
2150    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Plugin_ResourcePlugin", Storage="_Plugin", ThisKey="PluginId", OtherKey="Id", IsForeignKey=true)]
2151    public Plugin Plugin
2152    {
2153      get
2154      {
2155        return this._Plugin.Entity;
2156      }
2157      set
2158      {
2159        Plugin previousValue = this._Plugin.Entity;
2160        if (((previousValue != value)
2161              || (this._Plugin.HasLoadedOrAssignedValue == false)))
2162        {
2163          this.SendPropertyChanging();
2164          if ((previousValue != null))
2165          {
2166            this._Plugin.Entity = null;
2167            previousValue.ResourcePlugins.Remove(this);
2168          }
2169          this._Plugin.Entity = value;
2170          if ((value != null))
2171          {
2172            value.ResourcePlugins.Add(this);
2173            this._PluginId = value.Id;
2174          }
2175          else
2176          {
2177            this._PluginId = default(System.Guid);
2178          }
2179          this.SendPropertyChanged("Plugin");
2180        }
2181      }
2182    }
2183   
2184    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_ResourcePlugin", Storage="_Resource", ThisKey="ResourceId", OtherKey="Id", IsForeignKey=true)]
2185    public Resource Resource
2186    {
2187      get
2188      {
2189        return this._Resource.Entity;
2190      }
2191      set
2192      {
2193        Resource previousValue = this._Resource.Entity;
2194        if (((previousValue != value)
2195              || (this._Resource.HasLoadedOrAssignedValue == false)))
2196        {
2197          this.SendPropertyChanging();
2198          if ((previousValue != null))
2199          {
2200            this._Resource.Entity = null;
2201            previousValue.ResourcePlugins.Remove(this);
2202          }
2203          this._Resource.Entity = value;
2204          if ((value != null))
2205          {
2206            value.ResourcePlugins.Add(this);
2207            this._ResourceId = value.Id;
2208          }
2209          else
2210          {
2211            this._ResourceId = default(System.Guid);
2212          }
2213          this.SendPropertyChanged("Resource");
2214        }
2215      }
2216    }
2217   
2218    public event PropertyChangingEventHandler PropertyChanging;
2219   
2220    public event PropertyChangedEventHandler PropertyChanged;
2221   
2222    protected virtual void SendPropertyChanging()
2223    {
2224      if ((this.PropertyChanging != null))
2225      {
2226        this.PropertyChanging(this, emptyChangingEventArgs);
2227      }
2228    }
2229   
2230    protected virtual void SendPropertyChanged(String propertyName)
2231    {
2232      if ((this.PropertyChanged != null))
2233      {
2234        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2235      }
2236    }
2237  }
2238 
2239  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.UserGroupUserGroup")]
2240  public partial class UserGroupUserGroup : INotifyPropertyChanging, INotifyPropertyChanged
2241  {
2242   
2243    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2244   
2245    private System.Guid _UserGroupId;
2246   
2247    private System.Guid _UserGroupUserGroupId;
2248   
2249    private EntityRef<UserGroupBase> _UserGroup;
2250   
2251    private EntityRef<UserGroupBase> _UserGroupBase;
2252   
2253    #region Extensibility Method Definitions
2254    partial void OnLoaded();
2255    partial void OnValidate(System.Data.Linq.ChangeAction action);
2256    partial void OnCreated();
2257    partial void OnUserGroupIdChanging(System.Guid value);
2258    partial void OnUserGroupIdChanged();
2259    partial void OnUserGroupUserGroupIdChanging(System.Guid value);
2260    partial void OnUserGroupUserGroupIdChanged();
2261    #endregion
2262   
2263    public UserGroupUserGroup()
2264    {
2265      this._UserGroup = default(EntityRef<UserGroupBase>);
2266      this._UserGroupBase = default(EntityRef<UserGroupBase>);
2267      OnCreated();
2268    }
2269   
2270    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserGroupId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
2271    public System.Guid UserGroupId
2272    {
2273      get
2274      {
2275        return this._UserGroupId;
2276      }
2277      set
2278      {
2279        if ((this._UserGroupId != value))
2280        {
2281          if (this._UserGroup.HasLoadedOrAssignedValue)
2282          {
2283            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2284          }
2285          this.OnUserGroupIdChanging(value);
2286          this.SendPropertyChanging();
2287          this._UserGroupId = value;
2288          this.SendPropertyChanged("UserGroupId");
2289          this.OnUserGroupIdChanged();
2290        }
2291      }
2292    }
2293   
2294    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserGroupUserGroupId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
2295    public System.Guid UserGroupUserGroupId
2296    {
2297      get
2298      {
2299        return this._UserGroupUserGroupId;
2300      }
2301      set
2302      {
2303        if ((this._UserGroupUserGroupId != value))
2304        {
2305          if (this._UserGroupBase.HasLoadedOrAssignedValue)
2306          {
2307            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2308          }
2309          this.OnUserGroupUserGroupIdChanging(value);
2310          this.SendPropertyChanging();
2311          this._UserGroupUserGroupId = value;
2312          this.SendPropertyChanged("UserGroupUserGroupId");
2313          this.OnUserGroupUserGroupIdChanged();
2314        }
2315      }
2316    }
2317   
2318    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="UserGroupBase_UserGroupUserGroup", Storage="_UserGroup", ThisKey="UserGroupId", OtherKey="Id", IsForeignKey=true)]
2319    public UserGroupBase UserGroup
2320    {
2321      get
2322      {
2323        return this._UserGroup.Entity;
2324      }
2325      set
2326      {
2327        UserGroupBase previousValue = this._UserGroup.Entity;
2328        if (((previousValue != value)
2329              || (this._UserGroup.HasLoadedOrAssignedValue == false)))
2330        {
2331          this.SendPropertyChanging();
2332          if ((previousValue != null))
2333          {
2334            this._UserGroup.Entity = null;
2335            previousValue.UserGroupUserGroupsChilds.Remove(this);
2336          }
2337          this._UserGroup.Entity = value;
2338          if ((value != null))
2339          {
2340            value.UserGroupUserGroupsChilds.Add(this);
2341            this._UserGroupId = value.Id;
2342          }
2343          else
2344          {
2345            this._UserGroupId = default(System.Guid);
2346          }
2347          this.SendPropertyChanged("UserGroup");
2348        }
2349      }
2350    }
2351   
2352    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="UserGroupBase_UserGroupUserGroup1", Storage="_UserGroupBase", ThisKey="UserGroupUserGroupId", OtherKey="Id", IsForeignKey=true)]
2353    public UserGroupBase UserGroupBase
2354    {
2355      get
2356      {
2357        return this._UserGroupBase.Entity;
2358      }
2359      set
2360      {
2361        UserGroupBase previousValue = this._UserGroupBase.Entity;
2362        if (((previousValue != value)
2363              || (this._UserGroupBase.HasLoadedOrAssignedValue == false)))
2364        {
2365          this.SendPropertyChanging();
2366          if ((previousValue != null))
2367          {
2368            this._UserGroupBase.Entity = null;
2369            previousValue.UserGroupUserGroupsParents.Remove(this);
2370          }
2371          this._UserGroupBase.Entity = value;
2372          if ((value != null))
2373          {
2374            value.UserGroupUserGroupsParents.Add(this);
2375            this._UserGroupUserGroupId = value.Id;
2376          }
2377          else
2378          {
2379            this._UserGroupUserGroupId = default(System.Guid);
2380          }
2381          this.SendPropertyChanged("UserGroupBase");
2382        }
2383      }
2384    }
2385   
2386    public event PropertyChangingEventHandler PropertyChanging;
2387   
2388    public event PropertyChangedEventHandler PropertyChanged;
2389   
2390    protected virtual void SendPropertyChanging()
2391    {
2392      if ((this.PropertyChanging != null))
2393      {
2394        this.PropertyChanging(this, emptyChangingEventArgs);
2395      }
2396    }
2397   
2398    protected virtual void SendPropertyChanged(String propertyName)
2399    {
2400      if ((this.PropertyChanged != null))
2401      {
2402        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2403      }
2404    }
2405  }
2406}
2407#pragma warning restore 1591
Note: See TracBrowser for help on using the repository browser.