Free cookie consent management tool by TermsFeed Policy Generator

source: branches/HiveStatistics/sources/HeuristicLab.Services.Access.DataAccess/3.3/AccessService.designer.cs @ 12765

Last change on this file since 12765 was 12765, checked in by dglaser, 9 years ago

#2388:

HeuristicLab.Services.WebApp-3.3:

  • Fixed a bug which caused the PluginManager to not reload an existing plugin
  • Changed Path.PathSeparator to Path.DirectorySeparatorChar

HeuristicLab.Services.Hive-3.3:

  • HiveStatisticsGenerator.cs: When moving a client to another group is now recognized properly
  • Fixed the 'unknown user' problem

Installers/HiveJanitorServiceInstaller.nsi:

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