Free cookie consent management tool by TermsFeed Policy Generator

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

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

#1648 worked on webservice

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