Free cookie consent management tool by TermsFeed Policy Generator

Changeset 6840


Ignore:
Timestamp:
09/27/11 17:13:54 (13 years ago)
Author:
ascheibe
Message:

#1648 started implementing the web service

Location:
branches/ClientUserManagement
Files:
8 added
12 edited

Legend:

Unmodified
Added
Removed

  • branches/ClientUserManagement

    • Property svn:ignore

      •  

        old new  
        22*.testsettings
        33HeuristicLab.Services.Access.vsmdi
         4TestResults

  • branches/ClientUserManagement/HeuristicLab.Services.Access.DataAccess/3.3/ClientManagement.dbml

    r6825 r6840  
    1313      <Association Name="Resource_ResourcePlugin" Member="ResourcePlugins" ThisKey="Id" OtherKey="ResourceId" Type="ResourcePlugin" />
    1414      <Type Name="Client" InheritanceCode="Client" IsInheritanceDefault="true">
    15         <Column Name="ClientConfiguration" Member="ClientConfigurationId" Storage="_ClientConfiguration" Type="System.Guid" DbType="UniqueIdentifier" CanBeNull="false" />
    16         <Column Name="ClientType" Member="ClientTypeId" Storage="_ClientType" Type="System.Guid" DbType="UniqueIdentifier" CanBeNull="false" />
    1715        <Column Name="HeuristicLabVersion" Type="System.String" DbType="NVarChar(MAX)" CanBeNull="false" />
    18         <Column Name="Country" Member="CountryId" Storage="_Country" Type="System.Guid" DbType="UniqueIdentifier" CanBeNull="false" />
    19         <Column Name="OperatingSystem" Member="OperatingSystemId" Storage="_OperatingSystem" Type="System.Guid" DbType="UniqueIdentifier" CanBeNull="false" />
    2016        <Column Name="MemorySize" Type="System.Int32" DbType="Int" CanBeNull="true" />
    2117        <Column Name="Timestamp" Type="System.DateTime" DbType="DateTime" CanBeNull="true" />
    2218        <Column Name="NumberOfCores" Type="System.Int32" DbType="Int" CanBeNull="true" />
    2319        <Column Name="ProcessorType" Type="System.String" DbType="NVarChar(MAX)" CanBeNull="true" />
    24         <Association Name="Client_ClientType" Member="ClientType" Storage="_ClientTypes" ThisKey="ClientTypeId" OtherKey="Id" Type="ClientType" Cardinality="One" />
    25         <Association Name="Client_OperatingSystem" Member="OperatingSystem" Storage="_OperatingSystems" ThisKey="OperatingSystemId" OtherKey="Id" Type="OperatingSystem" Cardinality="One" />
    26         <Association Name="Client_Country" Member="Country" Storage="_Countries" ThisKey="CountryId" OtherKey="Id" Type="Country" Cardinality="One" />
    27         <Association Name="Client_ClientConfiguration" Member="ClientConfiguration" ThisKey="ClientConfigurationId" OtherKey="Id" Type="ClientConfiguration" Cardinality="One" />
     20        <Column Name="ClientTypeId" Type="System.Guid" DbType="UniqueIdentifier" CanBeNull="false" />
     21        <Column Name="OperatingSystemId" Type="System.Guid" DbType="UniqueIdentifier" CanBeNull="false" />
     22        <Column Name="ClientConfigurationId" Type="System.Guid" DbType="UniqueIdentifier" CanBeNull="false" />
     23        <Column Name="CountryId" Type="System.Guid" DbType="UniqueIdentifier" CanBeNull="false" />
     24        <Association Name="ClientType_Client" Member="ClientType" ThisKey="ClientTypeId" OtherKey="Id" Type="ClientType" IsForeignKey="true" />
     25        <Association Name="OperatingSystem_Client" Member="OperatingSystem" ThisKey="OperatingSystemId" OtherKey="Id" Type="OperatingSystem" IsForeignKey="true" />
     26        <Association Name="Country_Client" Member="Country" ThisKey="CountryId" OtherKey="Id" Type="Country" IsForeignKey="true" />
     27        <Association Name="ClientConfiguration_Client" Member="ClientConfiguration" ThisKey="ClientConfigurationId" OtherKey="Id" Type="ClientConfiguration" IsForeignKey="true" />
    2828      </Type>
    2929      <Type Name="ClientGroup" InheritanceCode="ClientGroup" />
    … …  
    7878      <Column Name="Id" AutoSync="Never" Type="System.Guid" DbType="UniqueIdentifier NOT NULL" IsPrimaryKey="true" IsDbGenerated="true" CanBeNull="false" />
    7979      <Column Name="Name" Type="System.String" DbType="NVarChar(MAX) NOT NULL" CanBeNull="false" />
    80       <Association Name="Client_ClientType" Member="Client" ThisKey="Id" OtherKey="ClientTypeId" Type="Client" IsForeignKey="true" />
    8180    </Type>
    8281  </Table>
    … …  
    8584      <Column Name="Id" AutoSync="Never" Type="System.Guid" DbType="UniqueIdentifier NOT NULL" IsPrimaryKey="true" IsDbGenerated="true" CanBeNull="false" />
    8685      <Column Name="Name" Type="System.String" DbType="NVarChar(MAX) NOT NULL" CanBeNull="false" />
    87       <Association Name="Client_OperatingSystem" Member="Client" ThisKey="Id" OtherKey="OperatingSystemId" Type="Client" IsForeignKey="true" />
    8886    </Type>
    8987  </Table>
    … …  
    9290      <Column Name="Id" AutoSync="Never" Type="System.Guid" DbType="UniqueIdentifier NOT NULL" IsPrimaryKey="true" IsDbGenerated="true" CanBeNull="false" />
    9391      <Column Name="Name" Type="System.String" DbType="NVarChar(MAX) NOT NULL" CanBeNull="false" />
    94       <Association Name="Client_Country" Member="Client" ThisKey="Id" OtherKey="CountryId" Type="Client" IsForeignKey="true" />
    9592    </Type>
    9693  </Table>
    … …  
    10097      <Column Name="Hash" Type="System.String" DbType="NVarChar(MAX) NOT NULL" CanBeNull="false" />
    10198      <Column Name="Description" Type="System.String" DbType="NVarChar(MAX)" CanBeNull="true" />
    102       <Association Name="Client_ClientConfiguration" Member="Client" ThisKey="Id" OtherKey="ClientConfigurationId" Type="Client" IsForeignKey="true" />
    10399    </Type>
    104100  </Table>

  • branches/ClientUserManagement/HeuristicLab.Services.Access.DataAccess/3.3/ClientManagement.dbml.layout

    r6825 r6840  
    5959      </nestedChildShapes>
    6060    </classShape>
    61     <associationConnector edgePoints="[(5.875 : 2.07859537760417); (5.875 : 2.34875); (8.125 : 2.34875)]" fixedFrom="NotFixed" fixedTo="NotFixed">
     61    <associationConnector edgePoints="[(5.875 : 2.07859537760417); (5.875 : 2.34875); (8.125 : 2.34875)]" fixedFrom="Algorithm" fixedTo="Algorithm">
    6262      <AssociationMoniker Name="/ClientManagementDataContext/Resource/Resource_ClientLog" />
    6363      <nodes>
    … …  
    115115      </nestedChildShapes>
    116116    </classShape>
    117     <associationConnector edgePoints="[(3.75 : 2.5); (3.375 : 2.125); (3.375 : 1.09699625651042); (2.5 : 1.09699625651042)]" fixedFrom="NotFixed" fixedTo="NotFixed">
    118       <AssociationMoniker Name="/ClientManagementDataContext/Client/Client_ClientType" />
    119       <nodes>
    120         <classShapeMoniker Id="c964402f-99b7-4355-b9ad-279a2a7cf692" />
    121         <classShapeMoniker Id="38891c77-8166-44c9-8dd5-da45900c45f3" />
    122       </nodes>
    123     </associationConnector>
    124     <associationConnector edgePoints="[(3.75 : 2.75324875651042); (2.5 : 2.75324875651042)]" fixedFrom="NotFixed" fixedTo="NotFixed">
    125       <AssociationMoniker Name="/ClientManagementDataContext/Client/Client_OperatingSystem" />
    126       <nodes>
    127         <classShapeMoniker Id="c964402f-99b7-4355-b9ad-279a2a7cf692" />
    128         <classShapeMoniker Id="cb6a29ca-7ef1-4721-9108-b64558f282a6" />
    129       </nodes>
    130     </associationConnector>
    131     <associationConnector edgePoints="[(3.75 : 3.59699625651042); (2.5 : 3.59699625651042)]" fixedFrom="NotFixed" fixedTo="NotFixed">
    132       <AssociationMoniker Name="/ClientManagementDataContext/Client/Client_Country" />
    133       <nodes>
    134         <classShapeMoniker Id="c964402f-99b7-4355-b9ad-279a2a7cf692" />
    135         <classShapeMoniker Id="c7dfcb39-11e2-47ec-8a48-4e41e2901893" />
    136       </nodes>
    137     </associationConnector>
    138117    <classShape Id="9f63fd2b-4410-4817-99d4-648466eacddd" absoluteBounds="3.625, 5.625, 2, 1.1939925130208333">
    139118      <DataClassMoniker Name="/ClientManagementDataContext/ResourcePlugin" />
    … …  
    149128      </nodes>
    150129    </associationConnector>
    151     <associationConnector edgePoints="[(5.90625 : 2.07859537760417); (5.90625 : 6.22199625651042); (5.625 : 6.22199625651042)]" fixedFrom="NotFixed" fixedTo="NotFixed">
     130    <associationConnector edgePoints="[(5.90625 : 2.07859537760417); (5.90625 : 6.22199625651042); (5.625 : 6.22199625651042)]" fixedFrom="Algorithm" fixedTo="Algorithm">
    152131      <AssociationMoniker Name="/ClientManagementDataContext/Resource/Resource_ResourcePlugin" />
    153132      <nodes>
    … …  
    207186      </nodes>
    208187    </associationConnector>
    209     <associationConnector edgePoints="[(3.75 : 4.64505126953125); (2.5 : 4.64505126953125)]" fixedFrom="NotFixed" fixedTo="NotFixed">
    210       <AssociationMoniker Name="/ClientManagementDataContext/Client/Client_ClientConfiguration" />
    211       <nodes>
    212         <classShapeMoniker Id="c964402f-99b7-4355-b9ad-279a2a7cf692" />
     188    <associationConnector edgePoints="[(2.5 : 1.09699625651042); (4.46848483471003 : 1.09699625651042); (4.46848483471003 : 2.5)]" fixedFrom="Algorithm" fixedTo="Caller">
     189      <AssociationMoniker Name="/ClientManagementDataContext/ClientType/ClientType_Client" />
     190      <nodes>
     191        <classShapeMoniker Id="38891c77-8166-44c9-8dd5-da45900c45f3" />
     192        <classShapeMoniker Id="c964402f-99b7-4355-b9ad-279a2a7cf692" />
     193      </nodes>
     194    </associationConnector>
     195    <associationConnector edgePoints="[(2.5 : 2.72199625651042); (3.75 : 2.72199625651042)]" fixedFrom="Algorithm" fixedTo="Algorithm">
     196      <AssociationMoniker Name="/ClientManagementDataContext/OperatingSystem/OperatingSystem_Client" />
     197      <nodes>
     198        <classShapeMoniker Id="cb6a29ca-7ef1-4721-9108-b64558f282a6" />
     199        <classShapeMoniker Id="c964402f-99b7-4355-b9ad-279a2a7cf692" />
     200      </nodes>
     201    </associationConnector>
     202    <associationConnector edgePoints="[(2.5 : 3.59699625651042); (3.75 : 3.59699625651042)]" fixedFrom="Algorithm" fixedTo="Algorithm">
     203      <AssociationMoniker Name="/ClientManagementDataContext/Country/Country_Client" />
     204      <nodes>
     205        <classShapeMoniker Id="c7dfcb39-11e2-47ec-8a48-4e41e2901893" />
     206        <classShapeMoniker Id="c964402f-99b7-4355-b9ad-279a2a7cf692" />
     207      </nodes>
     208    </associationConnector>
     209    <associationConnector edgePoints="[(2.5 : 4.64505126953125); (3.75 : 4.64505126953125)]" fixedFrom="Algorithm" fixedTo="Algorithm">
     210      <AssociationMoniker Name="/ClientManagementDataContext/ClientConfiguration/ClientConfiguration_Client" />
     211      <nodes>
    213212        <classShapeMoniker Id="3aef9298-1092-45fa-bf96-8dd25d61c2f8" />
     213        <classShapeMoniker Id="c964402f-99b7-4355-b9ad-279a2a7cf692" />
    214214      </nodes>
    215215    </associationConnector>

  • branches/ClientUserManagement/HeuristicLab.Services.Access.DataAccess/3.3/ClientManagement.designer.cs

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

  • branches/ClientUserManagement/HeuristicLab.Services.Access.DataAccess/3.3/SQL Scripts/Initialize ClientManagement.sql

    r6825 r6840  
    22GO
    33
    4 /****** Object:  Table [dbo].[Resource]    Script Date: 09/23/2011 17:55:12 ******/
    5 SET ANSI_NULLS ON
    6 GO
    7 
    8 SET QUOTED_IDENTIFIER ON
    9 GO
    10 
    11 CREATE TABLE [dbo].[Resource](
    12   [Id] [uniqueidentifier] NOT NULL,
    13   [Name] [nvarchar](max) NOT NULL,
     4/****** Object:  Table [dbo].[ClientConfiguration]    Script Date: 09/27/2011 17:05:22 ******/
     5SET ANSI_NULLS ON
     6GO
     7
     8SET QUOTED_IDENTIFIER ON
     9GO
     10
     11CREATE TABLE [dbo].[ClientConfiguration](
     12  [Id] [uniqueidentifier] NOT NULL,
     13  [Hash] [nvarchar](max) NOT NULL,
    1414  [Description] [nvarchar](max) NULL,
    15   [Type] [nvarchar](max) NOT NULL,
    16   [ProcessorType] [nvarchar](max) NULL,
    17   [NumberOfCores] [int] NULL,
    18   [MemorySize] [int] NULL,
    19   [OperatingSystem] [uniqueidentifier] NULL,
    20   [Country] [uniqueidentifier] NULL,
    21   [HeuristicLabVersion] [nvarchar](max) NULL,
    22   [ClientType] [uniqueidentifier] NULL,
    23   [ClientConfiguration] [uniqueidentifier] NULL,
    24   [Timestamp] [datetime] NULL,
    25  CONSTRAINT [PK_Resource] PRIMARY KEY CLUSTERED
    26 (
    27   [Id] ASC
    28 )WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
    29 ) ON [PRIMARY]
    30 
    31 GO
    32 
    33 ALTER TABLE [dbo].[Resource]  WITH CHECK ADD  CONSTRAINT [FK_Resource_ClientConfiguration] FOREIGN KEY([ClientConfiguration])
    34 REFERENCES [dbo].[ClientConfiguration] ([Id])
    35 GO
    36 
    37 ALTER TABLE [dbo].[Resource] CHECK CONSTRAINT [FK_Resource_ClientConfiguration]
    38 GO
    39 
    40 ALTER TABLE [dbo].[Resource]  WITH CHECK ADD  CONSTRAINT [FK_Resource_ClientType] FOREIGN KEY([ClientType])
    41 REFERENCES [dbo].[ClientType] ([Id])
    42 GO
    43 
    44 ALTER TABLE [dbo].[Resource] CHECK CONSTRAINT [FK_Resource_ClientType]
    45 GO
    46 
    47 ALTER TABLE [dbo].[Resource]  WITH CHECK ADD  CONSTRAINT [FK_Resource_Country] FOREIGN KEY([Country])
    48 REFERENCES [dbo].[Country] ([Id])
    49 GO
    50 
    51 ALTER TABLE [dbo].[Resource] CHECK CONSTRAINT [FK_Resource_Country]
    52 GO
    53 
    54 ALTER TABLE [dbo].[Resource]  WITH CHECK ADD  CONSTRAINT [FK_Resource_OperatingSystem] FOREIGN KEY([OperatingSystem])
    55 REFERENCES [dbo].[OperatingSystem] ([Id])
    56 GO
    57 
    58 ALTER TABLE [dbo].[Resource] CHECK CONSTRAINT [FK_Resource_OperatingSystem]
    59 GO
    60 
    61 ALTER TABLE [dbo].[Resource] ADD  CONSTRAINT [DF_Resource_Id]  DEFAULT (newsequentialid()) FOR [Id]
    62 GO
    63 
    64 
    65 /****** Object:  Table [dbo].[ResourceResourceGroup]    Script Date: 09/23/2011 13:34:10 ******/
    66 SET ANSI_NULLS ON
    67 GO
    68 
    69 SET QUOTED_IDENTIFIER ON
    70 GO
    71 
    72 CREATE TABLE [dbo].[ResourceResourceGroup](
    73   [ResourceId] [uniqueidentifier] NOT NULL,
    74   [ResourceGroupId] [uniqueidentifier] NOT NULL,
    75  CONSTRAINT [PK_ResourceResourceGroup_Id] PRIMARY KEY CLUSTERED
    76 (
    77   [ResourceId] ASC,
    78   [ResourceGroupId] ASC
    79 )WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
    80 ) ON [PRIMARY]
    81 
    82 GO
    83 
    84 ALTER TABLE [dbo].[ResourceResourceGroup]  WITH CHECK ADD  CONSTRAINT [FK_ResourceResourceGroup_ResourceGroupId] FOREIGN KEY([ResourceGroupId])
    85 REFERENCES [dbo].[Resource] ([Id])
    86 GO
    87 
    88 ALTER TABLE [dbo].[ResourceResourceGroup] CHECK CONSTRAINT [FK_ResourceResourceGroup_ResourceGroupId]
    89 GO
    90 
    91 ALTER TABLE [dbo].[ResourceResourceGroup]  WITH CHECK ADD  CONSTRAINT [FK_ResourceResourceGroup_ResourceId] FOREIGN KEY([ResourceId])
    92 REFERENCES [dbo].[Resource] ([Id])
    93 GO
    94 
    95 ALTER TABLE [dbo].[ResourceResourceGroup] CHECK CONSTRAINT [FK_ResourceResourceGroup_ResourceId]
    96 GO
    97 
    98 
    99 /****** Object:  Table [dbo].[Plugin]    Script Date: 09/23/2011 13:34:39 ******/
    100 SET ANSI_NULLS ON
    101 GO
    102 
    103 SET QUOTED_IDENTIFIER ON
    104 GO
    105 
    106 CREATE TABLE [dbo].[Plugin](
    107   [Id] [uniqueidentifier] NOT NULL,
    108   [Name] [nvarchar](max) NOT NULL,
    109   [StrongName] [nvarchar](max) NULL,
    110   [Version] [nvarchar](20) NOT NULL,
    111  CONSTRAINT [PK_Plugin] PRIMARY KEY CLUSTERED
    112 (
    113   [Id] ASC
    114 )WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
    115 ) ON [PRIMARY]
    116 
    117 GO
    118 
    119 /****** Object:  Table [dbo].[ResourcePlugin]    Script Date: 09/23/2011 13:34:53 ******/
    120 SET ANSI_NULLS ON
    121 GO
    122 
    123 SET QUOTED_IDENTIFIER ON
    124 GO
    125 
    126 CREATE TABLE [dbo].[ResourcePlugin](
    127   [ResourceId] [uniqueidentifier] NOT NULL,
    128   [PluginId] [uniqueidentifier] NOT NULL,
    129  CONSTRAINT [PK_ResourcePlugin] PRIMARY KEY CLUSTERED
    130 (
    131   [ResourceId] ASC,
    132   [PluginId] ASC
    133 )WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
    134 ) ON [PRIMARY]
    135 
    136 GO
    137 
    138 ALTER TABLE [dbo].[ResourcePlugin]  WITH CHECK ADD  CONSTRAINT [FK_ResourcePlugin_Plugin] FOREIGN KEY([PluginId])
    139 REFERENCES [dbo].[Plugin] ([Id])
    140 GO
    141 
    142 ALTER TABLE [dbo].[ResourcePlugin] CHECK CONSTRAINT [FK_ResourcePlugin_Plugin]
    143 GO
    144 
    145 ALTER TABLE [dbo].[ResourcePlugin]  WITH CHECK ADD  CONSTRAINT [FK_ResourcePlugin_Resource] FOREIGN KEY([ResourceId])
    146 REFERENCES [dbo].[Resource] ([Id])
    147 GO
    148 
    149 ALTER TABLE [dbo].[ResourcePlugin] CHECK CONSTRAINT [FK_ResourcePlugin_Resource]
    150 GO
    151 
    152 
    153 /****** Object:  Table [dbo].[UserGroup]    Script Date: 09/23/2011 13:35:16 ******/
    154 SET ANSI_NULLS ON
    155 GO
    156 
    157 SET QUOTED_IDENTIFIER ON
    158 GO
    159 
    160 CREATE TABLE [dbo].[UserGroup](
    161   [Id] [uniqueidentifier] NOT NULL,
    162   [FullName] [nvarchar](max) NULL,
    163   [Name] [nvarchar](max) NULL,
    164   [Type] [nvarchar](10) NOT NULL,
    165  CONSTRAINT [PK_UserGroup] PRIMARY KEY CLUSTERED
    166 (
    167   [Id] ASC
    168 )WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
    169 ) ON [PRIMARY]
    170 
    171 GO
    172 
    173 
    174 
    175 /****** Object:  Table [dbo].[UserGroupUserGroup]    Script Date: 09/23/2011 14:24:45 ******/
    176 SET ANSI_NULLS ON
    177 GO
    178 
    179 SET QUOTED_IDENTIFIER ON
    180 GO
    181 
    182 CREATE TABLE [dbo].[UserGroupUserGroup](
    183   [UserGroupId] [uniqueidentifier] NOT NULL,
    184   [UserGroupUserGroupId] [uniqueidentifier] NOT NULL,
    185  CONSTRAINT [PK_UserGroupUserGroup] PRIMARY KEY CLUSTERED
    186 (
    187   [UserGroupId] ASC,
    188   [UserGroupUserGroupId] ASC
    189 )WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
    190 ) ON [PRIMARY]
    191 
    192 GO
    193 
    194 ALTER TABLE [dbo].[UserGroupUserGroup]  WITH CHECK ADD  CONSTRAINT [FK_UserGroupUserGroup_UserGroup] FOREIGN KEY([UserGroupId])
    195 REFERENCES [dbo].[UserGroup] ([Id])
    196 GO
    197 
    198 ALTER TABLE [dbo].[UserGroupUserGroup] CHECK CONSTRAINT [FK_UserGroupUserGroup_UserGroup]
    199 GO
    200 
    201 ALTER TABLE [dbo].[UserGroupUserGroup]  WITH CHECK ADD  CONSTRAINT [FK_UserGroupUserGroup_UserGroup1] FOREIGN KEY([UserGroupUserGroupId])
    202 REFERENCES [dbo].[UserGroup] ([Id])
    203 GO
    204 
    205 ALTER TABLE [dbo].[UserGroupUserGroup] CHECK CONSTRAINT [FK_UserGroupUserGroup_UserGroup1]
    206 GO
    207 
    208 
    209 
    210 
    211 /****** Object:  Table [dbo].[OperatingSystem]    Script Date: 09/23/2011 13:36:01 ******/
    212 SET ANSI_NULLS ON
    213 GO
    214 
    215 SET QUOTED_IDENTIFIER ON
    216 GO
    217 
    218 CREATE TABLE [dbo].[OperatingSystem](
    219   [Id] [uniqueidentifier] NOT NULL,
    220   [Name] [nvarchar](max) NOT NULL,
    221  CONSTRAINT [PK_OperatingSystem] PRIMARY KEY CLUSTERED
    222 (
    223   [Id] ASC
    224 )WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
    225 ) ON [PRIMARY]
    226 
    227 GO
    228 
    229 
    230 
    231 /****** Object:  Table [dbo].[Country]    Script Date: 09/23/2011 13:36:11 ******/
    232 SET ANSI_NULLS ON
    233 GO
    234 
    235 SET QUOTED_IDENTIFIER ON
    236 GO
    237 
    238 CREATE TABLE [dbo].[Country](
    239   [Id] [uniqueidentifier] NOT NULL,
    240   [Name] [nvarchar](max) NOT NULL,
    241  CONSTRAINT [PK_Country] PRIMARY KEY CLUSTERED
    242 (
    243   [Id] ASC
    244 )WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
    245 ) ON [PRIMARY]
    246 
    247 GO
    248 
    249 
    250 /****** Object:  Table [dbo].[ClientType]    Script Date: 09/23/2011 13:36:24 ******/
    251 SET ANSI_NULLS ON
    252 GO
    253 
    254 SET QUOTED_IDENTIFIER ON
    255 GO
    256 
    257 CREATE TABLE [dbo].[ClientType](
    258   [Id] [uniqueidentifier] NOT NULL,
    259   [Name] [nvarchar](max) NOT NULL,
    260  CONSTRAINT [PK_ClientType] PRIMARY KEY CLUSTERED
    261 (
    262   [Id] ASC
    263 )WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
    264 ) ON [PRIMARY]
    265 
    266 GO
    267 
    268 /****** Object:  Table [dbo].[ClientLog]    Script Date: 09/23/2011 13:36:35 ******/
    269 SET ANSI_NULLS ON
    270 GO
    271 
    272 SET QUOTED_IDENTIFIER ON
    273 GO
    274 
    275 CREATE TABLE [dbo].[ClientLog](
    276   [Timestamp] [datetime] NOT NULL,
    277   [ResourceId] [uniqueidentifier] NOT NULL,
    278   [Message] [nvarchar](max) NULL,
    279  CONSTRAINT [PK_ClientLog] PRIMARY KEY CLUSTERED
    280 (
    281   [Timestamp] ASC,
    282   [ResourceId] ASC
    283 )WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
    284 ) ON [PRIMARY]
    285 
    286 GO
    287 
    288 ALTER TABLE [dbo].[ClientLog]  WITH CHECK ADD  CONSTRAINT [FK_ClientLog_Resource] FOREIGN KEY([ResourceId])
    289 REFERENCES [dbo].[Resource] ([Id])
    290 GO
    291 
    292 ALTER TABLE [dbo].[ClientLog] CHECK CONSTRAINT [FK_ClientLog_Resource]
    293 GO
    294 
    295 USE [HeuristicLab.ClientManagement]
    296 GO
    297 
    298 /****** Object:  Table [dbo].[ClientError]    Script Date: 09/23/2011 13:36:46 ******/
     15 CONSTRAINT [PK_ClientConfiguration] PRIMARY KEY CLUSTERED
     16(
     17  [Id] ASC
     18)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
     19) ON [PRIMARY]
     20
     21GO
     22
     23ALTER TABLE [dbo].[ClientConfiguration] ADD  CONSTRAINT [DF_ClientConfiguration_Id]  DEFAULT (newsequentialid()) FOR [Id]
     24GO
     25
     26USE [HeuristicLab.ClientManagement]
     27GO
     28
     29/****** Object:  Table [dbo].[ClientError]    Script Date: 09/27/2011 17:05:38 ******/
    29930SET ANSI_NULLS ON
    30031GO
    … …  
    33364GO
    33465
    335 /****** Object:  Table [dbo].[ClientConfiguration]    Script Date: 09/23/2011 13:36:55 ******/
    336 SET ANSI_NULLS ON
    337 GO
    338 
    339 SET QUOTED_IDENTIFIER ON
    340 GO
    341 
    342 CREATE TABLE [dbo].[ClientConfiguration](
    343   [Id] [uniqueidentifier] NOT NULL,
    344   [Hash] [nvarchar](max) NOT NULL,
     66ALTER TABLE [dbo].[ClientError] ADD  CONSTRAINT [DF_ClientError_Id]  DEFAULT (newsequentialid()) FOR [Id]
     67GO
     68
     69USE [HeuristicLab.ClientManagement]
     70GO
     71
     72/****** Object:  Table [dbo].[ClientLog]    Script Date: 09/27/2011 17:05:50 ******/
     73SET ANSI_NULLS ON
     74GO
     75
     76SET QUOTED_IDENTIFIER ON
     77GO
     78
     79CREATE TABLE [dbo].[ClientLog](
     80  [Timestamp] [datetime] NOT NULL,
     81  [ResourceId] [uniqueidentifier] NOT NULL,
     82  [Message] [nvarchar](max) NULL,
     83 CONSTRAINT [PK_ClientLog] PRIMARY KEY CLUSTERED
     84(
     85  [Timestamp] ASC,
     86  [ResourceId] ASC
     87)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
     88) ON [PRIMARY]
     89
     90GO
     91
     92ALTER TABLE [dbo].[ClientLog]  WITH CHECK ADD  CONSTRAINT [FK_ClientLog_Resource] FOREIGN KEY([ResourceId])
     93REFERENCES [dbo].[Resource] ([Id])
     94GO
     95
     96ALTER TABLE [dbo].[ClientLog] CHECK CONSTRAINT [FK_ClientLog_Resource]
     97GO
     98
     99
     100USE [HeuristicLab.ClientManagement]
     101GO
     102
     103/****** Object:  Table [dbo].[ClientType]    Script Date: 09/27/2011 17:06:09 ******/
     104SET ANSI_NULLS ON
     105GO
     106
     107SET QUOTED_IDENTIFIER ON
     108GO
     109
     110CREATE TABLE [dbo].[ClientType](
     111  [Id] [uniqueidentifier] NOT NULL,
     112  [Name] [nvarchar](max) NOT NULL,
     113 CONSTRAINT [PK_ClientType] PRIMARY KEY CLUSTERED
     114(
     115  [Id] ASC
     116)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
     117) ON [PRIMARY]
     118
     119GO
     120
     121ALTER TABLE [dbo].[ClientType] ADD  CONSTRAINT [DF_ClientType_Id]  DEFAULT (newsequentialid()) FOR [Id]
     122GO
     123
     124USE [HeuristicLab.ClientManagement]
     125GO
     126
     127/****** Object:  Table [dbo].[Country]    Script Date: 09/27/2011 17:06:21 ******/
     128SET ANSI_NULLS ON
     129GO
     130
     131SET QUOTED_IDENTIFIER ON
     132GO
     133
     134CREATE TABLE [dbo].[Country](
     135  [Id] [uniqueidentifier] NOT NULL,
     136  [Name] [nvarchar](max) NOT NULL,
     137 CONSTRAINT [PK_Country] PRIMARY KEY CLUSTERED
     138(
     139  [Id] ASC
     140)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
     141) ON [PRIMARY]
     142
     143GO
     144
     145ALTER TABLE [dbo].[Country] ADD  CONSTRAINT [DF_Country_Id]  DEFAULT (newsequentialid()) FOR [Id]
     146GO
     147
     148USE [HeuristicLab.ClientManagement]
     149GO
     150
     151/****** Object:  Table [dbo].[OperatingSystem]    Script Date: 09/27/2011 17:06:31 ******/
     152SET ANSI_NULLS ON
     153GO
     154
     155SET QUOTED_IDENTIFIER ON
     156GO
     157
     158CREATE TABLE [dbo].[OperatingSystem](
     159  [Id] [uniqueidentifier] NOT NULL,
     160  [Name] [nvarchar](max) NOT NULL,
     161 CONSTRAINT [PK_OperatingSystem] PRIMARY KEY CLUSTERED
     162(
     163  [Id] ASC
     164)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
     165) ON [PRIMARY]
     166
     167GO
     168
     169ALTER TABLE [dbo].[OperatingSystem] ADD  CONSTRAINT [DF_OperatingSystem_Id]  DEFAULT (newsequentialid()) FOR [Id]
     170GO
     171
     172USE [HeuristicLab.ClientManagement]
     173GO
     174
     175/****** Object:  Table [dbo].[Plugin]    Script Date: 09/27/2011 17:06:39 ******/
     176SET ANSI_NULLS ON
     177GO
     178
     179SET QUOTED_IDENTIFIER ON
     180GO
     181
     182CREATE TABLE [dbo].[Plugin](
     183  [Id] [uniqueidentifier] NOT NULL,
     184  [Name] [nvarchar](max) NOT NULL,
     185  [StrongName] [nvarchar](max) NULL,
     186  [Version] [nvarchar](20) NOT NULL,
     187 CONSTRAINT [PK_Plugin] PRIMARY KEY CLUSTERED
     188(
     189  [Id] ASC
     190)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
     191) ON [PRIMARY]
     192
     193GO
     194
     195ALTER TABLE [dbo].[Plugin] ADD  CONSTRAINT [DF_Plugin_Id]  DEFAULT (newsequentialid()) FOR [Id]
     196GO
     197
     198
     199USE [HeuristicLab.ClientManagement]
     200GO
     201
     202/****** Object:  Table [dbo].[ResourcePlugin]    Script Date: 09/27/2011 17:07:01 ******/
     203SET ANSI_NULLS ON
     204GO
     205
     206SET QUOTED_IDENTIFIER ON
     207GO
     208
     209CREATE TABLE [dbo].[ResourcePlugin](
     210  [ResourceId] [uniqueidentifier] NOT NULL,
     211  [PluginId] [uniqueidentifier] NOT NULL,
     212 CONSTRAINT [PK_ResourcePlugin] PRIMARY KEY CLUSTERED
     213(
     214  [ResourceId] ASC,
     215  [PluginId] ASC
     216)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
     217) ON [PRIMARY]
     218
     219GO
     220
     221ALTER TABLE [dbo].[ResourcePlugin]  WITH CHECK ADD  CONSTRAINT [FK_ResourcePlugin_Plugin] FOREIGN KEY([PluginId])
     222REFERENCES [dbo].[Plugin] ([Id])
     223GO
     224
     225ALTER TABLE [dbo].[ResourcePlugin] CHECK CONSTRAINT [FK_ResourcePlugin_Plugin]
     226GO
     227
     228ALTER TABLE [dbo].[ResourcePlugin]  WITH CHECK ADD  CONSTRAINT [FK_ResourcePlugin_Resource] FOREIGN KEY([ResourceId])
     229REFERENCES [dbo].[Resource] ([Id])
     230GO
     231
     232ALTER TABLE [dbo].[ResourcePlugin] CHECK CONSTRAINT [FK_ResourcePlugin_Resource]
     233GO
     234
     235
     236USE [HeuristicLab.ClientManagement]
     237GO
     238
     239/****** Object:  Table [dbo].[ResourceResourceGroup]    Script Date: 09/27/2011 17:07:08 ******/
     240SET ANSI_NULLS ON
     241GO
     242
     243SET QUOTED_IDENTIFIER ON
     244GO
     245
     246CREATE TABLE [dbo].[ResourceResourceGroup](
     247  [ResourceId] [uniqueidentifier] NOT NULL,
     248  [ResourceGroupId] [uniqueidentifier] NOT NULL,
     249 CONSTRAINT [PK_ResourceResourceGroup_Id] PRIMARY KEY CLUSTERED
     250(
     251  [ResourceId] ASC,
     252  [ResourceGroupId] ASC
     253)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
     254) ON [PRIMARY]
     255
     256GO
     257
     258ALTER TABLE [dbo].[ResourceResourceGroup]  WITH CHECK ADD  CONSTRAINT [FK_ResourceResourceGroup_ResourceGroupId] FOREIGN KEY([ResourceGroupId])
     259REFERENCES [dbo].[Resource] ([Id])
     260GO
     261
     262ALTER TABLE [dbo].[ResourceResourceGroup] CHECK CONSTRAINT [FK_ResourceResourceGroup_ResourceGroupId]
     263GO
     264
     265ALTER TABLE [dbo].[ResourceResourceGroup]  WITH CHECK ADD  CONSTRAINT [FK_ResourceResourceGroup_ResourceId] FOREIGN KEY([ResourceId])
     266REFERENCES [dbo].[Resource] ([Id])
     267GO
     268
     269ALTER TABLE [dbo].[ResourceResourceGroup] CHECK CONSTRAINT [FK_ResourceResourceGroup_ResourceId]
     270GO
     271
     272USE [HeuristicLab.ClientManagement]
     273GO
     274
     275/****** Object:  Table [dbo].[Resource]    Script Date: 09/27/2011 17:07:15 ******/
     276SET ANSI_NULLS ON
     277GO
     278
     279SET QUOTED_IDENTIFIER ON
     280GO
     281
     282CREATE TABLE [dbo].[Resource](
     283  [Id] [uniqueidentifier] NOT NULL,
     284  [Name] [nvarchar](max) NOT NULL,
    345285  [Description] [nvarchar](max) NULL,
    346  CONSTRAINT [PK_ClientConfiguration] PRIMARY KEY CLUSTERED
    347 (
    348   [Id] ASC
    349 )WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
    350 ) ON [PRIMARY]
    351 
    352 GO
     286  [Type] [nvarchar](max) NOT NULL,
     287  [ProcessorType] [nvarchar](max) NULL,
     288  [NumberOfCores] [int] NULL,
     289  [MemorySize] [int] NULL,
     290  [OperatingSystemId] [uniqueidentifier] NULL,
     291  [CountryId] [uniqueidentifier] NULL,
     292  [HeuristicLabVersion] [nvarchar](max) NULL,
     293  [ClientTypeId] [uniqueidentifier] NULL,
     294  [ClientConfigurationId] [uniqueidentifier] NULL,
     295  [Timestamp] [datetime] NULL,
     296 CONSTRAINT [PK_Resource] PRIMARY KEY CLUSTERED
     297(
     298  [Id] ASC
     299)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
     300) ON [PRIMARY]
     301
     302GO
     303
     304ALTER TABLE [dbo].[Resource]  WITH CHECK ADD  CONSTRAINT [FK_Resource_ClientConfiguration] FOREIGN KEY([ClientConfigurationId])
     305REFERENCES [dbo].[ClientConfiguration] ([Id])
     306GO
     307
     308ALTER TABLE [dbo].[Resource] CHECK CONSTRAINT [FK_Resource_ClientConfiguration]
     309GO
     310
     311ALTER TABLE [dbo].[Resource]  WITH CHECK ADD  CONSTRAINT [FK_Resource_ClientType] FOREIGN KEY([ClientTypeId])
     312REFERENCES [dbo].[ClientType] ([Id])
     313GO
     314
     315ALTER TABLE [dbo].[Resource] CHECK CONSTRAINT [FK_Resource_ClientType]
     316GO
     317
     318ALTER TABLE [dbo].[Resource]  WITH CHECK ADD  CONSTRAINT [FK_Resource_Country] FOREIGN KEY([CountryId])
     319REFERENCES [dbo].[Country] ([Id])
     320GO
     321
     322ALTER TABLE [dbo].[Resource] CHECK CONSTRAINT [FK_Resource_Country]
     323GO
     324
     325ALTER TABLE [dbo].[Resource]  WITH CHECK ADD  CONSTRAINT [FK_Resource_OperatingSystem] FOREIGN KEY([OperatingSystemId])
     326REFERENCES [dbo].[OperatingSystem] ([Id])
     327GO
     328
     329ALTER TABLE [dbo].[Resource] CHECK CONSTRAINT [FK_Resource_OperatingSystem]
     330GO
     331
     332ALTER TABLE [dbo].[Resource] ADD  CONSTRAINT [DF_Resource_Id]  DEFAULT (newsequentialid()) FOR [Id]
     333GO
     334
     335USE [HeuristicLab.ClientManagement]
     336GO
     337
     338/****** Object:  Table [dbo].[UserGroup]    Script Date: 09/27/2011 17:07:23 ******/
     339SET ANSI_NULLS ON
     340GO
     341
     342SET QUOTED_IDENTIFIER ON
     343GO
     344
     345CREATE TABLE [dbo].[UserGroup](
     346  [Id] [uniqueidentifier] NOT NULL,
     347  [FullName] [nvarchar](max) NULL,
     348  [Name] [nvarchar](max) NULL,
     349  [Type] [nvarchar](10) NOT NULL,
     350 CONSTRAINT [PK_UserGroup] PRIMARY KEY CLUSTERED
     351(
     352  [Id] ASC
     353)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
     354) ON [PRIMARY]
     355
     356GO
     357
     358USE [HeuristicLab.ClientManagement]
     359GO
     360
     361/****** Object:  Table [dbo].[UserGroupUserGroup]    Script Date: 09/27/2011 17:07:30 ******/
     362SET ANSI_NULLS ON
     363GO
     364
     365SET QUOTED_IDENTIFIER ON
     366GO
     367
     368CREATE TABLE [dbo].[UserGroupUserGroup](
     369  [UserGroupId] [uniqueidentifier] NOT NULL,
     370  [UserGroupUserGroupId] [uniqueidentifier] NOT NULL,
     371 CONSTRAINT [PK_UserGroupUserGroup] PRIMARY KEY CLUSTERED
     372(
     373  [UserGroupId] ASC,
     374  [UserGroupUserGroupId] ASC
     375)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
     376) ON [PRIMARY]
     377
     378GO
     379
     380ALTER TABLE [dbo].[UserGroupUserGroup]  WITH CHECK ADD  CONSTRAINT [FK_UserGroupUserGroup_UserGroup] FOREIGN KEY([UserGroupId])
     381REFERENCES [dbo].[UserGroup] ([Id])
     382GO
     383
     384ALTER TABLE [dbo].[UserGroupUserGroup] CHECK CONSTRAINT [FK_UserGroupUserGroup_UserGroup]
     385GO
     386
     387ALTER TABLE [dbo].[UserGroupUserGroup]  WITH CHECK ADD  CONSTRAINT [FK_UserGroupUserGroup_UserGroup1] FOREIGN KEY([UserGroupUserGroupId])
     388REFERENCES [dbo].[UserGroup] ([Id])
     389GO
     390
     391ALTER TABLE [dbo].[UserGroupUserGroup] CHECK CONSTRAINT [FK_UserGroupUserGroup_UserGroup1]
     392GO
     393
     394
     395
     396
     397
     398
     399
     400
     401
     402

  • branches/ClientUserManagement/HeuristicLab.Services.Access.sln

    r6826 r6840  
    1717EndProject
    1818Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.GeoIP", "HeuristicLab.GeoIP\1.12\HeuristicLab.GeoIP.csproj", "{BE9B0229-9150-49A4-AEA6-BB58E055992F}"
     19EndProject
     20Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Services.Access-3.3.Tests", "HeuristicLab.Services.Access-3.3.Tests\HeuristicLab.Services.Access-3.3.Tests.csproj", "{70C5A73A-148C-45A2-938F-F8F6DAA80A02}"
    1921EndProject
    2022Global
    … …  
    7173    {BE9B0229-9150-49A4-AEA6-BB58E055992F}.Release|Mixed Platforms.Build.0 = Release|Any CPU
    7274    {BE9B0229-9150-49A4-AEA6-BB58E055992F}.Release|x86.ActiveCfg = Release|Any CPU
     75    {70C5A73A-148C-45A2-938F-F8F6DAA80A02}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
     76    {70C5A73A-148C-45A2-938F-F8F6DAA80A02}.Debug|Any CPU.Build.0 = Debug|Any CPU
     77    {70C5A73A-148C-45A2-938F-F8F6DAA80A02}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
     78    {70C5A73A-148C-45A2-938F-F8F6DAA80A02}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
     79    {70C5A73A-148C-45A2-938F-F8F6DAA80A02}.Debug|x86.ActiveCfg = Debug|Any CPU
     80    {70C5A73A-148C-45A2-938F-F8F6DAA80A02}.Release|Any CPU.ActiveCfg = Release|Any CPU
     81    {70C5A73A-148C-45A2-938F-F8F6DAA80A02}.Release|Any CPU.Build.0 = Release|Any CPU
     82    {70C5A73A-148C-45A2-938F-F8F6DAA80A02}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
     83    {70C5A73A-148C-45A2-938F-F8F6DAA80A02}.Release|Mixed Platforms.Build.0 = Release|Any CPU
     84    {70C5A73A-148C-45A2-938F-F8F6DAA80A02}.Release|x86.ActiveCfg = Release|Any CPU
    7385  EndGlobalSection
    7486  GlobalSection(SolutionProperties) = preSolution

  • branches/ClientUserManagement/HeuristicLab.Services.Access/3.3/AccessService.cs

    r6825 r6840  
    2020#endregion
    2121
     22using System;
     23using System.Collections.Generic;
     24using System.Linq;
    2225using System.ServiceModel;
     26using DA = HeuristicLab.Services.Access.DataAccess;
     27using DT = HeuristicLab.Services.Access.DataTransfer;
    2328
    2429namespace HeuristicLab.Services.Access {
    2530  [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)]
    26   public class AccessService {
    27 
     31  public class AccessService : IAccessService {
     32
     33    #region Client Members
     34    public bool ClientExists(Guid id) {
     35      if (id != Guid.Empty) {
     36        using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
     37          return (context.Resources.Where(x => x.Id == id).Count() != 0);
     38        }
     39      }
     40      return false;
     41    }
     42
     43    public DT.Client GetClient(Guid id) {
     44      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
     45        var query = from c in context.GetTable<DA.Resource>().OfType<DA.Client>()
     46                    where c.Id == id
     47                    select c;
     48
     49        return Convert.ToDto(query.FirstOrDefault());
     50      }
     51    }
     52
     53    public IEnumerable<DT.Client> GetClients(IEnumerable<Guid> ids) {
     54      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
     55        var query = from c in context.GetTable<DA.Resource>().OfType<DA.Client>()
     56                    where ids.Contains(c.Id)
     57                    select Convert.ToDto(c);
     58        return query.ToList();
     59      }
     60    }
     61
     62    public IEnumerable<DT.Client> GetAllClients() {
     63      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
     64        var query = from c in context.GetTable<DA.Resource>().OfType<DA.Client>()
     65                    select Convert.ToDto(c);
     66        return query.ToList();
     67      }
     68    }
     69
     70    public Guid AddClient(DT.Client client) {
     71      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
     72        DA.Client entity = Convert.ToEntity(client);
     73        context.Resources.InsertOnSubmit(entity);
     74        context.SubmitChanges();
     75        return entity.Id;
     76      }
     77    }
     78
     79    public void UpdateClient(DT.Client client) {
     80      AddClient(client);
     81    }
     82
     83    public void DeleteClient(DT.Client client) {
     84      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
     85        context.Resources.DeleteOnSubmit(Convert.ToEntity(client));
     86        context.SubmitChanges();
     87      }
     88    }
     89    #endregion
     90
     91    #region ClientGroup
     92    public IEnumerable<DT.ClientGroup> GetAllClientGroups() {
     93      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
     94        var query = from c in context.GetTable<DA.Resource>().OfType<DA.ClientGroup>()
     95                    select Convert.ToDto(c);
     96        return query.ToList();
     97      }
     98    }
     99
     100    public IEnumerable<DT.ClientGroup> GetClientGroups(IEnumerable<Guid> ids) {
     101      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
     102        var query = from c in context.GetTable<DA.Resource>().OfType<DA.ClientGroup>()
     103                    where ids.Contains(c.Id)
     104                    select Convert.ToDto(c);
     105        return query.ToList();
     106      }
     107    }
     108
     109    public Guid AddClientGroup(DT.ClientGroup group) {
     110      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
     111        var entity = Convert.ToEntity(group);
     112        context.Resources.InsertOnSubmit(entity);
     113        context.SubmitChanges();
     114        return entity.Id;
     115      }
     116    }
     117
     118    public void UpdateClientGroup(DT.ClientGroup group) {
     119      AddClientGroup(group);
     120    }
     121
     122    public void DeleteClientGroup(DT.ClientGroup group) {
     123      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
     124        context.Resources.DeleteOnSubmit(Convert.ToEntity(group));
     125        context.SubmitChanges();
     126      }
     127    }
     128
     129    public void AddResourceToGroup(DT.Resource resource, DT.UserGroup group) {
     130      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
     131        DA.ResourceResourceGroup rrg = new DA.ResourceResourceGroup() {
     132          ResourceId = resource.Id,
     133          ResourceGroupId = group.Id
     134        };
     135
     136        context.ResourceResourceGroups.InsertOnSubmit(rrg);
     137        context.SubmitChanges();
     138      }
     139    }
     140
     141    public void RemoveResourceFromGroup(DT.Resource resource, DT.UserGroup group) {
     142      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
     143        var query = context.ResourceResourceGroups.Where(x => x.ResourceId == resource.Id && x.ResourceGroupId == group.Id);
     144        if (query.Count() > 0) {
     145          context.ResourceResourceGroups.DeleteOnSubmit(query.First());
     146          context.SubmitChanges();
     147        }
     148      }
     149    }
     150    #endregion
     151
     152    #region ClientGroupMapping
     153    public IEnumerable<DT.ClientGroupMapping> GetClientGroupMapping() {
     154      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
     155        var query = from c in context.GetTable<DA.ResourceResourceGroup>()
     156                    select Convert.ToDto(c);
     157        return query.ToList();
     158      }
     159    }
     160    #endregion
     161
     162    #region Resource
     163    public IEnumerable<DT.Resource> GetResources() {
     164      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
     165        var query = from r in context.Resources
     166                    select Convert.ToDto(r);
     167        return query.ToList();
     168      }
     169    }
     170    #endregion
     171
     172    #region ClientLog
     173    public DT.ClientLog GetLastClientLog(Guid clientId) {
     174      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
     175        var query = from r in context.ClientLogs
     176                    where r.ResourceId == clientId
     177                    select r;
     178        return Convert.ToDto(query.OrderBy(x => x.Timestamp).LastOrDefault());
     179      }
     180    }
     181
     182    public IEnumerable<DT.ClientLog> GetClientLogs(Guid clientId) {
     183      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
     184        var query = from r in context.ClientLogs
     185                    where r.ResourceId == clientId
     186                    select Convert.ToDto(r);
     187        return query.ToList();
     188      }
     189    }
     190
     191    public IEnumerable<DT.ClientLog> GetClientLogsSince(DateTime startDate) {
     192      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
     193        var query = from r in context.ClientLogs
     194                    where r.Timestamp >= startDate
     195                    select Convert.ToDto(r);
     196        return query.ToList();
     197      }
     198    }
     199
     200    public void AddClientLog(DT.ClientLog log) {
     201      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
     202        context.ClientLogs.InsertOnSubmit(Convert.ToEntity(log));
     203        context.SubmitChanges();
     204      }
     205    }
     206
     207    public void DeleteClientLog(DT.ClientLog log) {
     208      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
     209        context.ClientLogs.DeleteOnSubmit(Convert.ToEntity(log));
     210        context.SubmitChanges();
     211      }
     212    }
     213    #endregion
     214
     215    #region User
     216    public DT.User Login() {
     217      throw new System.NotImplementedException();
     218    }
     219
     220    public IEnumerable<DT.User> GetAllUsers() {
     221      throw new System.NotImplementedException();
     222    }
     223
     224    public IEnumerable<DT.User> GetUsers(IEnumerable<DT.User> ids) {
     225      throw new System.NotImplementedException();
     226    }
     227
     228    public DT.User AddUser(DT.User user) {
     229      throw new System.NotImplementedException();
     230    }
     231
     232    public void DeleteUser(DT.User user) {
     233      throw new System.NotImplementedException();
     234    }
     235
     236    public void UpdateUser(DT.User user) {
     237      throw new System.NotImplementedException();
     238    }
     239
     240    public void AddUserToRole(DT.Role role, DT.User user) {
     241      throw new System.NotImplementedException();
     242    }
     243
     244    public void RemoveUserFromRole(DT.Role role, DT.User user) {
     245      throw new System.NotImplementedException();
     246    }
     247
     248    public void ResetPassword(DT.User user, string password) {
     249      throw new System.NotImplementedException();
     250    }
     251    #endregion
     252
     253    public IEnumerable<DT.UserGroup> GetAllUserGroups() {
     254      throw new System.NotImplementedException();
     255    }
     256
     257    public IEnumerable<DT.UserGroup> GetUserGroups(IEnumerable<Guid> ids) {
     258      throw new System.NotImplementedException();
     259    }
     260
     261    public DT.UserGroup AddUserGroup(DT.UserGroup group) {
     262      throw new System.NotImplementedException();
     263    }
     264
     265    public void UpdateUserGroup(DT.UserGroup group) {
     266      throw new System.NotImplementedException();
     267    }
     268
     269    public void DeleteUserGroup(DT.UserGroup group) {
     270      throw new System.NotImplementedException();
     271    }
     272
     273    public void AddUserGroupBaseToGroup(DT.UserGroupBase resource, DT.UserGroup group) {
     274      throw new System.NotImplementedException();
     275    }
     276
     277    public void RemoveUserGroupBaseFromGroup(DT.UserGroupBase resource, DT.UserGroup group) {
     278      throw new System.NotImplementedException();
     279    }
     280
     281    public IEnumerable<DT.UserGroupBase> GetUsersAndGroups() {
     282      throw new System.NotImplementedException();
     283    }
     284
     285    public IEnumerable<DT.UserGroupMapping> GetUserGroupMapping() {
     286      throw new System.NotImplementedException();
     287    }
     288
     289    public IEnumerable<DT.Role> GetRoles() {
     290      throw new System.NotImplementedException();
     291    }
     292
     293    public DT.Role AddRole(DT.Role role) {
     294      throw new System.NotImplementedException();
     295    }
     296
     297    public void UpdateRole(DT.Role role) {
     298      throw new System.NotImplementedException();
     299    }
     300
     301    public void DeleteRole(DT.Role role) {
     302      throw new System.NotImplementedException();
     303    }
     304
     305    public IEnumerable<DT.Role> GetUserRoles(DT.User user) {
     306      throw new System.NotImplementedException();
     307    }
     308
     309    public void ReportError(DT.ClientError error) {
     310      throw new System.NotImplementedException();
     311    }
     312
     313    public IEnumerable<DT.ClientError> GetClientErrors() {
     314      throw new System.NotImplementedException();
     315    }
     316
     317    public IEnumerable<DT.ClientError> GetLastClientErrors(DateTime startDate) {
     318      throw new System.NotImplementedException();
     319    }
     320
     321    public void DeleteError(DT.ClientError error) {
     322      throw new System.NotImplementedException();
     323    }
    28324  }
    29325}

  • branches/ClientUserManagement/HeuristicLab.Services.Access/3.3/Convert.cs

    r6825 r6840  
    2626
    2727
    28 namespace HeuristicLab.Services.ClientManagement {
     28namespace HeuristicLab.Services.Access {
    2929  public static class Convert {
    3030
    … …  
    9595        Id = source.Id,
    9696        Name = source.Name,
    97 
    9897      };
    9998    }
    … …  
    301300    }
    302301    #endregion
     302
     303    #region ClientGroupMapping
     304    public static DT.ClientGroupMapping ToDto(DA.ResourceResourceGroup c) {
     305      return new DT.ClientGroupMapping() {
     306        Child = c.ResourceId, Parent = c.ResourceGroupId
     307      };
     308    }
     309    #endregion
     310
     311
    303312  }
    304313}

  • branches/ClientUserManagement/HeuristicLab.Services.Access/3.3/DataTransfer/Resource.cs

    r6825 r6840  
    2525namespace HeuristicLab.Services.Access.DataTransfer {
    2626  [DataContract]
     27  [KnownType(typeof(Client))]
     28  [KnownType(typeof(ClientGroup))]
    2729  public class Resource : AccessItem {
    2830    [DataMember]

  • branches/ClientUserManagement/HeuristicLab.Services.Access/3.3/DataTransfer/UserGroupBase.cs

    r6825 r6840  
    2525namespace HeuristicLab.Services.Access.DataTransfer {
    2626  [DataContract]
     27  [KnownType(typeof(User))]
     28  [KnownType(typeof(UserGroup))]
    2729  public class UserGroupBase : AccessItem {
    2830    [DataMember]

  • branches/ClientUserManagement/HeuristicLab.Services.Access/3.3/HeuristicLab.Services.Access-3.3.csproj

    r6825 r6840  
    5656    <Compile Include="DataTransfer\ClientConfiguration.cs" />
    5757    <Compile Include="DataTransfer\ClientError.cs" />
     58    <Compile Include="DataTransfer\ClientGroupMapping.cs" />
    5859    <Compile Include="DataTransfer\ClientLog.cs" />
    5960    <Compile Include="DataTransfer\AccessItem.cs" />
    … …  
    6869    <Compile Include="DataTransfer\UserGroup.cs" />
    6970    <Compile Include="DataTransfer\UserGroupBase.cs" />
     71    <Compile Include="DataTransfer\UserGroupMapping.cs" />
    7072    <Compile Include="IAccessService.cs" />
    7173    <Compile Include="Properties\AssemblyInfo.cs" />

  • branches/ClientUserManagement/HeuristicLab.Services.Access/3.3/IAccessService.cs

    r6825 r6840  
    3838
    3939    [OperationContract]
    40     IEnumerable<Client> GetClients();
     40    IEnumerable<Client> GetClients(IEnumerable<Guid> ids);
     41
     42    [OperationContract]
     43    IEnumerable<Client> GetAllClients();
    4144
    4245    [OperationContract]
    … …  
    4851    [OperationContract]
    4952    void DeleteClient(Client client);
     53    #endregion
     54
     55    #region Client Group
     56    [OperationContract]
     57    IEnumerable<ClientGroup> GetAllClientGroups();
     58
     59    [OperationContract]
     60    IEnumerable<ClientGroup> GetClientGroups(IEnumerable<Guid> ids);
     61
     62    [OperationContract]
     63    Guid AddClientGroup(ClientGroup group);
     64
     65    [OperationContract]
     66    void UpdateClientGroup(ClientGroup group);
     67
     68    [OperationContract]
     69    void DeleteClientGroup(ClientGroup group);
     70
     71    [OperationContract]
     72    void AddResourceToGroup(Resource resource, UserGroup group);
     73
     74    [OperationContract]
     75    void RemoveResourceFromGroup(Resource resource, UserGroup group);
     76    #endregion
     77
     78    #region ClientGroupMapping
     79    [OperationContract]
     80    IEnumerable<ClientGroupMapping> GetClientGroupMapping();
     81    #endregion
     82
     83    #region Resource
     84    [OperationContract]
     85    IEnumerable<Resource> GetResources();
    5086    #endregion
    5187
    … …  
    6197
    6298    [OperationContract]
    63     void AddClientLogEntry(ClientLog log);
     99    void AddClientLog(ClientLog log);
    64100
    65101    [OperationContract]
    66     void DeleteClientLogEntry(ClientLog log);
    67     #endregion
    68 
    69     #region Client Group
    70     [OperationContract]
    71     IEnumerable<ClientGroup> GetClientGroups();
    72 
    73     [OperationContract]
    74     IEnumerable<ClientGroup> GetParentGroups(Guid id);
    75 
    76     [OperationContract]
    77     Guid AddClientGroup(ClientGroup group);
    78 
    79     [OperationContract]
    80     void UpdateClientGroup(ClientGroup group);
    81 
    82     [OperationContract]
    83     void DeleteClientGroup(ClientGroup group);
     102    void DeleteClientLog(ClientLog log);
    84103    #endregion
    85104
    86105    #region User
    87106    [OperationContract]
    88     void Login();
     107    User Login();
    89108
    90109    [OperationContract]
    91     IEnumerable<User> GetUsers();
     110    IEnumerable<User> GetAllUsers();
     111
     112    [OperationContract]
     113    IEnumerable<User> GetUsers(IEnumerable<User> ids);
    92114
    93115    [OperationContract]
    … …  
    110132    #endregion
    111133
     134    #region UserGroup
     135    [OperationContract]
     136    IEnumerable<UserGroup> GetAllUserGroups();
     137
     138    [OperationContract]
     139    IEnumerable<UserGroup> GetUserGroups(IEnumerable<Guid> ids);
     140
     141    [OperationContract]
     142    UserGroup AddUserGroup(UserGroup group);
     143
     144    [OperationContract]
     145    void UpdateUserGroup(UserGroup group);
     146
     147    [OperationContract]
     148    void DeleteUserGroup(UserGroup group);
     149
     150    [OperationContract]
     151    void AddUserGroupBaseToGroup(UserGroupBase resource, UserGroup group);
     152
     153    [OperationContract]
     154    void RemoveUserGroupBaseFromGroup(UserGroupBase resource, UserGroup group);
     155    #endregion
     156
     157    #region UserGroupBase
     158    [OperationContract]
     159    IEnumerable<UserGroupBase> GetUsersAndGroups();
     160    #endregion
     161
     162    #region UserGroupMapping
     163    [OperationContract]
     164    IEnumerable<UserGroupMapping> GetUserGroupMapping();
     165    #endregion
     166
    112167    #region Role
    113168    [OperationContract]
    … …  
    127182    #endregion
    128183
    129     #region UserGroup
     184    #region ClientError
    130185    [OperationContract]
    131     IEnumerable<UserGroup> GetUserGroups();
     186    void ReportError(ClientError error);
    132187
    133188    [OperationContract]
    134     UserGroup AddUserGroup(UserGroup group);
     189    IEnumerable<ClientError> GetClientErrors();
    135190
    136191    [OperationContract]
    137     void UpdateUserGroup(UserGroup group);
     192    IEnumerable<ClientError> GetLastClientErrors(DateTime startDate);
    138193
    139194    [OperationContract]
    140     void DeleteUserGroup(UserGroup group);
     195    void DeleteError(ClientError error);
    141196    #endregion
    142197  }
Note: See TracChangeset for help on using the changeset viewer.