Free cookie consent management tool by TermsFeed Policy Generator

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

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

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