Free cookie consent management tool by TermsFeed Policy Generator

Changeset 4494


Ignore:
Timestamp:
09/26/10 00:48:11 (14 years ago)
Author:
swagner
Message:

Adapted deployment service (#1165)

Location:
trunk/sources
Files:
1 added
1 deleted
7 edited
8 moved

Legend:

Unmodified
Added
Removed

  • trunk/sources/HeuristicLab.Services.Deployment.DataAccess/3.3/Deployment.dbml

    r4493 r4494  
    1 <?xml version="1.0" encoding="utf-8"?>
    2 <Database Name="HeuristicLab.PluginStore" Class="PluginStoreClassesDataContext" xmlns="http://schemas.microsoft.com/linqtosql/dbml/2007">
    3   <Connection Mode="AppSettings" ConnectionString="Data Source=HEUREKA01\SQLEXPRESS;Initial Catalog=HeuristicLab.PluginStore;Integrated Security=True" SettingsObjectName="HeuristicLab.Services.Deployment.DataAccess.Properties.Settings" SettingsPropertyName="HeuristicLab_PluginStoreConnectionString" Provider="System.Data.SqlClient" />
     1<?xml version="1.0" encoding="utf-8"?><Database Name="HeuristicLab.PluginStore" Class="DeploymentDataContext" xmlns="http://schemas.microsoft.com/linqtosql/dbml/2007">
     2  <Connection Mode="AppSettings" ConnectionString="Data Source=.\SQLEXPRESS;Initial Catalog=HeuristicLab.Deployment;Integrated Security=SSPI" SettingsObjectName="HeuristicLab.Services.Deployment.DataAccess.Properties.Settings" SettingsPropertyName="HeuristicLab_DeploymentConnectionString" Provider="System.Data.SqlClient" />
    43  <Table Name="dbo.Dependencies" Member="Dependencies">
    54    <Type Name="Dependency">

  • trunk/sources/HeuristicLab.Services.Deployment.DataAccess/3.3/Deployment.dbml.layout

    r4493 r4494  
    11<?xml version="1.0" encoding="utf-8"?>
    22<ordesignerObjectsDiagram dslVersion="1.0.0.0" absoluteBounds="0, 0, 11, 8.5" name="PluginStoreClasses">
    3   <DataContextMoniker Name="/PluginStoreClassesDataContext" />
     3  <DataContextMoniker Name="/DeploymentDataContext" />
    44  <nestedChildShapes>
    55    <classShape Id="16e9d26d-f78e-4457-8cdb-0cee0835a0b6" absoluteBounds="3.5, 2, 2, 1.1939925130208335">
    6       <DataClassMoniker Name="/PluginStoreClassesDataContext/Dependency" />
     6      <DataClassMoniker Name="/DeploymentDataContext/Dependency" />
    77      <nestedChildShapes>
    88        <elementListCompartment Id="90573696-5cb0-44c5-a492-6e26800047b3" absoluteBounds="3.515, 2.46, 1.9700000000000002, 0.63399251302083326" name="DataPropertiesCompartment" titleTextColor="Black" itemTextColor="Black" />
    … …  
    1010    </classShape>
    1111    <classShape Id="86708203-9aa2-44f4-a85f-7fad2c542e23" absoluteBounds="3.5, 4, 2, 1.1939925130208344">
    12       <DataClassMoniker Name="/PluginStoreClassesDataContext/ProductPlugin" />
     12      <DataClassMoniker Name="/DeploymentDataContext/ProductPlugin" />
    1313      <nestedChildShapes>
    1414        <elementListCompartment Id="da9607ee-b60e-44f0-8e80-704abd6dd898" absoluteBounds="3.515, 4.46, 1.9700000000000002, 0.63399251302083326" name="DataPropertiesCompartment" titleTextColor="Black" itemTextColor="Black" />
    … …  
    1616    </classShape>
    1717    <classShape Id="1e228e3e-9436-4cd0-b7f7-492427268001" absoluteBounds="0.75, 2.625, 2, 1.9631982421874996">
    18       <DataClassMoniker Name="/PluginStoreClassesDataContext/Plugin" />
     18      <DataClassMoniker Name="/DeploymentDataContext/Plugin" />
    1919      <nestedChildShapes>
    2020        <elementListCompartment Id="81f74f1f-d4d0-4dce-991e-fb10afa63eb5" absoluteBounds="0.765, 3.085, 1.9700000000000002, 1.4031982421875" name="DataPropertiesCompartment" titleTextColor="Black" itemTextColor="Black" />
    … …  
    2222    </classShape>
    2323    <classShape Id="d660db81-846c-4661-9a86-09567e927f9d" absoluteBounds="3.5, 6, 2, 1.1939925130208344">
    24       <DataClassMoniker Name="/PluginStoreClassesDataContext/PluginPackage" />
     24      <DataClassMoniker Name="/DeploymentDataContext/PluginPackage" />
    2525      <nestedChildShapes>
    2626        <elementListCompartment Id="31a89e0e-c915-41d6-926b-d8c0f029f27d" absoluteBounds="3.515, 6.46, 1.9700000000000002, 0.63399251302083326" name="DataPropertiesCompartment" titleTextColor="Black" itemTextColor="Black" />
    … …  
    2828    </classShape>
    2929    <classShape Id="55486421-017b-44b9-894d-6cc4501cda04" absoluteBounds="0.75, 5.875, 2, 1.3862939453125005">
    30       <DataClassMoniker Name="/PluginStoreClassesDataContext/Product" />
     30      <DataClassMoniker Name="/DeploymentDataContext/Product" />
    3131      <nestedChildShapes>
    3232        <elementListCompartment Id="5abad42a-034c-4331-916c-e757c0c6c777" absoluteBounds="0.765, 6.335, 1.9700000000000002, 0.8262939453125" name="DataPropertiesCompartment" titleTextColor="Black" itemTextColor="Black" />
    3333      </nestedChildShapes>
    3434    </classShape>
    35     <associationConnector edgePoints="[(2.75 : 4.5881982421875); (3.125 : 4.9631982421875); (3.125 : 6.59699625651042); (3.5 : 6.59699625651042)]" fixedFrom="NotFixed" fixedTo="Algorithm">
    36       <AssociationMoniker Name="/PluginStoreClassesDataContext/Plugin/Plugin_PluginPackage" />
     35    <associationConnector edgePoints="[(2.75 : 4.5881982421875); (3.125 : 4.9631982421875); (3.125 : 6.59699625651042); (3.5 : 6.59699625651042)]" fixedFrom="NotFixed" fixedTo="NotFixed">
     36      <AssociationMoniker Name="/DeploymentDataContext/Plugin/Plugin_PluginPackage" />
    3737      <nodes>
    3838        <classShapeMoniker Id="1e228e3e-9436-4cd0-b7f7-492427268001" />

  • trunk/sources/HeuristicLab.Services.Deployment.DataAccess/3.3/Deployment.designer.cs

    r4493 r4494  
    1010//------------------------------------------------------------------------------
    1111
    12 namespace HeuristicLab.Services.Deployment.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.PluginStore")]
    20   public partial class PluginStoreClassesDataContext : System.Data.Linq.DataContext {
    21 
    22     private static System.Data.Linq.Mapping.MappingSource mappingSource = new AttributeMappingSource();
    23 
     12namespace HeuristicLab.Services.Deployment.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.PluginStore")]
     26  public partial class DeploymentDataContext : 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();
    … …  
    4047    partial void DeleteProduct(Product instance);
    4148    #endregion
    42 
    43     public PluginStoreClassesDataContext() :
    44       base(global::HeuristicLab.Services.Deployment.DataAccess.Properties.Settings.Default.HeuristicLab_PluginStoreConnectionString, mappingSource) {
    45       OnCreated();
    46     }
    47 
    48     public PluginStoreClassesDataContext(string connection) :
    49       base(connection, mappingSource) {
    50       OnCreated();
    51     }
    52 
    53     public PluginStoreClassesDataContext(System.Data.IDbConnection connection) :
    54       base(connection, mappingSource) {
    55       OnCreated();
    56     }
    57 
    58     public PluginStoreClassesDataContext(string connection, System.Data.Linq.Mapping.MappingSource mappingSource) :
    59       base(connection, mappingSource) {
    60       OnCreated();
    61     }
    62 
    63     public PluginStoreClassesDataContext(System.Data.IDbConnection connection, System.Data.Linq.Mapping.MappingSource mappingSource) :
    64       base(connection, mappingSource) {
    65       OnCreated();
    66     }
    67 
    68     public System.Data.Linq.Table<Dependency> Dependencies {
    69       get {
    70         return this.GetTable<Dependency>();
    71       }
    72     }
    73 
    74     public System.Data.Linq.Table<ProductPlugin> ProductPlugins {
    75       get {
    76         return this.GetTable<ProductPlugin>();
    77       }
    78     }
    79 
    80     public System.Data.Linq.Table<Plugin> Plugins {
    81       get {
    82         return this.GetTable<Plugin>();
    83       }
    84     }
    85 
    86     public System.Data.Linq.Table<PluginPackage> PluginPackages {
    87       get {
    88         return this.GetTable<PluginPackage>();
    89       }
    90     }
    91 
    92     public System.Data.Linq.Table<Product> Products {
    93       get {
    94         return this.GetTable<Product>();
    95       }
    96     }
    97   }
    98 
    99   [global::System.Data.Linq.Mapping.TableAttribute(Name = "dbo.Dependencies")]
    100   public partial class Dependency : INotifyPropertyChanging, INotifyPropertyChanged {
    101 
    102     private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    103 
    104     private long _PluginId;
    105 
    106     private long _DependencyId;
    107 
     49   
     50    public DeploymentDataContext() :
     51        base(global::HeuristicLab.Services.Deployment.DataAccess.Properties.Settings.Default.HeuristicLab_DeploymentConnectionString, mappingSource)
     52    {
     53      OnCreated();
     54    }
     55   
     56    public DeploymentDataContext(string connection) :
     57        base(connection, mappingSource)
     58    {
     59      OnCreated();
     60    }
     61   
     62    public DeploymentDataContext(System.Data.IDbConnection connection) :
     63        base(connection, mappingSource)
     64    {
     65      OnCreated();
     66    }
     67   
     68    public DeploymentDataContext(string connection, System.Data.Linq.Mapping.MappingSource mappingSource) :
     69        base(connection, mappingSource)
     70    {
     71      OnCreated();
     72    }
     73   
     74    public DeploymentDataContext(System.Data.IDbConnection connection, System.Data.Linq.Mapping.MappingSource mappingSource) :
     75        base(connection, mappingSource)
     76    {
     77      OnCreated();
     78    }
     79   
     80    public System.Data.Linq.Table<Dependency> Dependencies
     81    {
     82      get
     83      {
     84        return this.GetTable<Dependency>();
     85      }
     86    }
     87   
     88    public System.Data.Linq.Table<ProductPlugin> ProductPlugins
     89    {
     90      get
     91      {
     92        return this.GetTable<ProductPlugin>();
     93      }
     94    }
     95   
     96    public System.Data.Linq.Table<Plugin> Plugins
     97    {
     98      get
     99      {
     100        return this.GetTable<Plugin>();
     101      }
     102    }
     103   
     104    public System.Data.Linq.Table<PluginPackage> PluginPackages
     105    {
     106      get
     107      {
     108        return this.GetTable<PluginPackage>();
     109      }
     110    }
     111   
     112    public System.Data.Linq.Table<Product> Products
     113    {
     114      get
     115      {
     116        return this.GetTable<Product>();
     117      }
     118    }
     119  }
     120 
     121  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Dependencies")]
     122  public partial class Dependency : INotifyPropertyChanging, INotifyPropertyChanged
     123  {
     124   
     125    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
     126   
     127    private long _PluginId;
     128   
     129    private long _DependencyId;
     130   
    108131    #region Extensibility Method Definitions
    109132    partial void OnLoaded();
    … …  
    115138    partial void OnDependencyIdChanged();
    116139    #endregion
    117 
    118     public Dependency() {
    119       OnCreated();
    120     }
    121 
    122     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_PluginId", DbType = "BigInt NOT NULL", IsPrimaryKey = true)]
    123     public long PluginId {
    124       get {
    125         return this._PluginId;
    126       }
    127       set {
    128         if ((this._PluginId != value)) {
    129           this.OnPluginIdChanging(value);
    130           this.SendPropertyChanging();
    131           this._PluginId = value;
    132           this.SendPropertyChanged("PluginId");
    133           this.OnPluginIdChanged();
    134         }
    135       }
    136     }
    137 
    138     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_DependencyId", DbType = "BigInt NOT NULL", IsPrimaryKey = true)]
    139     public long DependencyId {
    140       get {
    141         return this._DependencyId;
    142       }
    143       set {
    144         if ((this._DependencyId != value)) {
    145           this.OnDependencyIdChanging(value);
    146           this.SendPropertyChanging();
    147           this._DependencyId = value;
    148           this.SendPropertyChanged("DependencyId");
    149           this.OnDependencyIdChanged();
    150         }
    151       }
    152     }
    153 
    154     public event PropertyChangingEventHandler PropertyChanging;
    155 
    156     public event PropertyChangedEventHandler PropertyChanged;
    157 
    158     protected virtual void SendPropertyChanging() {
    159       if ((this.PropertyChanging != null)) {
    160         this.PropertyChanging(this, emptyChangingEventArgs);
    161       }
    162     }
    163 
    164     protected virtual void SendPropertyChanged(String propertyName) {
    165       if ((this.PropertyChanged != null)) {
    166         this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    167       }
    168     }
    169   }
    170 
    171   [global::System.Data.Linq.Mapping.TableAttribute(Name = "dbo.ProductPlugin")]
    172   public partial class ProductPlugin : INotifyPropertyChanging, INotifyPropertyChanged {
    173 
    174     private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    175 
    176     private long _ProductId;
    177 
    178     private long _PluginId;
    179 
     140   
     141    public Dependency()
     142    {
     143      OnCreated();
     144    }
     145   
     146    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginId", DbType="BigInt NOT NULL", IsPrimaryKey=true)]
     147    public long PluginId
     148    {
     149      get
     150      {
     151        return this._PluginId;
     152      }
     153      set
     154      {
     155        if ((this._PluginId != value))
     156        {
     157          this.OnPluginIdChanging(value);
     158          this.SendPropertyChanging();
     159          this._PluginId = value;
     160          this.SendPropertyChanged("PluginId");
     161          this.OnPluginIdChanged();
     162        }
     163      }
     164    }
     165   
     166    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DependencyId", DbType="BigInt NOT NULL", IsPrimaryKey=true)]
     167    public long DependencyId
     168    {
     169      get
     170      {
     171        return this._DependencyId;
     172      }
     173      set
     174      {
     175        if ((this._DependencyId != value))
     176        {
     177          this.OnDependencyIdChanging(value);
     178          this.SendPropertyChanging();
     179          this._DependencyId = value;
     180          this.SendPropertyChanged("DependencyId");
     181          this.OnDependencyIdChanged();
     182        }
     183      }
     184    }
     185   
     186    public event PropertyChangingEventHandler PropertyChanging;
     187   
     188    public event PropertyChangedEventHandler PropertyChanged;
     189   
     190    protected virtual void SendPropertyChanging()
     191    {
     192      if ((this.PropertyChanging != null))
     193      {
     194        this.PropertyChanging(this, emptyChangingEventArgs);
     195      }
     196    }
     197   
     198    protected virtual void SendPropertyChanged(String propertyName)
     199    {
     200      if ((this.PropertyChanged != null))
     201      {
     202        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
     203      }
     204    }
     205  }
     206 
     207  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.ProductPlugin")]
     208  public partial class ProductPlugin : INotifyPropertyChanging, INotifyPropertyChanged
     209  {
     210   
     211    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
     212   
     213    private long _ProductId;
     214   
     215    private long _PluginId;
     216   
    180217    #region Extensibility Method Definitions
    181218    partial void OnLoaded();
    … …  
    187224    partial void OnPluginIdChanged();
    188225    #endregion
    189 
    190     public ProductPlugin() {
    191       OnCreated();
    192     }
    193 
    194     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_ProductId", DbType = "BigInt NOT NULL", IsPrimaryKey = true)]
    195     public long ProductId {
    196       get {
    197         return this._ProductId;
    198       }
    199       set {
    200         if ((this._ProductId != value)) {
    201           this.OnProductIdChanging(value);
    202           this.SendPropertyChanging();
    203           this._ProductId = value;
    204           this.SendPropertyChanged("ProductId");
    205           this.OnProductIdChanged();
    206         }
    207       }
    208     }
    209 
    210     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_PluginId", DbType = "BigInt NOT NULL", IsPrimaryKey = true)]
    211     public long PluginId {
    212       get {
    213         return this._PluginId;
    214       }
    215       set {
    216         if ((this._PluginId != value)) {
    217           this.OnPluginIdChanging(value);
    218           this.SendPropertyChanging();
    219           this._PluginId = value;
    220           this.SendPropertyChanged("PluginId");
    221           this.OnPluginIdChanged();
    222         }
    223       }
    224     }
    225 
    226     public event PropertyChangingEventHandler PropertyChanging;
    227 
    228     public event PropertyChangedEventHandler PropertyChanged;
    229 
    230     protected virtual void SendPropertyChanging() {
    231       if ((this.PropertyChanging != null)) {
    232         this.PropertyChanging(this, emptyChangingEventArgs);
    233       }
    234     }
    235 
    236     protected virtual void SendPropertyChanged(String propertyName) {
    237       if ((this.PropertyChanged != null)) {
    238         this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    239       }
    240     }
    241   }
    242 
    243   [global::System.Data.Linq.Mapping.TableAttribute(Name = "dbo.Plugin")]
    244   public partial class Plugin : INotifyPropertyChanging, INotifyPropertyChanged {
    245 
    246     private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    247 
    248     private long _Id;
    249 
    250     private string _Name;
    251 
    252     private string _Version;
    253 
    254     private string _ContactName;
    255 
    256     private string _ContactEmail;
    257 
    258     private string _License;
    259 
    260     private EntityRef<PluginPackage> _PluginPackage;
    261 
     226   
     227    public ProductPlugin()
     228    {
     229      OnCreated();
     230    }
     231   
     232    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ProductId", DbType="BigInt NOT NULL", IsPrimaryKey=true)]
     233    public long ProductId
     234    {
     235      get
     236      {
     237        return this._ProductId;
     238      }
     239      set
     240      {
     241        if ((this._ProductId != value))
     242        {
     243          this.OnProductIdChanging(value);
     244          this.SendPropertyChanging();
     245          this._ProductId = value;
     246          this.SendPropertyChanged("ProductId");
     247          this.OnProductIdChanged();
     248        }
     249      }
     250    }
     251   
     252    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginId", DbType="BigInt NOT NULL", IsPrimaryKey=true)]
     253    public long PluginId
     254    {
     255      get
     256      {
     257        return this._PluginId;
     258      }
     259      set
     260      {
     261        if ((this._PluginId != value))
     262        {
     263          this.OnPluginIdChanging(value);
     264          this.SendPropertyChanging();
     265          this._PluginId = value;
     266          this.SendPropertyChanged("PluginId");
     267          this.OnPluginIdChanged();
     268        }
     269      }
     270    }
     271   
     272    public event PropertyChangingEventHandler PropertyChanging;
     273   
     274    public event PropertyChangedEventHandler PropertyChanged;
     275   
     276    protected virtual void SendPropertyChanging()
     277    {
     278      if ((this.PropertyChanging != null))
     279      {
     280        this.PropertyChanging(this, emptyChangingEventArgs);
     281      }
     282    }
     283   
     284    protected virtual void SendPropertyChanged(String propertyName)
     285    {
     286      if ((this.PropertyChanged != null))
     287      {
     288        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
     289      }
     290    }
     291  }
     292 
     293  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Plugin")]
     294  public partial class Plugin : INotifyPropertyChanging, INotifyPropertyChanged
     295  {
     296   
     297    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
     298   
     299    private long _Id;
     300   
     301    private string _Name;
     302   
     303    private string _Version;
     304   
     305    private string _ContactName;
     306   
     307    private string _ContactEmail;
     308   
     309    private string _License;
     310   
     311    private EntityRef<PluginPackage> _PluginPackage;
     312   
    262313    #region Extensibility Method Definitions
    263314    partial void OnLoaded();
    … …  
    277328    partial void OnLicenseChanged();
    278329    #endregion
    279 
    280     public Plugin() {
    281       this._PluginPackage = default(EntityRef<PluginPackage>);
    282       OnCreated();
    283     }
    284 
    285     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_Id", AutoSync = AutoSync.OnInsert, DbType = "BigInt NOT NULL IDENTITY", IsPrimaryKey = true, IsDbGenerated = true)]
    286     public long Id {
    287       get {
    288         return this._Id;
    289       }
    290       set {
    291         if ((this._Id != value)) {
    292           this.OnIdChanging(value);
    293           this.SendPropertyChanging();
    294           this._Id = value;
    295           this.SendPropertyChanged("Id");
    296           this.OnIdChanged();
    297         }
    298       }
    299     }
    300 
    301     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_Name", DbType = "NVarChar(300) NOT NULL", CanBeNull = false)]
    302     public string Name {
    303       get {
    304         return this._Name;
    305       }
    306       set {
    307         if ((this._Name != value)) {
    308           this.OnNameChanging(value);
    309           this.SendPropertyChanging();
    310           this._Name = value;
    311           this.SendPropertyChanged("Name");
    312           this.OnNameChanged();
    313         }
    314       }
    315     }
    316 
    317     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_Version", DbType = "NVarChar(50) NOT NULL", CanBeNull = false)]
    318     public string Version {
    319       get {
    320         return this._Version;
    321       }
    322       set {
    323         if ((this._Version != value)) {
    324           this.OnVersionChanging(value);
    325           this.SendPropertyChanging();
    326           this._Version = value;
    327           this.SendPropertyChanged("Version");
    328           this.OnVersionChanged();
    329         }
    330       }
    331     }
    332 
    333     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_ContactName", DbType = "Text", UpdateCheck = UpdateCheck.Never)]
    334     public string ContactName {
    335       get {
    336         return this._ContactName;
    337       }
    338       set {
    339         if ((this._ContactName != value)) {
    340           this.OnContactNameChanging(value);
    341           this.SendPropertyChanging();
    342           this._ContactName = value;
    343           this.SendPropertyChanged("ContactName");
    344           this.OnContactNameChanged();
    345         }
    346       }
    347     }
    348 
    349     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_ContactEmail", DbType = "Text", UpdateCheck = UpdateCheck.Never)]
    350     public string ContactEmail {
    351       get {
    352         return this._ContactEmail;
    353       }
    354       set {
    355         if ((this._ContactEmail != value)) {
    356           this.OnContactEmailChanging(value);
    357           this.SendPropertyChanging();
    358           this._ContactEmail = value;
    359           this.SendPropertyChanged("ContactEmail");
    360           this.OnContactEmailChanged();
    361         }
    362       }
    363     }
    364 
    365     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_License", DbType = "Text", UpdateCheck = UpdateCheck.Never)]
    366     public string License {
    367       get {
    368         return this._License;
    369       }
    370       set {
    371         if ((this._License != value)) {
    372           this.OnLicenseChanging(value);
    373           this.SendPropertyChanging();
    374           this._License = value;
    375           this.SendPropertyChanged("License");
    376           this.OnLicenseChanged();
    377         }
    378       }
    379     }
    380 
    381     [global::System.Data.Linq.Mapping.AssociationAttribute(Name = "Plugin_PluginPackage", Storage = "_PluginPackage", ThisKey = "Id", OtherKey = "PluginId", IsUnique = true, IsForeignKey = false)]
    382     public PluginPackage PluginPackage {
    383       get {
    384         return this._PluginPackage.Entity;
    385       }
    386       set {
    387         PluginPackage previousValue = this._PluginPackage.Entity;
    388         if (((previousValue != value)
    389               || (this._PluginPackage.HasLoadedOrAssignedValue == false))) {
    390           this.SendPropertyChanging();
    391           if ((previousValue != null)) {
    392             this._PluginPackage.Entity = null;
    393             previousValue.Plugin = null;
    394           }
    395           this._PluginPackage.Entity = value;
    396           if ((value != null)) {
    397             value.Plugin = this;
    398           }
    399           this.SendPropertyChanged("PluginPackage");
    400         }
    401       }
    402     }
    403 
    404     public event PropertyChangingEventHandler PropertyChanging;
    405 
    406     public event PropertyChangedEventHandler PropertyChanged;
    407 
    408     protected virtual void SendPropertyChanging() {
    409       if ((this.PropertyChanging != null)) {
    410         this.PropertyChanging(this, emptyChangingEventArgs);
    411       }
    412     }
    413 
    414     protected virtual void SendPropertyChanged(String propertyName) {
    415       if ((this.PropertyChanged != null)) {
    416         this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    417       }
    418     }
    419   }
    420 
    421   [global::System.Data.Linq.Mapping.TableAttribute(Name = "dbo.PluginPackage")]
    422   public partial class PluginPackage : INotifyPropertyChanging, INotifyPropertyChanged {
    423 
    424     private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    425 
    426     private long _PluginId;
    427 
    428     private System.Data.Linq.Binary _Data;
    429 
    430     private EntityRef<Plugin> _Plugin;
    431 
     330   
     331    public Plugin()
     332    {
     333      this._PluginPackage = default(EntityRef<PluginPackage>);
     334      OnCreated();
     335    }
     336   
     337    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true)]
     338    public long Id
     339    {
     340      get
     341      {
     342        return this._Id;
     343      }
     344      set
     345      {
     346        if ((this._Id != value))
     347        {
     348          this.OnIdChanging(value);
     349          this.SendPropertyChanging();
     350          this._Id = value;
     351          this.SendPropertyChanged("Id");
     352          this.OnIdChanged();
     353        }
     354      }
     355    }
     356   
     357    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(300) NOT NULL", CanBeNull=false)]
     358    public string Name
     359    {
     360      get
     361      {
     362        return this._Name;
     363      }
     364      set
     365      {
     366        if ((this._Name != value))
     367        {
     368          this.OnNameChanging(value);
     369          this.SendPropertyChanging();
     370          this._Name = value;
     371          this.SendPropertyChanged("Name");
     372          this.OnNameChanged();
     373        }
     374      }
     375    }
     376   
     377    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Version", DbType="NVarChar(50) NOT NULL", CanBeNull=false)]
     378    public string Version
     379    {
     380      get
     381      {
     382        return this._Version;
     383      }
     384      set
     385      {
     386        if ((this._Version != value))
     387        {
     388          this.OnVersionChanging(value);
     389          this.SendPropertyChanging();
     390          this._Version = value;
     391          this.SendPropertyChanged("Version");
     392          this.OnVersionChanged();
     393        }
     394      }
     395    }
     396   
     397    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ContactName", DbType="Text", UpdateCheck=UpdateCheck.Never)]
     398    public string ContactName
     399    {
     400      get
     401      {
     402        return this._ContactName;
     403      }
     404      set
     405      {
     406        if ((this._ContactName != value))
     407        {
     408          this.OnContactNameChanging(value);
     409          this.SendPropertyChanging();
     410          this._ContactName = value;
     411          this.SendPropertyChanged("ContactName");
     412          this.OnContactNameChanged();
     413        }
     414      }
     415    }
     416   
     417    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ContactEmail", DbType="Text", UpdateCheck=UpdateCheck.Never)]
     418    public string ContactEmail
     419    {
     420      get
     421      {
     422        return this._ContactEmail;
     423      }
     424      set
     425      {
     426        if ((this._ContactEmail != value))
     427        {
     428          this.OnContactEmailChanging(value);
     429          this.SendPropertyChanging();
     430          this._ContactEmail = value;
     431          this.SendPropertyChanged("ContactEmail");
     432          this.OnContactEmailChanged();
     433        }
     434      }
     435    }
     436   
     437    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_License", DbType="Text", UpdateCheck=UpdateCheck.Never)]
     438    public string License
     439    {
     440      get
     441      {
     442        return this._License;
     443      }
     444      set
     445      {
     446        if ((this._License != value))
     447        {
     448          this.OnLicenseChanging(value);
     449          this.SendPropertyChanging();
     450          this._License = value;
     451          this.SendPropertyChanged("License");
     452          this.OnLicenseChanged();
     453        }
     454      }
     455    }
     456   
     457    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Plugin_PluginPackage", Storage="_PluginPackage", ThisKey="Id", OtherKey="PluginId", IsUnique=true, IsForeignKey=false)]
     458    public PluginPackage PluginPackage
     459    {
     460      get
     461      {
     462        return this._PluginPackage.Entity;
     463      }
     464      set
     465      {
     466        PluginPackage previousValue = this._PluginPackage.Entity;
     467        if (((previousValue != value)
     468              || (this._PluginPackage.HasLoadedOrAssignedValue == false)))
     469        {
     470          this.SendPropertyChanging();
     471          if ((previousValue != null))
     472          {
     473            this._PluginPackage.Entity = null;
     474            previousValue.Plugin = null;
     475          }
     476          this._PluginPackage.Entity = value;
     477          if ((value != null))
     478          {
     479            value.Plugin = this;
     480          }
     481          this.SendPropertyChanged("PluginPackage");
     482        }
     483      }
     484    }
     485   
     486    public event PropertyChangingEventHandler PropertyChanging;
     487   
     488    public event PropertyChangedEventHandler PropertyChanged;
     489   
     490    protected virtual void SendPropertyChanging()
     491    {
     492      if ((this.PropertyChanging != null))
     493      {
     494        this.PropertyChanging(this, emptyChangingEventArgs);
     495      }
     496    }
     497   
     498    protected virtual void SendPropertyChanged(String propertyName)
     499    {
     500      if ((this.PropertyChanged != null))
     501      {
     502        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
     503      }
     504    }
     505  }
     506 
     507  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.PluginPackage")]
     508  public partial class PluginPackage : INotifyPropertyChanging, INotifyPropertyChanged
     509  {
     510   
     511    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
     512   
     513    private long _PluginId;
     514   
     515    private System.Data.Linq.Binary _Data;
     516   
     517    private EntityRef<Plugin> _Plugin;
     518   
    432519    #region Extensibility Method Definitions
    433520    partial void OnLoaded();
    … …  
    439526    partial void OnDataChanged();
    440527    #endregion
    441 
    442     public PluginPackage() {
    443       this._Plugin = default(EntityRef<Plugin>);
    444       OnCreated();
    445     }
    446 
    447     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_PluginId", DbType = "BigInt NOT NULL", IsPrimaryKey = true)]
    448     public long PluginId {
    449       get {
    450         return this._PluginId;
    451       }
    452       set {
    453         if ((this._PluginId != value)) {
    454           if (this._Plugin.HasLoadedOrAssignedValue) {
    455             throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
    456           }
    457           this.OnPluginIdChanging(value);
    458           this.SendPropertyChanging();
    459           this._PluginId = value;
    460           this.SendPropertyChanged("PluginId");
    461           this.OnPluginIdChanged();
    462         }
    463       }
    464     }
    465 
    466     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_Data", DbType = "Image NOT NULL", CanBeNull = false, UpdateCheck = UpdateCheck.Never)]
    467     public System.Data.Linq.Binary Data {
    468       get {
    469         return this._Data;
    470       }
    471       set {
    472         if ((this._Data != value)) {
    473           this.OnDataChanging(value);
    474           this.SendPropertyChanging();
    475           this._Data = value;
    476           this.SendPropertyChanged("Data");
    477           this.OnDataChanged();
    478         }
    479       }
    480     }
    481 
    482     [global::System.Data.Linq.Mapping.AssociationAttribute(Name = "Plugin_PluginPackage", Storage = "_Plugin", ThisKey = "PluginId", OtherKey = "Id", IsForeignKey = true)]
    483     public Plugin Plugin {
    484       get {
    485         return this._Plugin.Entity;
    486       }
    487       set {
    488         Plugin previousValue = this._Plugin.Entity;
    489         if (((previousValue != value)
    490               || (this._Plugin.HasLoadedOrAssignedValue == false))) {
    491           this.SendPropertyChanging();
    492           if ((previousValue != null)) {
    493             this._Plugin.Entity = null;
    494             previousValue.PluginPackage = null;
    495           }
    496           this._Plugin.Entity = value;
    497           if ((value != null)) {
    498             value.PluginPackage = this;
    499             this._PluginId = value.Id;
    500           } else {
    501             this._PluginId = default(long);
    502           }
    503           this.SendPropertyChanged("Plugin");
    504         }
    505       }
    506     }
    507 
    508     public event PropertyChangingEventHandler PropertyChanging;
    509 
    510     public event PropertyChangedEventHandler PropertyChanged;
    511 
    512     protected virtual void SendPropertyChanging() {
    513       if ((this.PropertyChanging != null)) {
    514         this.PropertyChanging(this, emptyChangingEventArgs);
    515       }
    516     }
    517 
    518     protected virtual void SendPropertyChanged(String propertyName) {
    519       if ((this.PropertyChanged != null)) {
    520         this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    521       }
    522     }
    523   }
    524 
    525   [global::System.Data.Linq.Mapping.TableAttribute(Name = "dbo.Product")]
    526   public partial class Product : INotifyPropertyChanging, INotifyPropertyChanged {
    527 
    528     private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    529 
    530     private long _Id;
    531 
    532     private string _Name;
    533 
    534     private string _Version;
    535 
     528   
     529    public PluginPackage()
     530    {
     531      this._Plugin = default(EntityRef<Plugin>);
     532      OnCreated();
     533    }
     534   
     535    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginId", DbType="BigInt NOT NULL", IsPrimaryKey=true)]
     536    public long PluginId
     537    {
     538      get
     539      {
     540        return this._PluginId;
     541      }
     542      set
     543      {
     544        if ((this._PluginId != value))
     545        {
     546          if (this._Plugin.HasLoadedOrAssignedValue)
     547          {
     548            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
     549          }
     550          this.OnPluginIdChanging(value);
     551          this.SendPropertyChanging();
     552          this._PluginId = value;
     553          this.SendPropertyChanged("PluginId");
     554          this.OnPluginIdChanged();
     555        }
     556      }
     557    }
     558   
     559    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Data", DbType="Image NOT NULL", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
     560    public System.Data.Linq.Binary Data
     561    {
     562      get
     563      {
     564        return this._Data;
     565      }
     566      set
     567      {
     568        if ((this._Data != value))
     569        {
     570          this.OnDataChanging(value);
     571          this.SendPropertyChanging();
     572          this._Data = value;
     573          this.SendPropertyChanged("Data");
     574          this.OnDataChanged();
     575        }
     576      }
     577    }
     578   
     579    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Plugin_PluginPackage", Storage="_Plugin", ThisKey="PluginId", OtherKey="Id", IsForeignKey=true)]
     580    public Plugin Plugin
     581    {
     582      get
     583      {
     584        return this._Plugin.Entity;
     585      }
     586      set
     587      {
     588        Plugin previousValue = this._Plugin.Entity;
     589        if (((previousValue != value)
     590              || (this._Plugin.HasLoadedOrAssignedValue == false)))
     591        {
     592          this.SendPropertyChanging();
     593          if ((previousValue != null))
     594          {
     595            this._Plugin.Entity = null;
     596            previousValue.PluginPackage = null;
     597          }
     598          this._Plugin.Entity = value;
     599          if ((value != null))
     600          {
     601            value.PluginPackage = this;
     602            this._PluginId = value.Id;
     603          }
     604          else
     605          {
     606            this._PluginId = default(long);
     607          }
     608          this.SendPropertyChanged("Plugin");
     609        }
     610      }
     611    }
     612   
     613    public event PropertyChangingEventHandler PropertyChanging;
     614   
     615    public event PropertyChangedEventHandler PropertyChanged;
     616   
     617    protected virtual void SendPropertyChanging()
     618    {
     619      if ((this.PropertyChanging != null))
     620      {
     621        this.PropertyChanging(this, emptyChangingEventArgs);
     622      }
     623    }
     624   
     625    protected virtual void SendPropertyChanged(String propertyName)
     626    {
     627      if ((this.PropertyChanged != null))
     628      {
     629        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
     630      }
     631    }
     632  }
     633 
     634  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Product")]
     635  public partial class Product : INotifyPropertyChanging, INotifyPropertyChanged
     636  {
     637   
     638    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
     639   
     640    private long _Id;
     641   
     642    private string _Name;
     643   
     644    private string _Version;
     645   
    536646    #region Extensibility Method Definitions
    537647    partial void OnLoaded();
    … …  
    545655    partial void OnVersionChanged();
    546656    #endregion
    547 
    548     public Product() {
    549       OnCreated();
    550     }
    551 
    552     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_Id", AutoSync = AutoSync.OnInsert, DbType = "BigInt NOT NULL IDENTITY", IsPrimaryKey = true, IsDbGenerated = true)]
    553     public long Id {
    554       get {
    555         return this._Id;
    556       }
    557       set {
    558         if ((this._Id != value)) {
    559           this.OnIdChanging(value);
    560           this.SendPropertyChanging();
    561           this._Id = value;
    562           this.SendPropertyChanged("Id");
    563           this.OnIdChanged();
    564         }
    565       }
    566     }
    567 
    568     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_Name", DbType = "NVarChar(300) NOT NULL", CanBeNull = false)]
    569     public string Name {
    570       get {
    571         return this._Name;
    572       }
    573       set {
    574         if ((this._Name != value)) {
    575           this.OnNameChanging(value);
    576           this.SendPropertyChanging();
    577           this._Name = value;
    578           this.SendPropertyChanged("Name");
    579           this.OnNameChanged();
    580         }
    581       }
    582     }
    583 
    584     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_Version", DbType = "NVarChar(50) NOT NULL", CanBeNull = false)]
    585     public string Version {
    586       get {
    587         return this._Version;
    588       }
    589       set {
    590         if ((this._Version != value)) {
    591           this.OnVersionChanging(value);
    592           this.SendPropertyChanging();
    593           this._Version = value;
    594           this.SendPropertyChanged("Version");
    595           this.OnVersionChanged();
    596         }
    597       }
    598     }
    599 
    600     public event PropertyChangingEventHandler PropertyChanging;
    601 
    602     public event PropertyChangedEventHandler PropertyChanged;
    603 
    604     protected virtual void SendPropertyChanging() {
    605       if ((this.PropertyChanging != null)) {
    606         this.PropertyChanging(this, emptyChangingEventArgs);
    607       }
    608     }
    609 
    610     protected virtual void SendPropertyChanged(String propertyName) {
    611       if ((this.PropertyChanged != null)) {
    612         this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    613       }
    614     }
    615   }
     657   
     658    public Product()
     659    {
     660      OnCreated();
     661    }
     662   
     663    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true)]
     664    public long Id
     665    {
     666      get
     667      {
     668        return this._Id;
     669      }
     670      set
     671      {
     672        if ((this._Id != value))
     673        {
     674          this.OnIdChanging(value);
     675          this.SendPropertyChanging();
     676          this._Id = value;
     677          this.SendPropertyChanged("Id");
     678          this.OnIdChanged();
     679        }
     680      }
     681    }
     682   
     683    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(300) NOT NULL", CanBeNull=false)]
     684    public string Name
     685    {
     686      get
     687      {
     688        return this._Name;
     689      }
     690      set
     691      {
     692        if ((this._Name != value))
     693        {
     694          this.OnNameChanging(value);
     695          this.SendPropertyChanging();
     696          this._Name = value;
     697          this.SendPropertyChanged("Name");
     698          this.OnNameChanged();
     699        }
     700      }
     701    }
     702   
     703    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Version", DbType="NVarChar(50) NOT NULL", CanBeNull=false)]
     704    public string Version
     705    {
     706      get
     707      {
     708        return this._Version;
     709      }
     710      set
     711      {
     712        if ((this._Version != value))
     713        {
     714          this.OnVersionChanging(value);
     715          this.SendPropertyChanging();
     716          this._Version = value;
     717          this.SendPropertyChanged("Version");
     718          this.OnVersionChanged();
     719        }
     720      }
     721    }
     722   
     723    public event PropertyChangingEventHandler PropertyChanging;
     724   
     725    public event PropertyChangedEventHandler PropertyChanged;
     726   
     727    protected virtual void SendPropertyChanging()
     728    {
     729      if ((this.PropertyChanging != null))
     730      {
     731        this.PropertyChanging(this, emptyChangingEventArgs);
     732      }
     733    }
     734   
     735    protected virtual void SendPropertyChanged(String propertyName)
     736    {
     737      if ((this.PropertyChanged != null))
     738      {
     739        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
     740      }
     741    }
     742  }
    616743}
    617744#pragma warning restore 1591

  • trunk/sources/HeuristicLab.Services.Deployment.DataAccess/3.3/HeuristicLab.Services.Deployment.DataAccess-3.3.csproj

    r4065 r4494  
    112112  </ItemGroup>
    113113  <ItemGroup>
    114     <Compile Include="PluginStoreClasses.cs">
    115       <DependentUpon>PluginStoreClasses.dbml</DependentUpon>
    116     </Compile>
    117     <Compile Include="PluginStoreClasses.designer.cs">
     114    <Compile Include="Deployment.designer.cs">
    118115      <AutoGen>True</AutoGen>
    119116      <DesignTime>True</DesignTime>
    120       <DependentUpon>PluginStoreClasses.dbml</DependentUpon>
     117      <DependentUpon>Deployment.dbml</DependentUpon>
    121118    </Compile>
    122119    <Compile Include="Properties\AssemblyInfo.cs" />
    … …  
    128125  </ItemGroup>
    129126  <ItemGroup>
    130     <None Include="PluginStoreClasses.dbml">
    131       <Generator>MSLinqToSQLGenerator</Generator>
    132       <LastGenOutput>PluginStoreClasses.designer.cs</LastGenOutput>
    133       <SubType>Designer</SubType>
    134     </None>
    135   </ItemGroup>
    136   <ItemGroup>
    137127    <Service Include="{3259AA49-8AA1-44D3-9025-A0B520596A8C}" />
    138128  </ItemGroup>
    139129  <ItemGroup>
    140130    <None Include="app.config" />
     131    <None Include="Deployment.dbml">
     132      <Generator>MSLinqToSQLGenerator</Generator>
     133      <LastGenOutput>Deployment.designer.cs</LastGenOutput>
     134      <SubType>Designer</SubType>
     135    </None>
    141136    <None Include="HeuristicLab.snk" />
    142     <None Include="PluginStoreClasses.dbml.layout">
    143       <DependentUpon>PluginStoreClasses.dbml</DependentUpon>
    144     </None>
    145137    <None Include="Properties\AssemblyInfo.frame" />
    146138    <None Include="Properties\Settings.settings">
    … …  
    166158    </BootstrapperPackage>
    167159  </ItemGroup>
     160  <ItemGroup>
     161    <None Include="SQL Scripts\Initialize Deployment Database.sql" />
     162  </ItemGroup>
     163  <ItemGroup>
     164    <None Include="Deployment.dbml.layout">
     165      <DependentUpon>Deployment.dbml</DependentUpon>
     166    </None>
     167  </ItemGroup>
    168168  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
    169169  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.

  • trunk/sources/HeuristicLab.Services.Deployment.DataAccess/3.3/Properties/Settings.Designer.cs

    r4256 r4494  
    2727        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    2828        [global::System.Configuration.SpecialSettingAttribute(global::System.Configuration.SpecialSetting.ConnectionString)]
    29         [global::System.Configuration.DefaultSettingValueAttribute("Server=SERVICES;Database=HeuristicLab.Deployment;Integrated Security=SSPI")]
    30         public string HeuristicLab_PluginStoreConnectionString {
     29        [global::System.Configuration.DefaultSettingValueAttribute("Data Source=.\\SQLEXPRESS;Initial Catalog=HeuristicLab.Deployment;Integrated Secur" +
     30            "ity=SSPI")]
     31        public string HeuristicLab_DeploymentConnectionString {
    3132            get {
    32                 return ((string)(this["HeuristicLab_PluginStoreConnectionString"]));
     33                return ((string)(this["HeuristicLab_DeploymentConnectionString"]));
    3334            }
    3435        }

  • trunk/sources/HeuristicLab.Services.Deployment.DataAccess/3.3/Properties/Settings.settings

    r4256 r4494  
    33  <Profiles />
    44  <Settings>
    5     <Setting Name="HeuristicLab_PluginStoreConnectionString" Type="(Connection string)" Scope="Application">
     5    <Setting Name="HeuristicLab_DeploymentConnectionString" Type="(Connection string)" Scope="Application">
    66      <DesignTimeValue Profile="(Default)">&lt;?xml version="1.0" encoding="utf-16"?&gt;
    77&lt;SerializableConnectionString xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"&gt;
    8   &lt;ConnectionString&gt;Server=SERVICES;Database=HeuristicLab.Deployment;Integrated Security=SSPI&lt;/ConnectionString&gt;
    9   &lt;ProviderName /&gt;
     8  &lt;ConnectionString&gt;Data Source=.\SQLEXPRESS;Initial Catalog=HeuristicLab.Deployment;Integrated Security=SSPI&lt;/ConnectionString&gt;
     9  &lt;ProviderName&gt;System.Data.SqlClient&lt;/ProviderName&gt;
    1010&lt;/SerializableConnectionString&gt;</DesignTimeValue>
    11       <Value Profile="(Default)">Server=SERVICES;Database=HeuristicLab.Deployment;Integrated Security=SSPI</Value>
     11      <Value Profile="(Default)">Data Source=.\SQLEXPRESS;Initial Catalog=HeuristicLab.Deployment;Integrated Security=SSPI</Value>
    1212    </Setting>
    1313  </Settings>

  • trunk/sources/HeuristicLab.Services.Deployment.DataAccess/3.3/SQL Scripts/Initialize Deployment Database.sql

    r4493 r4494  
    11USE [HeuristicLab.Deployment]
    2 GO
    3 /****** Object:  User [DeploymentService]    Script Date: 03/22/2010 15:57:21 ******/
    4 CREATE USER [DeploymentService] FOR LOGIN [SERVDEV\DeploymentService] WITH DEFAULT_SCHEMA=[dbo]
    52GO
    63/****** Object:  Table [dbo].[Plugin]    Script Date: 03/22/2010 15:57:25 ******/

  • trunk/sources/HeuristicLab.Services.Deployment.DataAccess/3.3/app.config

    r4256 r4494  
    11<?xml version="1.0" encoding="utf-8" ?>
    22<configuration>
    3     <configSections>
    4     </configSections>
    5     <connectionStrings>
    6         <add name="HeuristicLab.Services.Deployment.DataAccess.Properties.Settings.HeuristicLab_PluginStoreConnectionString"
    7             connectionString="Server=SERVICES;Database=HeuristicLab.Deployment;Integrated Security=SSPI"
    8             providerName="" />
    9     </connectionStrings>
     3  <configSections>
     4  </configSections>
     5  <connectionStrings>
     6    <add name="HeuristicLab.Services.Deployment.DataAccess.Properties.Settings.HeuristicLab_DeploymentConnectionString"
     7      connectionString="Data Source=.\SQLEXPRESS;Initial Catalog=HeuristicLab.Deployment;Integrated Security=SSPI"
     8      providerName="System.Data.SqlClient" />
     9  </connectionStrings>
    1010</configuration>

  • trunk/sources/HeuristicLab.Services.Deployment/3.3/AdminService.cs

    r4493 r4494  
    2323
    2424namespace HeuristicLab.Services.Deployment {
    25   public class Admin : IAdmin {
    26     #region IAdmin Members
     25  public class AdminService : IAdminService {
     26    #region IAdminService Members
    2727    [PrincipalPermission(SecurityAction.Demand, Role = "Deployment Administrator")]
    2828    public void DeployProduct(ProductDescription product) {

  • trunk/sources/HeuristicLab.Services.Deployment/3.3/App.config

    r4307 r4494  
    11<?xml version="1.0" encoding="utf-8"?>
    22<configuration>
    3   <configSections>
    4   </configSections>
    53  <system.diagnostics>
    64    <!-- for logging. Make sure the IIS application user has write access rights for the output directory -->
    … …  
    4139    </sharedListeners-->
    4240  </system.diagnostics>
     41
    4342  <connectionStrings>
    44     <remove name="LocalSqlServer" />
    45     <add connectionString="Server=SERVICES;Database=HeuristicLab.Deployment;Integrated Security=SSPI" name="HeuristicLab.Services.Deployment.DataAccess.Properties.Settings.HeuristicLab_PluginStoreConnectionString" />
    46     <add name="HeuristicLab.Authentication" connectionString="Initial Catalog=HeuristicLab.Authentication;data source=localhost;Integrated Security=SSPI;" />
     43    <add name="HeuristicLab.Authentication"
     44         connectionString="data source=.\SQLEXPRESS;Integrated Security=SSPI;Initial Catalog=HeuristicLab.Authentication" />
     45    <add name="HeuristicLab.Services.Deployment.DataAccess.Properties.Settings.HeuristicLab_DeploymentConnectionString"
     46         connectionString="Data Source=.\SQLEXPRESS;Integrated Security=SSPI;Initial Catalog=HeuristicLab.Deployment" />
    4747  </connectionStrings>
     48
    4849  <system.webServer>
    4950    <security>
    … …  
    5354    </security>
    5455  </system.webServer>
     56
    5557  <system.web>
    56     <compilation debug="false" />
     58    <compilation debug="true" />
    5759    <httpRuntime maxRequestLength="2097151" />
    5860    <membership defaultProvider="AspNetSqlMembershipProvider">
    5961      <providers>
    6062        <clear />
    61         <add name="AspNetSqlMemberShipProvider" type="System.Web.Security.SqlMembershipProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" connectionStringName="HeuristicLab.Authentication" applicationName="HeuristicLab.Authentication" enablePasswordReset="false" enablePasswordRetrieval="false" passwordFormat="Hashed" requiresQuestionAndAnswer="false" requiresUniqueEmail="false"  minRequiredNonalphanumericCharacters="0" minRequiredPasswordLength="8" />
     63        <add name="AspNetSqlMemberShipProvider" type="System.Web.Security.SqlMembershipProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"
     64             connectionStringName="HeuristicLab.Authentication" applicationName="HeuristicLab.Authentication" enablePasswordReset="false"
     65             enablePasswordRetrieval="false" passwordFormat="Hashed" requiresQuestionAndAnswer="false" requiresUniqueEmail="false"
     66             minRequiredNonalphanumericCharacters="0" minRequiredPasswordLength="8" />
    6267      </providers>
    6368    </membership>
    … …  
    6671      <providers>
    6772        <clear />
    68         <add name="AspNetSqlRoleProvider" connectionStringName="HeuristicLab.Authentication" applicationName="HeuristicLab.Authentication" type="System.Web.Security.SqlRoleProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
     73        <add name="AspNetSqlRoleProvider" type="System.Web.Security.SqlRoleProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"
     74             connectionStringName="HeuristicLab.Authentication" applicationName="HeuristicLab.Authentication" />
    6975      </providers>
    7076    </roleManager>
    7177  </system.web>
     78
    7279  <!-- When deploying the service library project, the content of the config file must be added to the host's
    7380  app.config file. System.Configuration does not support config files for libraries. -->
    … …  
    8693      </mexHttpBinding>
    8794    </bindings>
     95
    8896    <diagnostics performanceCounters="Default">
    8997      <!--<messageLogging logMalformedMessages="false" logMessagesAtTransportLevel="false" />-->
    9098    </diagnostics>
     99
     100    <behaviors>
     101      <endpointBehaviors>
     102        <behavior name="DefaultEndpointBehavior">
     103          <dataContractSerializer maxItemsInObjectGraph="1000000" />
     104        </behavior>
     105      </endpointBehaviors>
     106
     107      <serviceBehaviors>
     108        <behavior name="DefaultServiceBehavior">
     109          <serviceMetadata httpGetEnabled="true" />
     110          <serviceDebug includeExceptionDetailInFaults="true" />
     111          <serviceCredentials>
     112            <serviceCertificate findValue="localhost" storeLocation="LocalMachine"
     113                                storeName="My" x509FindType="FindBySubjectName" />
     114            <userNameAuthentication userNamePasswordValidationMode="MembershipProvider"
     115                                    membershipProviderName="AspNetSqlMembershipProvider" />
     116          </serviceCredentials>
     117          <serviceAuthorization principalPermissionMode="UseAspNetRoles"
     118                                roleProviderName="AspNetSqlRoleProvider" />
     119        </behavior>
     120      </serviceBehaviors>
     121    </behaviors>
     122
    91123    <services>
    92       <service behaviorConfiguration="HeuristicLab.Services.Deployment.UpdateBehavior"
    93         name="HeuristicLab.Services.Deployment.Update">
    94         <endpoint address="" behaviorConfiguration="SerializationBehavior"
    95           binding="wsHttpBinding" bindingConfiguration="DefaultWsHttpBinding"
    96           contract="HeuristicLab.Services.Deployment.IUpdate" />
    97         <endpoint address="mex" binding="mexHttpBinding" bindingConfiguration="DefaultMexHttpBinding"
    98           contract="IMetadataExchange" />
     124      <service name="HeuristicLab.Services.Deployment.UpdateService" behaviorConfiguration="DefaultServiceBehavior">
     125        <endpoint address="mex" binding="mexHttpBinding" bindingConfiguration="DefaultMexHttpBinding" contract="IMetadataExchange" />
     126        <endpoint behaviorConfiguration="DefaultEndpointBehavior" binding="wsHttpBinding" bindingConfiguration="DefaultWsHttpBinding"
     127                  contract="HeuristicLab.Services.Deployment.IUpdateService" />
    99128        <host>
    100129          <baseAddresses>
    101             <add baseAddress="http://localhost:8732/Design_Time_Addresses/Deployment-3.3/Update" />
     130            <add baseAddress="http://localhost:8732/Design_Time_Addresses/Deployment-3.3/UpdateService" />
    102131          </baseAddresses>
    103132        </host>
    104133      </service>
    105       <service behaviorConfiguration="HeuristicLab.Services.Deployment.AdminBehavior"
    106         name="HeuristicLab.Services.Deployment.Admin">
    107         <endpoint address="" behaviorConfiguration="SerializationBehavior"
    108           binding="wsHttpBinding" bindingConfiguration="DefaultWsHttpBinding"
    109           contract="HeuristicLab.Services.Deployment.IAdmin" />
    110         <endpoint address="mex" behaviorConfiguration="SerializationBehavior"
    111           binding="mexHttpBinding" bindingConfiguration="DefaultMexHttpBinding"
    112           contract="IMetadataExchange" />
     134
     135      <service name="HeuristicLab.Services.Deployment.AdminService" behaviorConfiguration="DefaultServiceBehavior">
     136        <endpoint address="mex" binding="mexHttpBinding" bindingConfiguration="DefaultMexHttpBinding" contract="IMetadataExchange" />
     137        <endpoint behaviorConfiguration="DefaultEndpointBehavior" binding="wsHttpBinding" bindingConfiguration="DefaultWsHttpBinding"
     138                  contract="HeuristicLab.Services.Deployment.IAdminService" />
    113139        <host>
    114140          <baseAddresses>
    115             <add baseAddress="http://localhost:8732/Design_Time_Addresses/Deployment-3.3/Admin" />
     141            <add baseAddress="http://localhost:8732/Design_Time_Addresses/Deployment-3.3/AdminService" />
    116142          </baseAddresses>
    117143        </host>
    118144      </service>
    119145    </services>
    120     <behaviors>
    121       <endpointBehaviors>
    122         <behavior name="SerializationBehavior">
    123           <dataContractSerializer maxItemsInObjectGraph="1000000" />
    124         </behavior>
    125       </endpointBehaviors>
    126       <serviceBehaviors>
    127         <behavior name="HeuristicLab.Services.Deployment.UpdateBehavior">
    128           <serviceMetadata httpGetEnabled="true" />
    129           <serviceDebug includeExceptionDetailInFaults="false" />
    130           <serviceCredentials>
    131             <serviceCertificate findValue="localhost" storeLocation="LocalMachine"
    132              storeName="My" x509FindType="FindBySubjectName" />
    133             <userNameAuthentication userNamePasswordValidationMode="MembershipProvider"
    134              membershipProviderName="AspNetSqlMembershipProvider" />
    135           </serviceCredentials>
    136           <serviceAuthorization principalPermissionMode="UseAspNetRoles"
    137            roleProviderName="AspNetSqlRoleProvider" />
    138         </behavior>
    139         <behavior name="HeuristicLab.Services.Deployment.AdminBehavior">
    140           <serviceMetadata httpGetEnabled="true" />
    141           <serviceDebug includeExceptionDetailInFaults="false" />
    142           <serviceCredentials>
    143             <serviceCertificate findValue="localhost" storeLocation="LocalMachine"
    144              storeName="My" x509FindType="FindBySubjectName" />
    145             <userNameAuthentication userNamePasswordValidationMode="MembershipProvider"
    146              membershipProviderName="AspNetSqlMembershipProvider" />
    147           </serviceCredentials>
    148           <serviceAuthorization principalPermissionMode="UseAspNetRoles"
    149            roleProviderName="AspNetSqlRoleProvider" />
    150         </behavior>
    151       </serviceBehaviors>
    152     </behaviors>
    153146  </system.serviceModel>
    154147</configuration>

  • trunk/sources/HeuristicLab.Services.Deployment/3.3/HeuristicLab.Services.Deployment-3.3.csproj

    r4307 r4494  
    9898  </ItemGroup>
    9999  <ItemGroup>
    100     <Compile Include="Admin.cs" />
    101     <Compile Include="IAdmin.cs" />
    102     <Compile Include="IUpdate.cs" />
     100    <Compile Include="AdminService.cs" />
     101    <Compile Include="IAdminService.cs" />
     102    <Compile Include="IUpdateService.cs" />
    103103    <Compile Include="PluginDescription.cs" />
    104104    <Compile Include="PluginStore.cs" />
    … …  
    110110      <DependentUpon>Settings.settings</DependentUpon>
    111111    </Compile>
    112     <Compile Include="Update.cs" />
     112    <Compile Include="UpdateService.cs" />
    113113  </ItemGroup>
    114114  <ItemGroup>

  • trunk/sources/HeuristicLab.Services.Deployment/3.3/IAdminService.cs

    r4493 r4494  
    2020#endregion
    2121
    22 using System;
    23 using System.Collections.Generic;
    24 using System.Linq;
    25 using System.Runtime.Serialization;
    2622using System.ServiceModel;
    27 using System.Text;
    28 using HeuristicLab.Services.Deployment.DataAccess;
    2923
    3024namespace HeuristicLab.Services.Deployment {
    3125  [ServiceContract]
    32   public interface IAdmin {
     26  public interface IAdminService {
    3327    [OperationContract]
    3428    void DeployProduct(ProductDescription product);

  • trunk/sources/HeuristicLab.Services.Deployment/3.3/IUpdateService.cs

    r4493 r4494  
    2020#endregion
    2121
    22 using System;
    2322using System.Collections.Generic;
    24 using System.Linq;
    25 using System.Runtime.Serialization;
    2623using System.ServiceModel;
    27 using System.Text;
    28 using HeuristicLab.Services.Deployment.DataAccess;
    2924
    3025namespace HeuristicLab.Services.Deployment {
    3126  [ServiceContract]
    32   public interface IUpdate {
     27  public interface IUpdateService {
    3328    [OperationContract]
    3429    byte[] GetPlugin(PluginDescription description);

  • trunk/sources/HeuristicLab.Services.Deployment/3.3/PluginStore.cs

    r3612 r4494  
    2222using System;
    2323using System.Collections.Generic;
     24using System.Data.SqlClient;
    2425using System.Linq;
    25 using System.Text;
    26 using System.Data.Common;
    2726using System.Transactions;
    28 using System.Data.SqlClient;
    2927using HeuristicLab.Services.Deployment.DataAccess;
    3028
    … …  
    3836    public IEnumerable<ProductDescription> Products {
    3937      get {
    40         using (var ctx = new PluginStoreClassesDataContext()) {
     38        using (var ctx = new DeploymentDataContext()) {
    4139          return (from p in ctx.Products
    4240                  let plugins = from pair in ctx.ProductPlugins
    … …  
    5250    public IEnumerable<PluginDescription> Plugins {
    5351      get {
    54         using (var ctx = new PluginStoreClassesDataContext()) {
     52        using (var ctx = new DeploymentDataContext()) {
    5553          return (from plugin in ctx.Plugins
    5654                  select MakePluginDescription(ctx, plugin)).ToList();
    … …  
    6058
    6159    public byte[] PluginFile(PluginDescription pluginDescription) {
    62       using (var ctx = new PluginStoreClassesDataContext()) {
     60      using (var ctx = new DeploymentDataContext()) {
    6361        return GetExistingPlugin(ctx, pluginDescription.Name, pluginDescription.Version).PluginPackage.Data.ToArray();
    6462      }
    … …  
    6664
    6765    public void Persist(PluginDescription pluginDescription, byte[] pluginPackage) {
    68       using (var ctx = new PluginStoreClassesDataContext()) {
     66      using (var ctx = new DeploymentDataContext()) {
    6967        try {
    7068          using (var transaction = new TransactionScope()) {
    … …  
    9189
    9290    public void Persist(ProductDescription productDescription) {
    93       using (var ctx = new PluginStoreClassesDataContext()) {
     91      using (var ctx = new DeploymentDataContext()) {
    9492        try {
    9593          using (var transaction = new TransactionScope()) {
    … …  
    112110    }
    113111    public void Delete(ProductDescription productDescription) {
    114       using (var ctx = new PluginStoreClassesDataContext()) {
     112      using (var ctx = new DeploymentDataContext()) {
    115113        try {
    116114          using (var transaction = new TransactionScope()) {
    … …  
    136134
    137135    #region insert/update/delete product
    138     private void InsertOrUpdateProduct(PluginStoreClassesDataContext ctx, ProductDescription product) {
     136    private void InsertOrUpdateProduct(DeploymentDataContext ctx, ProductDescription product) {
    139137      var productEntity = (from p in ctx.Products
    140138                           where p.Name == product.Name
    … …  
    158156    }
    159157
    160     private void DeleteProductPlugins(PluginStoreClassesDataContext ctx, Product productEntity) {
     158    private void DeleteProductPlugins(DeploymentDataContext ctx, Product productEntity) {
    161159      var oldPlugins = (from p in ctx.ProductPlugins
    162160                        where p.ProductId == productEntity.Id
    … …  
    168166
    169167    #region insert/update plugins
    170     private Plugin InsertOrUpdatePlugin(PluginStoreClassesDataContext ctx, PluginDescription pluginDescription) {
     168    private Plugin InsertOrUpdatePlugin(DeploymentDataContext ctx, PluginDescription pluginDescription) {
    171169      var pluginEntity = (from p in ctx.Plugins
    172170                          where p.Name == pluginDescription.Name
    … …  
    183181    }
    184182
    185     private void UpdatePlugin(PluginStoreClassesDataContext ctx, Plugin pluginEntity, PluginDescription pluginDescription) {
     183    private void UpdatePlugin(DeploymentDataContext ctx, Plugin pluginEntity, PluginDescription pluginDescription) {
    186184      // update plugin data
    187185      pluginEntity.License = pluginDescription.LicenseText;
    … …  
    205203
    206204
    207     private void DeleteOldDependencies(PluginStoreClassesDataContext ctx, Plugin pluginEntity) {
     205    private void DeleteOldDependencies(DeploymentDataContext ctx, Plugin pluginEntity) {
    208206      var oldDependencies = (from dep in ctx.Dependencies
    209207                             where dep.PluginId == pluginEntity.Id
    … …  
    216214
    217215    #region product <-> productDescription transformation
    218     private ProductDescription MakeProductDescription(PluginStoreClassesDataContext ctx, Product p, IEnumerable<Plugin> plugins) {
     216    private ProductDescription MakeProductDescription(DeploymentDataContext ctx, Product p, IEnumerable<Plugin> plugins) {
    219217      var desc = new ProductDescription(p.Name, new Version(p.Version), from plugin in plugins
    220218                                                                        select MakePluginDescription(ctx, plugin));
    … …  
    232230    // cache for plugin descriptions
    233231    private Dictionary<long, PluginDescription> pluginDescriptions = new Dictionary<long, PluginDescription>();
    234     private PluginDescription MakePluginDescription(PluginStoreClassesDataContext ctx, Plugin plugin) {
     232    private PluginDescription MakePluginDescription(DeploymentDataContext ctx, Plugin plugin) {
    235233      if (!pluginDescriptions.ContainsKey(plugin.Id)) {
    236234        // no cached description -> create new
    … …  
    267265
    268266    #region helper queries
    269     private Plugin GetExistingPlugin(PluginStoreClassesDataContext ctx, string name, Version version) {
     267    private Plugin GetExistingPlugin(DeploymentDataContext ctx, string name, Version version) {
    270268      return (from p in ctx.Plugins
    271269              where p.Name == name
    … …  
    274272    }
    275273
    276     private Product GetExistingProduct(PluginStoreClassesDataContext ctx, string name, Version version) {
     274    private Product GetExistingProduct(DeploymentDataContext ctx, string name, Version version) {
    277275      return (from p in ctx.Products
    278276              where p.Name == name
    … …  
    281279    }
    282280
    283     private IEnumerable<Plugin> GetDependencies(PluginStoreClassesDataContext ctx, Plugin plugin) {
     281    private IEnumerable<Plugin> GetDependencies(DeploymentDataContext ctx, Plugin plugin) {
    284282      return from pair in ctx.Dependencies
    285283             from dependency in ctx.Plugins

  • trunk/sources/HeuristicLab.Services.Deployment/3.3/UpdateService.cs

    r4493 r4494  
    2020#endregion
    2121
    22 using System;
    2322using System.Collections.Generic;
    24 using System.Linq;
    25 using System.Runtime.Serialization;
    26 using System.ServiceModel;
    27 using System.Text;
    28 using HeuristicLab.Services.Deployment.DataAccess;
    2923
    3024namespace HeuristicLab.Services.Deployment {
    31   public class Update : IUpdate {
    32     #region IUpdate Members
     25  public class UpdateService : IUpdateService {
     26    #region IUpdateService Members
    3327
    3428    public byte[] GetPlugin(PluginDescription description) {
Note: See TracChangeset for help on using the changeset viewer.