Free cookie consent management tool by TermsFeed Policy Generator

source: branches/2839_HiveProjectManagement/HeuristicLab.Services.Access.DataAccess/3.3/AccessService.designer.cs @ 17958

Last change on this file since 17958 was 11623, checked in by ascheibe, 10 years ago

#2280 switched all projects to .NET 4.5 (ExtLibs, HL, Tests, Services, Slave)
File size: 64.9 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.34014
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 AccessServiceDataContext : 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 AccessServiceDataContext() :
72        base(global::HeuristicLab.Services.Access.DataAccess.Properties.Settings.Default.HeuristicLab_ClientManagementConnectionString, mappingSource)
73    {
74      OnCreated();
75    }
76   
77    public AccessServiceDataContext(string connection) :
78        base(connection, mappingSource)
79    {
80      OnCreated();
81    }
82   
83    public AccessServiceDataContext(System.Data.IDbConnection connection) :
84        base(connection, mappingSource)
85    {
86      OnCreated();
87    }
88   
89    public AccessServiceDataContext(string connection, System.Data.Linq.Mapping.MappingSource mappingSource) :
90        base(connection, mappingSource)
91    {
92      OnCreated();
93    }
94   
95    public AccessServiceDataContext(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)]
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)")]
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 System.Nullable<double> _PerformanceValue;
469   
470    private EntityRef<ClientType> _ClientType;
471   
472    private EntityRef<OperatingSystem> _OperatingSystem;
473   
474    private EntityRef<Country> _Country;
475   
476    private EntityRef<ClientConfiguration> _ClientConfiguration;
477   
478    #region Extensibility Method Definitions
479    partial void OnLoaded();
480    partial void OnValidate(System.Data.Linq.ChangeAction action);
481    partial void OnCreated();
482    partial void OnHeuristicLabVersionChanging(string value);
483    partial void OnHeuristicLabVersionChanged();
484    partial void OnMemorySizeChanging(System.Nullable<int> value);
485    partial void OnMemorySizeChanged();
486    partial void OnTimestampChanging(System.Nullable<System.DateTime> value);
487    partial void OnTimestampChanged();
488    partial void OnNumberOfCoresChanging(System.Nullable<int> value);
489    partial void OnNumberOfCoresChanged();
490    partial void OnProcessorTypeChanging(string value);
491    partial void OnProcessorTypeChanged();
492    partial void OnClientTypeIdChanging(System.Nullable<System.Guid> value);
493    partial void OnClientTypeIdChanged();
494    partial void OnOperatingSystemIdChanging(System.Nullable<System.Guid> value);
495    partial void OnOperatingSystemIdChanged();
496    partial void OnClientConfigurationIdChanging(System.Nullable<System.Guid> value);
497    partial void OnClientConfigurationIdChanged();
498    partial void OnCountryIdChanging(System.Nullable<System.Guid> value);
499    partial void OnCountryIdChanged();
500    partial void OnPerformanceValueChanging(System.Nullable<double> value);
501    partial void OnPerformanceValueChanged();
502    #endregion
503   
504    public Client()
505    {
506      this._ClientType = default(EntityRef<ClientType>);
507      this._OperatingSystem = default(EntityRef<OperatingSystem>);
508      this._Country = default(EntityRef<Country>);
509      this._ClientConfiguration = default(EntityRef<ClientConfiguration>);
510      OnCreated();
511    }
512   
513    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_HeuristicLabVersion", DbType="NVarChar(MAX)")]
514    public string HeuristicLabVersion
515    {
516      get
517      {
518        return this._HeuristicLabVersion;
519      }
520      set
521      {
522        if ((this._HeuristicLabVersion != value))
523        {
524          this.OnHeuristicLabVersionChanging(value);
525          this.SendPropertyChanging();
526          this._HeuristicLabVersion = value;
527          this.SendPropertyChanged("HeuristicLabVersion");
528          this.OnHeuristicLabVersionChanged();
529        }
530      }
531    }
532   
533    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_MemorySize", DbType="Int")]
534    public System.Nullable<int> MemorySize
535    {
536      get
537      {
538        return this._MemorySize;
539      }
540      set
541      {
542        if ((this._MemorySize != value))
543        {
544          this.OnMemorySizeChanging(value);
545          this.SendPropertyChanging();
546          this._MemorySize = value;
547          this.SendPropertyChanged("MemorySize");
548          this.OnMemorySizeChanged();
549        }
550      }
551    }
552   
553    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Timestamp", DbType="DateTime")]
554    public System.Nullable<System.DateTime> Timestamp
555    {
556      get
557      {
558        return this._Timestamp;
559      }
560      set
561      {
562        if ((this._Timestamp != value))
563        {
564          this.OnTimestampChanging(value);
565          this.SendPropertyChanging();
566          this._Timestamp = value;
567          this.SendPropertyChanged("Timestamp");
568          this.OnTimestampChanged();
569        }
570      }
571    }
572   
573    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumberOfCores", DbType="Int")]
574    public System.Nullable<int> NumberOfCores
575    {
576      get
577      {
578        return this._NumberOfCores;
579      }
580      set
581      {
582        if ((this._NumberOfCores != value))
583        {
584          this.OnNumberOfCoresChanging(value);
585          this.SendPropertyChanging();
586          this._NumberOfCores = value;
587          this.SendPropertyChanged("NumberOfCores");
588          this.OnNumberOfCoresChanged();
589        }
590      }
591    }
592   
593    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ProcessorType", DbType="NVarChar(MAX)")]
594    public string ProcessorType
595    {
596      get
597      {
598        return this._ProcessorType;
599      }
600      set
601      {
602        if ((this._ProcessorType != value))
603        {
604          this.OnProcessorTypeChanging(value);
605          this.SendPropertyChanging();
606          this._ProcessorType = value;
607          this.SendPropertyChanged("ProcessorType");
608          this.OnProcessorTypeChanged();
609        }
610      }
611    }
612   
613    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ClientTypeId", DbType="UniqueIdentifier")]
614    public System.Nullable<System.Guid> ClientTypeId
615    {
616      get
617      {
618        return this._ClientTypeId;
619      }
620      set
621      {
622        if ((this._ClientTypeId != value))
623        {
624          if (this._ClientType.HasLoadedOrAssignedValue)
625          {
626            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
627          }
628          this.OnClientTypeIdChanging(value);
629          this.SendPropertyChanging();
630          this._ClientTypeId = value;
631          this.SendPropertyChanged("ClientTypeId");
632          this.OnClientTypeIdChanged();
633        }
634      }
635    }
636   
637    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_OperatingSystemId", DbType="UniqueIdentifier")]
638    public System.Nullable<System.Guid> OperatingSystemId
639    {
640      get
641      {
642        return this._OperatingSystemId;
643      }
644      set
645      {
646        if ((this._OperatingSystemId != value))
647        {
648          if (this._OperatingSystem.HasLoadedOrAssignedValue)
649          {
650            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
651          }
652          this.OnOperatingSystemIdChanging(value);
653          this.SendPropertyChanging();
654          this._OperatingSystemId = value;
655          this.SendPropertyChanged("OperatingSystemId");
656          this.OnOperatingSystemIdChanged();
657        }
658      }
659    }
660   
661    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ClientConfigurationId", DbType="UniqueIdentifier")]
662    public System.Nullable<System.Guid> ClientConfigurationId
663    {
664      get
665      {
666        return this._ClientConfigurationId;
667      }
668      set
669      {
670        if ((this._ClientConfigurationId != value))
671        {
672          if (this._ClientConfiguration.HasLoadedOrAssignedValue)
673          {
674            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
675          }
676          this.OnClientConfigurationIdChanging(value);
677          this.SendPropertyChanging();
678          this._ClientConfigurationId = value;
679          this.SendPropertyChanged("ClientConfigurationId");
680          this.OnClientConfigurationIdChanged();
681        }
682      }
683    }
684   
685    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CountryId", DbType="UniqueIdentifier")]
686    public System.Nullable<System.Guid> CountryId
687    {
688      get
689      {
690        return this._CountryId;
691      }
692      set
693      {
694        if ((this._CountryId != value))
695        {
696          if (this._Country.HasLoadedOrAssignedValue)
697          {
698            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
699          }
700          this.OnCountryIdChanging(value);
701          this.SendPropertyChanging();
702          this._CountryId = value;
703          this.SendPropertyChanged("CountryId");
704          this.OnCountryIdChanged();
705        }
706      }
707    }
708   
709    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PerformanceValue", DbType="real")]
710    public System.Nullable<double> PerformanceValue
711    {
712      get
713      {
714        return this._PerformanceValue;
715      }
716      set
717      {
718        if ((this._PerformanceValue != value))
719        {
720          this.OnPerformanceValueChanging(value);
721          this.SendPropertyChanging();
722          this._PerformanceValue = value;
723          this.SendPropertyChanged("PerformanceValue");
724          this.OnPerformanceValueChanged();
725        }
726      }
727    }
728   
729    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="ClientType_Client", Storage="_ClientType", ThisKey="ClientTypeId", OtherKey="Id", IsForeignKey=true)]
730    public ClientType ClientType
731    {
732      get
733      {
734        return this._ClientType.Entity;
735      }
736      set
737      {
738        if ((this._ClientType.Entity != value))
739        {
740          this.SendPropertyChanging();
741          this._ClientType.Entity = value;
742          this.SendPropertyChanged("ClientType");
743        }
744      }
745    }
746   
747    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="OperatingSystem_Client", Storage="_OperatingSystem", ThisKey="OperatingSystemId", OtherKey="Id", IsForeignKey=true)]
748    public OperatingSystem OperatingSystem
749    {
750      get
751      {
752        return this._OperatingSystem.Entity;
753      }
754      set
755      {
756        if ((this._OperatingSystem.Entity != value))
757        {
758          this.SendPropertyChanging();
759          this._OperatingSystem.Entity = value;
760          this.SendPropertyChanged("OperatingSystem");
761        }
762      }
763    }
764   
765    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Country_Client", Storage="_Country", ThisKey="CountryId", OtherKey="Id", IsForeignKey=true)]
766    public Country Country
767    {
768      get
769      {
770        return this._Country.Entity;
771      }
772      set
773      {
774        if ((this._Country.Entity != value))
775        {
776          this.SendPropertyChanging();
777          this._Country.Entity = value;
778          this.SendPropertyChanged("Country");
779        }
780      }
781    }
782   
783    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="ClientConfiguration_Client", Storage="_ClientConfiguration", ThisKey="ClientConfigurationId", OtherKey="Id", IsForeignKey=true)]
784    public ClientConfiguration ClientConfiguration
785    {
786      get
787      {
788        return this._ClientConfiguration.Entity;
789      }
790      set
791      {
792        if ((this._ClientConfiguration.Entity != value))
793        {
794          this.SendPropertyChanging();
795          this._ClientConfiguration.Entity = value;
796          this.SendPropertyChanged("ClientConfiguration");
797        }
798      }
799    }
800  }
801 
802  public partial class ClientGroup : Resource
803  {
804   
805    #region Extensibility Method Definitions
806    partial void OnLoaded();
807    partial void OnValidate(System.Data.Linq.ChangeAction action);
808    partial void OnCreated();
809    #endregion
810   
811    public ClientGroup()
812    {
813      OnCreated();
814    }
815  }
816 
817  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.ResourceResourceGroup")]
818  public partial class ResourceResourceGroup : INotifyPropertyChanging, INotifyPropertyChanged
819  {
820   
821    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
822   
823    private System.Guid _ResourceId;
824   
825    private System.Guid _ResourceGroupId;
826   
827    private EntityRef<Resource> _Resource;
828   
829    private EntityRef<Resource> _Resource1;
830   
831    #region Extensibility Method Definitions
832    partial void OnLoaded();
833    partial void OnValidate(System.Data.Linq.ChangeAction action);
834    partial void OnCreated();
835    partial void OnResourceIdChanging(System.Guid value);
836    partial void OnResourceIdChanged();
837    partial void OnResourceGroupIdChanging(System.Guid value);
838    partial void OnResourceGroupIdChanged();
839    #endregion
840   
841    public ResourceResourceGroup()
842    {
843      this._Resource = default(EntityRef<Resource>);
844      this._Resource1 = default(EntityRef<Resource>);
845      OnCreated();
846    }
847   
848    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
849    public System.Guid ResourceId
850    {
851      get
852      {
853        return this._ResourceId;
854      }
855      set
856      {
857        if ((this._ResourceId != value))
858        {
859          if (this._Resource1.HasLoadedOrAssignedValue)
860          {
861            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
862          }
863          this.OnResourceIdChanging(value);
864          this.SendPropertyChanging();
865          this._ResourceId = value;
866          this.SendPropertyChanged("ResourceId");
867          this.OnResourceIdChanged();
868        }
869      }
870    }
871   
872    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceGroupId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
873    public System.Guid ResourceGroupId
874    {
875      get
876      {
877        return this._ResourceGroupId;
878      }
879      set
880      {
881        if ((this._ResourceGroupId != value))
882        {
883          if (this._Resource.HasLoadedOrAssignedValue)
884          {
885            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
886          }
887          this.OnResourceGroupIdChanging(value);
888          this.SendPropertyChanging();
889          this._ResourceGroupId = value;
890          this.SendPropertyChanged("ResourceGroupId");
891          this.OnResourceGroupIdChanged();
892        }
893      }
894    }
895   
896    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_ResourceResourceGroup", Storage="_Resource", ThisKey="ResourceGroupId", OtherKey="Id", IsForeignKey=true)]
897    public Resource ParentResource
898    {
899      get
900      {
901        return this._Resource.Entity;
902      }
903      set
904      {
905        Resource previousValue = this._Resource.Entity;
906        if (((previousValue != value)
907              || (this._Resource.HasLoadedOrAssignedValue == false)))
908        {
909          this.SendPropertyChanging();
910          if ((previousValue != null))
911          {
912            this._Resource.Entity = null;
913            previousValue.ResourceResourceGroupsChilds.Remove(this);
914          }
915          this._Resource.Entity = value;
916          if ((value != null))
917          {
918            value.ResourceResourceGroupsChilds.Add(this);
919            this._ResourceGroupId = value.Id;
920          }
921          else
922          {
923            this._ResourceGroupId = default(System.Guid);
924          }
925          this.SendPropertyChanged("ParentResource");
926        }
927      }
928    }
929   
930    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_ResourceResourceGroup1", Storage="_Resource1", ThisKey="ResourceId", OtherKey="Id", IsForeignKey=true)]
931    public Resource Resource
932    {
933      get
934      {
935        return this._Resource1.Entity;
936      }
937      set
938      {
939        Resource previousValue = this._Resource1.Entity;
940        if (((previousValue != value)
941              || (this._Resource1.HasLoadedOrAssignedValue == false)))
942        {
943          this.SendPropertyChanging();
944          if ((previousValue != null))
945          {
946            this._Resource1.Entity = null;
947            previousValue.ResourceResourceGroupsParents.Remove(this);
948          }
949          this._Resource1.Entity = value;
950          if ((value != null))
951          {
952            value.ResourceResourceGroupsParents.Add(this);
953            this._ResourceId = value.Id;
954          }
955          else
956          {
957            this._ResourceId = default(System.Guid);
958          }
959          this.SendPropertyChanged("Resource");
960        }
961      }
962    }
963   
964    public event PropertyChangingEventHandler PropertyChanging;
965   
966    public event PropertyChangedEventHandler PropertyChanged;
967   
968    protected virtual void SendPropertyChanging()
969    {
970      if ((this.PropertyChanging != null))
971      {
972        this.PropertyChanging(this, emptyChangingEventArgs);
973      }
974    }
975   
976    protected virtual void SendPropertyChanged(String propertyName)
977    {
978      if ((this.PropertyChanged != null))
979      {
980        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
981      }
982    }
983  }
984 
985  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.ClientLog")]
986  public partial class ClientLog : INotifyPropertyChanging, INotifyPropertyChanged
987  {
988   
989    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
990   
991    private System.DateTime _Timestamp;
992   
993    private System.Guid _ResourceId;
994   
995    private string _Message;
996   
997    private EntityRef<Resource> _Resource;
998   
999    #region Extensibility Method Definitions
1000    partial void OnLoaded();
1001    partial void OnValidate(System.Data.Linq.ChangeAction action);
1002    partial void OnCreated();
1003    partial void OnTimestampChanging(System.DateTime value);
1004    partial void OnTimestampChanged();
1005    partial void OnResourceIdChanging(System.Guid value);
1006    partial void OnResourceIdChanged();
1007    partial void OnMessageChanging(string value);
1008    partial void OnMessageChanged();
1009    #endregion
1010   
1011    public ClientLog()
1012    {
1013      this._Resource = default(EntityRef<Resource>);
1014      OnCreated();
1015    }
1016   
1017    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Timestamp", DbType="DateTime NOT NULL", IsPrimaryKey=true)]
1018    public System.DateTime Timestamp
1019    {
1020      get
1021      {
1022        return this._Timestamp;
1023      }
1024      set
1025      {
1026        if ((this._Timestamp != value))
1027        {
1028          this.OnTimestampChanging(value);
1029          this.SendPropertyChanging();
1030          this._Timestamp = value;
1031          this.SendPropertyChanged("Timestamp");
1032          this.OnTimestampChanged();
1033        }
1034      }
1035    }
1036   
1037    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
1038    public System.Guid ResourceId
1039    {
1040      get
1041      {
1042        return this._ResourceId;
1043      }
1044      set
1045      {
1046        if ((this._ResourceId != value))
1047        {
1048          if (this._Resource.HasLoadedOrAssignedValue)
1049          {
1050            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
1051          }
1052          this.OnResourceIdChanging(value);
1053          this.SendPropertyChanging();
1054          this._ResourceId = value;
1055          this.SendPropertyChanged("ResourceId");
1056          this.OnResourceIdChanged();
1057        }
1058      }
1059    }
1060   
1061    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Message", DbType="NVarChar(MAX)")]
1062    public string Message
1063    {
1064      get
1065      {
1066        return this._Message;
1067      }
1068      set
1069      {
1070        if ((this._Message != value))
1071        {
1072          this.OnMessageChanging(value);
1073          this.SendPropertyChanging();
1074          this._Message = value;
1075          this.SendPropertyChanged("Message");
1076          this.OnMessageChanged();
1077        }
1078      }
1079    }
1080   
1081    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_ClientLog", Storage="_Resource", ThisKey="ResourceId", OtherKey="Id", IsForeignKey=true)]
1082    public Resource Resource
1083    {
1084      get
1085      {
1086        return this._Resource.Entity;
1087      }
1088      set
1089      {
1090        Resource previousValue = this._Resource.Entity;
1091        if (((previousValue != value)
1092              || (this._Resource.HasLoadedOrAssignedValue == false)))
1093        {
1094          this.SendPropertyChanging();
1095          if ((previousValue != null))
1096          {
1097            this._Resource.Entity = null;
1098            previousValue.ClientLogs.Remove(this);
1099          }
1100          this._Resource.Entity = value;
1101          if ((value != null))
1102          {
1103            value.ClientLogs.Add(this);
1104            this._ResourceId = value.Id;
1105          }
1106          else
1107          {
1108            this._ResourceId = default(System.Guid);
1109          }
1110          this.SendPropertyChanged("Resource");
1111        }
1112      }
1113    }
1114   
1115    public event PropertyChangingEventHandler PropertyChanging;
1116   
1117    public event PropertyChangedEventHandler PropertyChanged;
1118   
1119    protected virtual void SendPropertyChanging()
1120    {
1121      if ((this.PropertyChanging != null))
1122      {
1123        this.PropertyChanging(this, emptyChangingEventArgs);
1124      }
1125    }
1126   
1127    protected virtual void SendPropertyChanged(String propertyName)
1128    {
1129      if ((this.PropertyChanged != null))
1130      {
1131        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1132      }
1133    }
1134  }
1135 
1136  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.ClientError")]
1137  public partial class ClientError : INotifyPropertyChanging, INotifyPropertyChanged
1138  {
1139   
1140    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1141   
1142    private System.Guid _Id;
1143   
1144    private System.DateTime _Timestamp;
1145   
1146    private string _Exception;
1147   
1148    private string _UserComment;
1149   
1150    private string _ConfigDump;
1151   
1152    private System.Nullable<System.Guid> _ClientId;
1153   
1154    private System.Nullable<System.Guid> _UserId;
1155   
1156    #region Extensibility Method Definitions
1157    partial void OnLoaded();
1158    partial void OnValidate(System.Data.Linq.ChangeAction action);
1159    partial void OnCreated();
1160    partial void OnIdChanging(System.Guid value);
1161    partial void OnIdChanged();
1162    partial void OnTimestampChanging(System.DateTime value);
1163    partial void OnTimestampChanged();
1164    partial void OnExceptionChanging(string value);
1165    partial void OnExceptionChanged();
1166    partial void OnUserCommentChanging(string value);
1167    partial void OnUserCommentChanged();
1168    partial void OnConfigDumpChanging(string value);
1169    partial void OnConfigDumpChanged();
1170    partial void OnClientIdChanging(System.Nullable<System.Guid> value);
1171    partial void OnClientIdChanged();
1172    partial void OnUserIdChanging(System.Nullable<System.Guid> value);
1173    partial void OnUserIdChanged();
1174    #endregion
1175   
1176    public ClientError()
1177    {
1178      OnCreated();
1179    }
1180   
1181    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
1182    public System.Guid Id
1183    {
1184      get
1185      {
1186        return this._Id;
1187      }
1188      set
1189      {
1190        if ((this._Id != value))
1191        {
1192          this.OnIdChanging(value);
1193          this.SendPropertyChanging();
1194          this._Id = value;
1195          this.SendPropertyChanged("Id");
1196          this.OnIdChanged();
1197        }
1198      }
1199    }
1200   
1201    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Timestamp", DbType="DateTime NOT NULL")]
1202    public System.DateTime Timestamp
1203    {
1204      get
1205      {
1206        return this._Timestamp;
1207      }
1208      set
1209      {
1210        if ((this._Timestamp != value))
1211        {
1212          this.OnTimestampChanging(value);
1213          this.SendPropertyChanging();
1214          this._Timestamp = value;
1215          this.SendPropertyChanged("Timestamp");
1216          this.OnTimestampChanged();
1217        }
1218      }
1219    }
1220   
1221    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Exception", DbType="NVarChar(MAX)")]
1222    public string Exception
1223    {
1224      get
1225      {
1226        return this._Exception;
1227      }
1228      set
1229      {
1230        if ((this._Exception != value))
1231        {
1232          this.OnExceptionChanging(value);
1233          this.SendPropertyChanging();
1234          this._Exception = value;
1235          this.SendPropertyChanged("Exception");
1236          this.OnExceptionChanged();
1237        }
1238      }
1239    }
1240   
1241    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserComment", DbType="NVarChar(MAX)")]
1242    public string UserComment
1243    {
1244      get
1245      {
1246        return this._UserComment;
1247      }
1248      set
1249      {
1250        if ((this._UserComment != value))
1251        {
1252          this.OnUserCommentChanging(value);
1253          this.SendPropertyChanging();
1254          this._UserComment = value;
1255          this.SendPropertyChanged("UserComment");
1256          this.OnUserCommentChanged();
1257        }
1258      }
1259    }
1260   
1261    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ConfigDump", DbType="NVarChar(MAX)")]
1262    public string ConfigDump
1263    {
1264      get
1265      {
1266        return this._ConfigDump;
1267      }
1268      set
1269      {
1270        if ((this._ConfigDump != value))
1271        {
1272          this.OnConfigDumpChanging(value);
1273          this.SendPropertyChanging();
1274          this._ConfigDump = value;
1275          this.SendPropertyChanged("ConfigDump");
1276          this.OnConfigDumpChanged();
1277        }
1278      }
1279    }
1280   
1281    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ClientId", DbType="UniqueIdentifier")]
1282    public System.Nullable<System.Guid> ClientId
1283    {
1284      get
1285      {
1286        return this._ClientId;
1287      }
1288      set
1289      {
1290        if ((this._ClientId != value))
1291        {
1292          this.OnClientIdChanging(value);
1293          this.SendPropertyChanging();
1294          this._ClientId = value;
1295          this.SendPropertyChanged("ClientId");
1296          this.OnClientIdChanged();
1297        }
1298      }
1299    }
1300   
1301    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier")]
1302    public System.Nullable<System.Guid> UserId
1303    {
1304      get
1305      {
1306        return this._UserId;
1307      }
1308      set
1309      {
1310        if ((this._UserId != value))
1311        {
1312          this.OnUserIdChanging(value);
1313          this.SendPropertyChanging();
1314          this._UserId = value;
1315          this.SendPropertyChanged("UserId");
1316          this.OnUserIdChanged();
1317        }
1318      }
1319    }
1320   
1321    public event PropertyChangingEventHandler PropertyChanging;
1322   
1323    public event PropertyChangedEventHandler PropertyChanged;
1324   
1325    protected virtual void SendPropertyChanging()
1326    {
1327      if ((this.PropertyChanging != null))
1328      {
1329        this.PropertyChanging(this, emptyChangingEventArgs);
1330      }
1331    }
1332   
1333    protected virtual void SendPropertyChanged(String propertyName)
1334    {
1335      if ((this.PropertyChanged != null))
1336      {
1337        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1338      }
1339    }
1340  }
1341 
1342  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.UserGroup")]
1343  [global::System.Data.Linq.Mapping.InheritanceMappingAttribute(Code="UserGroupBase", Type=typeof(UserGroupBase), IsDefault=true)]
1344  [global::System.Data.Linq.Mapping.InheritanceMappingAttribute(Code="User", Type=typeof(User))]
1345  [global::System.Data.Linq.Mapping.InheritanceMappingAttribute(Code="UserGroup", Type=typeof(UserGroup))]
1346  public partial class UserGroupBase : INotifyPropertyChanging, INotifyPropertyChanged
1347  {
1348   
1349    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1350   
1351    private System.Guid _Id;
1352   
1353    private string _Type;
1354   
1355    private EntitySet<UserGroupUserGroup> _UserGroupUserGroups;
1356   
1357    private EntitySet<UserGroupUserGroup> _UserGroupUserGroups1;
1358   
1359    #region Extensibility Method Definitions
1360    partial void OnLoaded();
1361    partial void OnValidate(System.Data.Linq.ChangeAction action);
1362    partial void OnCreated();
1363    partial void OnIdChanging(System.Guid value);
1364    partial void OnIdChanged();
1365    partial void OnTypeChanging(string value);
1366    partial void OnTypeChanged();
1367    #endregion
1368   
1369    public UserGroupBase()
1370    {
1371      this._UserGroupUserGroups = new EntitySet<UserGroupUserGroup>(new Action<UserGroupUserGroup>(this.attach_UserGroupUserGroups), new Action<UserGroupUserGroup>(this.detach_UserGroupUserGroups));
1372      this._UserGroupUserGroups1 = new EntitySet<UserGroupUserGroup>(new Action<UserGroupUserGroup>(this.attach_UserGroupUserGroups1), new Action<UserGroupUserGroup>(this.detach_UserGroupUserGroups1));
1373      OnCreated();
1374    }
1375   
1376    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
1377    public System.Guid Id
1378    {
1379      get
1380      {
1381        return this._Id;
1382      }
1383      set
1384      {
1385        if ((this._Id != value))
1386        {
1387          this.OnIdChanging(value);
1388          this.SendPropertyChanging();
1389          this._Id = value;
1390          this.SendPropertyChanged("Id");
1391          this.OnIdChanged();
1392        }
1393      }
1394    }
1395   
1396    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Type", DbType="NVarChar(10) NOT NULL", CanBeNull=false, IsDiscriminator=true)]
1397    public string Type
1398    {
1399      get
1400      {
1401        return this._Type;
1402      }
1403      set
1404      {
1405        if ((this._Type != value))
1406        {
1407          this.OnTypeChanging(value);
1408          this.SendPropertyChanging();
1409          this._Type = value;
1410          this.SendPropertyChanged("Type");
1411          this.OnTypeChanged();
1412        }
1413      }
1414    }
1415   
1416    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="UserGroupBase_UserGroupUserGroup", Storage="_UserGroupUserGroups", ThisKey="Id", OtherKey="UserGroupId")]
1417    public EntitySet<UserGroupUserGroup> UserGroupUserGroupsChilds
1418    {
1419      get
1420      {
1421        return this._UserGroupUserGroups;
1422      }
1423      set
1424      {
1425        this._UserGroupUserGroups.Assign(value);
1426      }
1427    }
1428   
1429    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="UserGroupBase_UserGroupUserGroup1", Storage="_UserGroupUserGroups1", ThisKey="Id", OtherKey="UserGroupUserGroupId")]
1430    public EntitySet<UserGroupUserGroup> UserGroupUserGroupsParents
1431    {
1432      get
1433      {
1434        return this._UserGroupUserGroups1;
1435      }
1436      set
1437      {
1438        this._UserGroupUserGroups1.Assign(value);
1439      }
1440    }
1441   
1442    public event PropertyChangingEventHandler PropertyChanging;
1443   
1444    public event PropertyChangedEventHandler PropertyChanged;
1445   
1446    protected virtual void SendPropertyChanging()
1447    {
1448      if ((this.PropertyChanging != null))
1449      {
1450        this.PropertyChanging(this, emptyChangingEventArgs);
1451      }
1452    }
1453   
1454    protected virtual void SendPropertyChanged(String propertyName)
1455    {
1456      if ((this.PropertyChanged != null))
1457      {
1458        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1459      }
1460    }
1461   
1462    private void attach_UserGroupUserGroups(UserGroupUserGroup entity)
1463    {
1464      this.SendPropertyChanging();
1465      entity.UserGroup = this;
1466    }
1467   
1468    private void detach_UserGroupUserGroups(UserGroupUserGroup entity)
1469    {
1470      this.SendPropertyChanging();
1471      entity.UserGroup = null;
1472    }
1473   
1474    private void attach_UserGroupUserGroups1(UserGroupUserGroup entity)
1475    {
1476      this.SendPropertyChanging();
1477      entity.UserGroupBase = this;
1478    }
1479   
1480    private void detach_UserGroupUserGroups1(UserGroupUserGroup entity)
1481    {
1482      this.SendPropertyChanging();
1483      entity.UserGroupBase = null;
1484    }
1485  }
1486 
1487  public partial class User : UserGroupBase
1488  {
1489   
1490    private string _FullName;
1491   
1492    #region Extensibility Method Definitions
1493    partial void OnLoaded();
1494    partial void OnValidate(System.Data.Linq.ChangeAction action);
1495    partial void OnCreated();
1496    partial void OnFullNameChanging(string value);
1497    partial void OnFullNameChanged();
1498    #endregion
1499   
1500    public User()
1501    {
1502      OnCreated();
1503    }
1504   
1505    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_FullName", DbType="NVarChar(MAX)")]
1506    public string FullName
1507    {
1508      get
1509      {
1510        return this._FullName;
1511      }
1512      set
1513      {
1514        if ((this._FullName != value))
1515        {
1516          this.OnFullNameChanging(value);
1517          this.SendPropertyChanging();
1518          this._FullName = value;
1519          this.SendPropertyChanged("FullName");
1520          this.OnFullNameChanged();
1521        }
1522      }
1523    }
1524  }
1525 
1526  public partial class UserGroup : UserGroupBase
1527  {
1528   
1529    private string _Name;
1530   
1531    #region Extensibility Method Definitions
1532    partial void OnLoaded();
1533    partial void OnValidate(System.Data.Linq.ChangeAction action);
1534    partial void OnCreated();
1535    partial void OnNameChanging(string value);
1536    partial void OnNameChanged();
1537    #endregion
1538   
1539    public UserGroup()
1540    {
1541      OnCreated();
1542    }
1543   
1544    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(MAX)")]
1545    public string Name
1546    {
1547      get
1548      {
1549        return this._Name;
1550      }
1551      set
1552      {
1553        if ((this._Name != value))
1554        {
1555          this.OnNameChanging(value);
1556          this.SendPropertyChanging();
1557          this._Name = value;
1558          this.SendPropertyChanged("Name");
1559          this.OnNameChanged();
1560        }
1561      }
1562    }
1563  }
1564 
1565  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.ClientType")]
1566  public partial class ClientType : INotifyPropertyChanging, INotifyPropertyChanged
1567  {
1568   
1569    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1570   
1571    private System.Guid _Id;
1572   
1573    private string _Name;
1574   
1575    #region Extensibility Method Definitions
1576    partial void OnLoaded();
1577    partial void OnValidate(System.Data.Linq.ChangeAction action);
1578    partial void OnCreated();
1579    partial void OnIdChanging(System.Guid value);
1580    partial void OnIdChanged();
1581    partial void OnNameChanging(string value);
1582    partial void OnNameChanged();
1583    #endregion
1584   
1585    public ClientType()
1586    {
1587      OnCreated();
1588    }
1589   
1590    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
1591    public System.Guid Id
1592    {
1593      get
1594      {
1595        return this._Id;
1596      }
1597      set
1598      {
1599        if ((this._Id != value))
1600        {
1601          this.OnIdChanging(value);
1602          this.SendPropertyChanging();
1603          this._Id = value;
1604          this.SendPropertyChanged("Id");
1605          this.OnIdChanged();
1606        }
1607      }
1608    }
1609   
1610    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(MAX) NOT NULL", CanBeNull=false)]
1611    public string Name
1612    {
1613      get
1614      {
1615        return this._Name;
1616      }
1617      set
1618      {
1619        if ((this._Name != value))
1620        {
1621          this.OnNameChanging(value);
1622          this.SendPropertyChanging();
1623          this._Name = value;
1624          this.SendPropertyChanged("Name");
1625          this.OnNameChanged();
1626        }
1627      }
1628    }
1629   
1630    public event PropertyChangingEventHandler PropertyChanging;
1631   
1632    public event PropertyChangedEventHandler PropertyChanged;
1633   
1634    protected virtual void SendPropertyChanging()
1635    {
1636      if ((this.PropertyChanging != null))
1637      {
1638        this.PropertyChanging(this, emptyChangingEventArgs);
1639      }
1640    }
1641   
1642    protected virtual void SendPropertyChanged(String propertyName)
1643    {
1644      if ((this.PropertyChanged != null))
1645      {
1646        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1647      }
1648    }
1649  }
1650 
1651  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.OperatingSystem")]
1652  public partial class OperatingSystem : INotifyPropertyChanging, INotifyPropertyChanged
1653  {
1654   
1655    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1656   
1657    private System.Guid _Id;
1658   
1659    private string _Name;
1660   
1661    #region Extensibility Method Definitions
1662    partial void OnLoaded();
1663    partial void OnValidate(System.Data.Linq.ChangeAction action);
1664    partial void OnCreated();
1665    partial void OnIdChanging(System.Guid value);
1666    partial void OnIdChanged();
1667    partial void OnNameChanging(string value);
1668    partial void OnNameChanged();
1669    #endregion
1670   
1671    public OperatingSystem()
1672    {
1673      OnCreated();
1674    }
1675   
1676    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
1677    public System.Guid Id
1678    {
1679      get
1680      {
1681        return this._Id;
1682      }
1683      set
1684      {
1685        if ((this._Id != value))
1686        {
1687          this.OnIdChanging(value);
1688          this.SendPropertyChanging();
1689          this._Id = value;
1690          this.SendPropertyChanged("Id");
1691          this.OnIdChanged();
1692        }
1693      }
1694    }
1695   
1696    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(MAX) NOT NULL", CanBeNull=false)]
1697    public string Name
1698    {
1699      get
1700      {
1701        return this._Name;
1702      }
1703      set
1704      {
1705        if ((this._Name != value))
1706        {
1707          this.OnNameChanging(value);
1708          this.SendPropertyChanging();
1709          this._Name = value;
1710          this.SendPropertyChanged("Name");
1711          this.OnNameChanged();
1712        }
1713      }
1714    }
1715   
1716    public event PropertyChangingEventHandler PropertyChanging;
1717   
1718    public event PropertyChangedEventHandler PropertyChanged;
1719   
1720    protected virtual void SendPropertyChanging()
1721    {
1722      if ((this.PropertyChanging != null))
1723      {
1724        this.PropertyChanging(this, emptyChangingEventArgs);
1725      }
1726    }
1727   
1728    protected virtual void SendPropertyChanged(String propertyName)
1729    {
1730      if ((this.PropertyChanged != null))
1731      {
1732        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1733      }
1734    }
1735  }
1736 
1737  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Country")]
1738  public partial class Country : INotifyPropertyChanging, INotifyPropertyChanged
1739  {
1740   
1741    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1742   
1743    private System.Guid _Id;
1744   
1745    private string _Name;
1746   
1747    #region Extensibility Method Definitions
1748    partial void OnLoaded();
1749    partial void OnValidate(System.Data.Linq.ChangeAction action);
1750    partial void OnCreated();
1751    partial void OnIdChanging(System.Guid value);
1752    partial void OnIdChanged();
1753    partial void OnNameChanging(string value);
1754    partial void OnNameChanged();
1755    #endregion
1756   
1757    public Country()
1758    {
1759      OnCreated();
1760    }
1761   
1762    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
1763    public System.Guid Id
1764    {
1765      get
1766      {
1767        return this._Id;
1768      }
1769      set
1770      {
1771        if ((this._Id != value))
1772        {
1773          this.OnIdChanging(value);
1774          this.SendPropertyChanging();
1775          this._Id = value;
1776          this.SendPropertyChanged("Id");
1777          this.OnIdChanged();
1778        }
1779      }
1780    }
1781   
1782    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(MAX) NOT NULL", CanBeNull=false)]
1783    public string Name
1784    {
1785      get
1786      {
1787        return this._Name;
1788      }
1789      set
1790      {
1791        if ((this._Name != value))
1792        {
1793          this.OnNameChanging(value);
1794          this.SendPropertyChanging();
1795          this._Name = value;
1796          this.SendPropertyChanged("Name");
1797          this.OnNameChanged();
1798        }
1799      }
1800    }
1801   
1802    public event PropertyChangingEventHandler PropertyChanging;
1803   
1804    public event PropertyChangedEventHandler PropertyChanged;
1805   
1806    protected virtual void SendPropertyChanging()
1807    {
1808      if ((this.PropertyChanging != null))
1809      {
1810        this.PropertyChanging(this, emptyChangingEventArgs);
1811      }
1812    }
1813   
1814    protected virtual void SendPropertyChanged(String propertyName)
1815    {
1816      if ((this.PropertyChanged != null))
1817      {
1818        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1819      }
1820    }
1821  }
1822 
1823  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.ClientConfiguration")]
1824  public partial class ClientConfiguration : INotifyPropertyChanging, INotifyPropertyChanged
1825  {
1826   
1827    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1828   
1829    private System.Guid _Id;
1830   
1831    private string _Hash;
1832   
1833    private string _Description;
1834   
1835    #region Extensibility Method Definitions
1836    partial void OnLoaded();
1837    partial void OnValidate(System.Data.Linq.ChangeAction action);
1838    partial void OnCreated();
1839    partial void OnIdChanging(System.Guid value);
1840    partial void OnIdChanged();
1841    partial void OnHashChanging(string value);
1842    partial void OnHashChanged();
1843    partial void OnDescriptionChanging(string value);
1844    partial void OnDescriptionChanged();
1845    #endregion
1846   
1847    public ClientConfiguration()
1848    {
1849      OnCreated();
1850    }
1851   
1852    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
1853    public System.Guid Id
1854    {
1855      get
1856      {
1857        return this._Id;
1858      }
1859      set
1860      {
1861        if ((this._Id != value))
1862        {
1863          this.OnIdChanging(value);
1864          this.SendPropertyChanging();
1865          this._Id = value;
1866          this.SendPropertyChanged("Id");
1867          this.OnIdChanged();
1868        }
1869      }
1870    }
1871   
1872    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Hash", DbType="NVarChar(MAX) NOT NULL", CanBeNull=false)]
1873    public string Hash
1874    {
1875      get
1876      {
1877        return this._Hash;
1878      }
1879      set
1880      {
1881        if ((this._Hash != value))
1882        {
1883          this.OnHashChanging(value);
1884          this.SendPropertyChanging();
1885          this._Hash = value;
1886          this.SendPropertyChanged("Hash");
1887          this.OnHashChanged();
1888        }
1889      }
1890    }
1891   
1892    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Description", DbType="NVarChar(MAX)")]
1893    public string Description
1894    {
1895      get
1896      {
1897        return this._Description;
1898      }
1899      set
1900      {
1901        if ((this._Description != value))
1902        {
1903          this.OnDescriptionChanging(value);
1904          this.SendPropertyChanging();
1905          this._Description = value;
1906          this.SendPropertyChanged("Description");
1907          this.OnDescriptionChanged();
1908        }
1909      }
1910    }
1911   
1912    public event PropertyChangingEventHandler PropertyChanging;
1913   
1914    public event PropertyChangedEventHandler PropertyChanged;
1915   
1916    protected virtual void SendPropertyChanging()
1917    {
1918      if ((this.PropertyChanging != null))
1919      {
1920        this.PropertyChanging(this, emptyChangingEventArgs);
1921      }
1922    }
1923   
1924    protected virtual void SendPropertyChanged(String propertyName)
1925    {
1926      if ((this.PropertyChanged != null))
1927      {
1928        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1929      }
1930    }
1931  }
1932 
1933  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Plugin")]
1934  public partial class Plugin : INotifyPropertyChanging, INotifyPropertyChanged
1935  {
1936   
1937    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1938   
1939    private System.Guid _Id;
1940   
1941    private string _Name;
1942   
1943    private string _StrongName;
1944   
1945    private string _Version;
1946   
1947    private EntitySet<ResourcePlugin> _ResourcePlugins;
1948   
1949    #region Extensibility Method Definitions
1950    partial void OnLoaded();
1951    partial void OnValidate(System.Data.Linq.ChangeAction action);
1952    partial void OnCreated();
1953    partial void OnIdChanging(System.Guid value);
1954    partial void OnIdChanged();
1955    partial void OnNameChanging(string value);
1956    partial void OnNameChanged();
1957    partial void OnStrongNameChanging(string value);
1958    partial void OnStrongNameChanged();
1959    partial void OnVersionChanging(string value);
1960    partial void OnVersionChanged();
1961    #endregion
1962   
1963    public Plugin()
1964    {
1965      this._ResourcePlugins = new EntitySet<ResourcePlugin>(new Action<ResourcePlugin>(this.attach_ResourcePlugins), new Action<ResourcePlugin>(this.detach_ResourcePlugins));
1966      OnCreated();
1967    }
1968   
1969    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
1970    public System.Guid Id
1971    {
1972      get
1973      {
1974        return this._Id;
1975      }
1976      set
1977      {
1978        if ((this._Id != value))
1979        {
1980          this.OnIdChanging(value);
1981          this.SendPropertyChanging();
1982          this._Id = value;
1983          this.SendPropertyChanged("Id");
1984          this.OnIdChanged();
1985        }
1986      }
1987    }
1988   
1989    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(MAX) NOT NULL", CanBeNull=false)]
1990    public string Name
1991    {
1992      get
1993      {
1994        return this._Name;
1995      }
1996      set
1997      {
1998        if ((this._Name != value))
1999        {
2000          this.OnNameChanging(value);
2001          this.SendPropertyChanging();
2002          this._Name = value;
2003          this.SendPropertyChanged("Name");
2004          this.OnNameChanged();
2005        }
2006      }
2007    }
2008   
2009    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StrongName", DbType="NVarChar(MAX)")]
2010    public string StrongName
2011    {
2012      get
2013      {
2014        return this._StrongName;
2015      }
2016      set
2017      {
2018        if ((this._StrongName != value))
2019        {
2020          this.OnStrongNameChanging(value);
2021          this.SendPropertyChanging();
2022          this._StrongName = value;
2023          this.SendPropertyChanged("StrongName");
2024          this.OnStrongNameChanged();
2025        }
2026      }
2027    }
2028   
2029    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Version", DbType="NVarChar(20) NOT NULL", CanBeNull=false)]
2030    public string Version
2031    {
2032      get
2033      {
2034        return this._Version;
2035      }
2036      set
2037      {
2038        if ((this._Version != value))
2039        {
2040          this.OnVersionChanging(value);
2041          this.SendPropertyChanging();
2042          this._Version = value;
2043          this.SendPropertyChanged("Version");
2044          this.OnVersionChanged();
2045        }
2046      }
2047    }
2048   
2049    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Plugin_ResourcePlugin", Storage="_ResourcePlugins", ThisKey="Id", OtherKey="PluginId")]
2050    public EntitySet<ResourcePlugin> ResourcePlugins
2051    {
2052      get
2053      {
2054        return this._ResourcePlugins;
2055      }
2056      set
2057      {
2058        this._ResourcePlugins.Assign(value);
2059      }
2060    }
2061   
2062    public event PropertyChangingEventHandler PropertyChanging;
2063   
2064    public event PropertyChangedEventHandler PropertyChanged;
2065   
2066    protected virtual void SendPropertyChanging()
2067    {
2068      if ((this.PropertyChanging != null))
2069      {
2070        this.PropertyChanging(this, emptyChangingEventArgs);
2071      }
2072    }
2073   
2074    protected virtual void SendPropertyChanged(String propertyName)
2075    {
2076      if ((this.PropertyChanged != null))
2077      {
2078        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2079      }
2080    }
2081   
2082    private void attach_ResourcePlugins(ResourcePlugin entity)
2083    {
2084      this.SendPropertyChanging();
2085      entity.Plugin = this;
2086    }
2087   
2088    private void detach_ResourcePlugins(ResourcePlugin entity)
2089    {
2090      this.SendPropertyChanging();
2091      entity.Plugin = null;
2092    }
2093  }
2094 
2095  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.ResourcePlugin")]
2096  public partial class ResourcePlugin : INotifyPropertyChanging, INotifyPropertyChanged
2097  {
2098   
2099    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2100   
2101    private System.Guid _ResourceId;
2102   
2103    private System.Guid _PluginId;
2104   
2105    private EntityRef<Plugin> _Plugin;
2106   
2107    private EntityRef<Resource> _Resource;
2108   
2109    #region Extensibility Method Definitions
2110    partial void OnLoaded();
2111    partial void OnValidate(System.Data.Linq.ChangeAction action);
2112    partial void OnCreated();
2113    partial void OnResourceIdChanging(System.Guid value);
2114    partial void OnResourceIdChanged();
2115    partial void OnPluginIdChanging(System.Guid value);
2116    partial void OnPluginIdChanged();
2117    #endregion
2118   
2119    public ResourcePlugin()
2120    {
2121      this._Plugin = default(EntityRef<Plugin>);
2122      this._Resource = default(EntityRef<Resource>);
2123      OnCreated();
2124    }
2125   
2126    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
2127    public System.Guid ResourceId
2128    {
2129      get
2130      {
2131        return this._ResourceId;
2132      }
2133      set
2134      {
2135        if ((this._ResourceId != value))
2136        {
2137          if (this._Resource.HasLoadedOrAssignedValue)
2138          {
2139            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2140          }
2141          this.OnResourceIdChanging(value);
2142          this.SendPropertyChanging();
2143          this._ResourceId = value;
2144          this.SendPropertyChanged("ResourceId");
2145          this.OnResourceIdChanged();
2146        }
2147      }
2148    }
2149   
2150    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
2151    public System.Guid PluginId
2152    {
2153      get
2154      {
2155        return this._PluginId;
2156      }
2157      set
2158      {
2159        if ((this._PluginId != value))
2160        {
2161          if (this._Plugin.HasLoadedOrAssignedValue)
2162          {
2163            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2164          }
2165          this.OnPluginIdChanging(value);
2166          this.SendPropertyChanging();
2167          this._PluginId = value;
2168          this.SendPropertyChanged("PluginId");
2169          this.OnPluginIdChanged();
2170        }
2171      }
2172    }
2173   
2174    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Plugin_ResourcePlugin", Storage="_Plugin", ThisKey="PluginId", OtherKey="Id", IsForeignKey=true)]
2175    public Plugin Plugin
2176    {
2177      get
2178      {
2179        return this._Plugin.Entity;
2180      }
2181      set
2182      {
2183        Plugin previousValue = this._Plugin.Entity;
2184        if (((previousValue != value)
2185              || (this._Plugin.HasLoadedOrAssignedValue == false)))
2186        {
2187          this.SendPropertyChanging();
2188          if ((previousValue != null))
2189          {
2190            this._Plugin.Entity = null;
2191            previousValue.ResourcePlugins.Remove(this);
2192          }
2193          this._Plugin.Entity = value;
2194          if ((value != null))
2195          {
2196            value.ResourcePlugins.Add(this);
2197            this._PluginId = value.Id;
2198          }
2199          else
2200          {
2201            this._PluginId = default(System.Guid);
2202          }
2203          this.SendPropertyChanged("Plugin");
2204        }
2205      }
2206    }
2207   
2208    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_ResourcePlugin", Storage="_Resource", ThisKey="ResourceId", OtherKey="Id", IsForeignKey=true)]
2209    public Resource Resource
2210    {
2211      get
2212      {
2213        return this._Resource.Entity;
2214      }
2215      set
2216      {
2217        Resource previousValue = this._Resource.Entity;
2218        if (((previousValue != value)
2219              || (this._Resource.HasLoadedOrAssignedValue == false)))
2220        {
2221          this.SendPropertyChanging();
2222          if ((previousValue != null))
2223          {
2224            this._Resource.Entity = null;
2225            previousValue.ResourcePlugins.Remove(this);
2226          }
2227          this._Resource.Entity = value;
2228          if ((value != null))
2229          {
2230            value.ResourcePlugins.Add(this);
2231            this._ResourceId = value.Id;
2232          }
2233          else
2234          {
2235            this._ResourceId = default(System.Guid);
2236          }
2237          this.SendPropertyChanged("Resource");
2238        }
2239      }
2240    }
2241   
2242    public event PropertyChangingEventHandler PropertyChanging;
2243   
2244    public event PropertyChangedEventHandler PropertyChanged;
2245   
2246    protected virtual void SendPropertyChanging()
2247    {
2248      if ((this.PropertyChanging != null))
2249      {
2250        this.PropertyChanging(this, emptyChangingEventArgs);
2251      }
2252    }
2253   
2254    protected virtual void SendPropertyChanged(String propertyName)
2255    {
2256      if ((this.PropertyChanged != null))
2257      {
2258        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2259      }
2260    }
2261  }
2262 
2263  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.UserGroupUserGroup")]
2264  public partial class UserGroupUserGroup : INotifyPropertyChanging, INotifyPropertyChanged
2265  {
2266   
2267    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2268   
2269    private System.Guid _UserGroupId;
2270   
2271    private System.Guid _UserGroupUserGroupId;
2272   
2273    private EntityRef<UserGroupBase> _UserGroup;
2274   
2275    private EntityRef<UserGroupBase> _UserGroupBase;
2276   
2277    #region Extensibility Method Definitions
2278    partial void OnLoaded();
2279    partial void OnValidate(System.Data.Linq.ChangeAction action);
2280    partial void OnCreated();
2281    partial void OnUserGroupIdChanging(System.Guid value);
2282    partial void OnUserGroupIdChanged();
2283    partial void OnUserGroupUserGroupIdChanging(System.Guid value);
2284    partial void OnUserGroupUserGroupIdChanged();
2285    #endregion
2286   
2287    public UserGroupUserGroup()
2288    {
2289      this._UserGroup = default(EntityRef<UserGroupBase>);
2290      this._UserGroupBase = default(EntityRef<UserGroupBase>);
2291      OnCreated();
2292    }
2293   
2294    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserGroupId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
2295    public System.Guid UserGroupId
2296    {
2297      get
2298      {
2299        return this._UserGroupId;
2300      }
2301      set
2302      {
2303        if ((this._UserGroupId != value))
2304        {
2305          if (this._UserGroup.HasLoadedOrAssignedValue)
2306          {
2307            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2308          }
2309          this.OnUserGroupIdChanging(value);
2310          this.SendPropertyChanging();
2311          this._UserGroupId = value;
2312          this.SendPropertyChanged("UserGroupId");
2313          this.OnUserGroupIdChanged();
2314        }
2315      }
2316    }
2317   
2318    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserGroupUserGroupId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
2319    public System.Guid UserGroupUserGroupId
2320    {
2321      get
2322      {
2323        return this._UserGroupUserGroupId;
2324      }
2325      set
2326      {
2327        if ((this._UserGroupUserGroupId != value))
2328        {
2329          if (this._UserGroupBase.HasLoadedOrAssignedValue)
2330          {
2331            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2332          }
2333          this.OnUserGroupUserGroupIdChanging(value);
2334          this.SendPropertyChanging();
2335          this._UserGroupUserGroupId = value;
2336          this.SendPropertyChanged("UserGroupUserGroupId");
2337          this.OnUserGroupUserGroupIdChanged();
2338        }
2339      }
2340    }
2341   
2342    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="UserGroupBase_UserGroupUserGroup", Storage="_UserGroup", ThisKey="UserGroupId", OtherKey="Id", IsForeignKey=true)]
2343    public UserGroupBase UserGroup
2344    {
2345      get
2346      {
2347        return this._UserGroup.Entity;
2348      }
2349      set
2350      {
2351        UserGroupBase previousValue = this._UserGroup.Entity;
2352        if (((previousValue != value)
2353              || (this._UserGroup.HasLoadedOrAssignedValue == false)))
2354        {
2355          this.SendPropertyChanging();
2356          if ((previousValue != null))
2357          {
2358            this._UserGroup.Entity = null;
2359            previousValue.UserGroupUserGroupsChilds.Remove(this);
2360          }
2361          this._UserGroup.Entity = value;
2362          if ((value != null))
2363          {
2364            value.UserGroupUserGroupsChilds.Add(this);
2365            this._UserGroupId = value.Id;
2366          }
2367          else
2368          {
2369            this._UserGroupId = default(System.Guid);
2370          }
2371          this.SendPropertyChanged("UserGroup");
2372        }
2373      }
2374    }
2375   
2376    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="UserGroupBase_UserGroupUserGroup1", Storage="_UserGroupBase", ThisKey="UserGroupUserGroupId", OtherKey="Id", IsForeignKey=true)]
2377    public UserGroupBase UserGroupBase
2378    {
2379      get
2380      {
2381        return this._UserGroupBase.Entity;
2382      }
2383      set
2384      {
2385        UserGroupBase previousValue = this._UserGroupBase.Entity;
2386        if (((previousValue != value)
2387              || (this._UserGroupBase.HasLoadedOrAssignedValue == false)))
2388        {
2389          this.SendPropertyChanging();
2390          if ((previousValue != null))
2391          {
2392            this._UserGroupBase.Entity = null;
2393            previousValue.UserGroupUserGroupsParents.Remove(this);
2394          }
2395          this._UserGroupBase.Entity = value;
2396          if ((value != null))
2397          {
2398            value.UserGroupUserGroupsParents.Add(this);
2399            this._UserGroupUserGroupId = value.Id;
2400          }
2401          else
2402          {
2403            this._UserGroupUserGroupId = default(System.Guid);
2404          }
2405          this.SendPropertyChanged("UserGroupBase");
2406        }
2407      }
2408    }
2409   
2410    public event PropertyChangingEventHandler PropertyChanging;
2411   
2412    public event PropertyChangedEventHandler PropertyChanged;
2413   
2414    protected virtual void SendPropertyChanging()
2415    {
2416      if ((this.PropertyChanging != null))
2417      {
2418        this.PropertyChanging(this, emptyChangingEventArgs);
2419      }
2420    }
2421   
2422    protected virtual void SendPropertyChanged(String propertyName)
2423    {
2424      if ((this.PropertyChanged != null))
2425      {
2426        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2427      }
2428    }
2429  }
2430}
2431#pragma warning restore 1591
Note: See TracBrowser for help on using the repository browser.