Changeset 12765


Ignore:
Timestamp:
07/16/15 11:50:41 (6 years ago)
Author:
dglaser
Message:

#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
Location:
branches/HiveStatistics/sources
Files:
1 deleted
8 edited

Legend:

Unmodified
Added
Removed
  • branches/HiveStatistics/sources/HeuristicLab.Services.Access.DataAccess/3.3/AccessService.designer.cs

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

    r11651 r12765  
    124124  </ItemGroup>
    125125  <ItemGroup>
     126    <ProjectReference Include="..\..\HeuristicLab.Services.Access.DataAccess\3.3\HeuristicLab.Services.Access.DataAccess-3.3.csproj">
     127      <Project>{0f652437-998a-4eab-8bf1-444b5fe8ce97}</Project>
     128      <Name>HeuristicLab.Services.Access.DataAccess-3.3</Name>
     129    </ProjectReference>
     130    <ProjectReference Include="..\..\HeuristicLab.Services.Access\3.3\HeuristicLab.Services.Access-3.3.csproj">
     131      <Project>{9fac0b23-2730-452a-9ba0-d7ca1746c541}</Project>
     132      <Name>HeuristicLab.Services.Access-3.3</Name>
     133    </ProjectReference>
    126134    <ProjectReference Include="..\..\HeuristicLab.Services.Hive.DataAccess\3.3\HeuristicLab.Services.Hive.DataAccess-3.3.csproj">
    127135      <Project>{EC2C8109-6E1E-4C88-9A2B-908CFF2EF4AC}</Project>
  • branches/HiveStatistics/sources/HeuristicLab.Services.Hive/3.3/HeuristicLab.Services.Hive-3.3.csproj

    r12691 r12765  
    189189  </ItemGroup>
    190190  <ItemGroup>
     191    <ProjectReference Include="..\..\HeuristicLab.Services.Access.DataAccess\3.3\HeuristicLab.Services.Access.DataAccess-3.3.csproj">
     192      <Project>{0F652437-998A-4EAB-8BF1-444B5FE8CE97}</Project>
     193      <Name>HeuristicLab.Services.Access.DataAccess-3.3</Name>
     194    </ProjectReference>
    191195    <ProjectReference Include="..\..\HeuristicLab.Services.Access\3.3\HeuristicLab.Services.Access-3.3.csproj">
    192196      <Project>{9FAC0B23-2730-452A-9BA0-D7CA1746C541}</Project>
  • branches/HiveStatistics/sources/HeuristicLab.Services.Hive/3.3/HiveStatisticsGenerator.cs

    r12551 r12765  
    2424using System.Data.Linq;
    2525using System.Linq;
     26using HeuristicLab.Services.Access.DataAccess;
    2627using HeuristicLab.Services.Hive.DataAccess;
    2728using HeuristicLab.Services.Hive.DataAccess.Manager;
     
    150151        }
    151152        if (totalTasks == completedTasks) {
    152           dimJob.DateCompleted = factTaskDao.GetLastCompletedTaskFromJob(dimJob.JobId);
     153          dimJob.DateCompleted = factTaskDao.GetLastCompletedTaskFromJob(dimJob.JobId) ?? DateTime.Now;
    153154        }
    154155        dimJob.TotalTasks = totalTasks;
     
    171172        join client in recentlyAddedClients on slave.ResourceId equals client.ResourceId
    172173        where (slave.Name != client.Name
     174               || slave.ParentResourceId == null && client.ResourceGroupId != null // because both can be null and null comparison
     175               || slave.ParentResourceId != null && client.ResourceGroupId == null // does return no entry on the sql server
    173176               || slave.ParentResourceId != client.ResourceGroupId
    174                || slave.ParentResource.ParentResourceId != client.ResourceGroup2Id)
     177               || ((slave.ParentResource != null) && slave.ParentResource.ParentResourceId != client.ResourceGroup2Id))
    175178        select new {
    176179          SlaveId = slave.ResourceId,
     
    186189          x.Name,
    187190          ResourceGroupId = x.ParentResourceId,
    188           GroupName = x.ParentResource.Name,
    189           ResourceGroup2Id = x.ParentResource.ParentResourceId,
    190           GroupName2 = x.ParentResource.ParentResource.Name
     191          GroupName = x.ParentResource != null ? x.ParentResource.Name : null,
     192          ResourceGroup2Id = x.ParentResource != null ? x.ParentResource.ParentResourceId : null,
     193          GroupName2 = x.ParentResource != null ? x.ParentResource.ParentResource != null ? x.ParentResource.ParentResource.Name : null : null
    191194        })
    192195        .ToList();
     
    311314    private string GetUserName(Guid userId) {
    312315      try {
    313         var userManager = ServiceLocator.Instance.UserManager;
    314         var user = userManager.GetUserById(userId);
    315         return user != null ? user.UserName : UnknownUserName;
     316        // we cannot use the ServiceLocator.Instance.UserManager since the janitor service
     317        // is not hosted in the iis the MemberShip.GetUser method causes exceptions
     318        // needs to be further investigated current workaround: use the authenticationcontext
     319        // we could also connect to the access service to get the user name
     320        using (ASPNETAuthenticationDataContext dc = new ASPNETAuthenticationDataContext()) {
     321          var user = dc.aspnet_Users.SingleOrDefault(x => x.UserId == userId);
     322          return user != null ? user.UserName : UnknownUserName;
     323        }
    316324      }
    317325      catch (Exception) {
  • branches/HiveStatistics/sources/HeuristicLab.Services.WebApp/3.3/Plugin.cs

    r12525 r12765  
    7777        if (!assemblies.Any())
    7878          return;
     79
    7980        var assemblyPath = assemblies.First();
    8081        AssemblyName = Path.GetFileName(assemblyPath);
  • branches/HiveStatistics/sources/HeuristicLab.Services.WebApp/3.3/PluginManager.cs

    r12515 r12765  
    6060    private void OnFilesChanged(object sender, FileSystemEventArgs args) {
    6161      string path = args.FullPath.Remove(0, PluginsDirectory.Length + 1);
    62       var pathParts = path.Split(Path.PathSeparator);
     62      var pathParts = path.Split(Path.DirectorySeparatorChar);
    6363      string pluginName = pathParts[0];
    64       if (pathParts.Length == 1) {
     64      if (pathParts.Length <= 2) {
    6565        switch (args.ChangeType) {
    6666          case WatcherChangeTypes.Created:
     
    7575            RenamedEventArgs renamedArgs = (RenamedEventArgs)args;
    7676            string oldPath = renamedArgs.OldFullPath.Remove(0, PluginsDirectory.Length + 1);
    77             var oldPathParts = oldPath.Split(Path.PathSeparator);
     77            var oldPathParts = oldPath.Split(Path.DirectorySeparatorChar);
    7878            string oldPluginName = oldPathParts[0];
    7979            plugins.Remove(oldPluginName);
  • branches/HiveStatistics/sources/HeuristicLab.Services.WebApp/3.3/WebApp/app.css

    r12761 r12765  
    414414.default-view-container {
    415415  padding: 30px;
     416  min-height: 300px;
    416417}
    417418
  • branches/HiveStatistics/sources/Installers/HiveJanitorServiceInstaller.nsi

    r12551 r12765  
    5151  File "${JANITORBUILDPATH}\HeuristicLab.PluginInfrastructure-3.3.dll"
    5252  File "${JANITORBUILDPATH}\HeuristicLab.Services.Access.dll"
     53  File "${JANITORBUILDPATH}\HeuristicLab.Services.Access.DataAccess.dll"
    5354  File "${JANITORBUILDPATH}\HeuristicLab.Services.Hive.DataAccess-3.3.dll"
    5455  File "${JANITORBUILDPATH}\HeuristicLab.Services.Hive.JanitorService-3.3.exe"
Note: See TracChangeset for help on using the changeset viewer.