Free cookie consent management tool by TermsFeed Policy Generator

source: branches/HiveProjectManagement/HeuristicLab.Services.Hive.DataAccess/3.3/HiveDataContext.designer.cs @ 15527

Last change on this file since 15527 was 15527, checked in by jzenisek, 5 years ago

#2839

  • updated dbml (removed ResourcePermission and ResourceIds in Job-Table)
  • updated Resource and Project Daos
File size: 162.5 KB
Line 
1#pragma warning disable 1591
2//------------------------------------------------------------------------------
3// <auto-generated>
4//     This code was generated by a tool.
5//     Runtime Version:4.0.30319.42000
6//
7//     Changes to this file may cause incorrect behavior and will be lost if
8//     the code is regenerated.
9// </auto-generated>
10//------------------------------------------------------------------------------
11
12namespace HeuristicLab.Services.Hive.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.Hive")]
26  public partial class HiveDataContext : System.Data.Linq.DataContext
27  {
28   
29    private static System.Data.Linq.Mapping.MappingSource mappingSource = new AttributeMappingSource();
30   
31    #region Extensibility Method Definitions
32    partial void OnCreated();
33    partial void InsertAssignedProjectResource(AssignedProjectResource instance);
34    partial void UpdateAssignedProjectResource(AssignedProjectResource instance);
35    partial void DeleteAssignedProjectResource(AssignedProjectResource instance);
36    partial void InsertPlugin(Plugin instance);
37    partial void UpdatePlugin(Plugin instance);
38    partial void DeletePlugin(Plugin instance);
39    partial void InsertRequiredPlugin(RequiredPlugin instance);
40    partial void UpdateRequiredPlugin(RequiredPlugin instance);
41    partial void DeleteRequiredPlugin(RequiredPlugin instance);
42    partial void InsertResource(Resource instance);
43    partial void UpdateResource(Resource instance);
44    partial void DeleteResource(Resource instance);
45    partial void InsertTask(Task instance);
46    partial void UpdateTask(Task instance);
47    partial void DeleteTask(Task instance);
48    partial void InsertDowntime(Downtime instance);
49    partial void UpdateDowntime(Downtime instance);
50    partial void DeleteDowntime(Downtime instance);
51    partial void InsertJob(Job instance);
52    partial void UpdateJob(Job instance);
53    partial void DeleteJob(Job instance);
54    partial void InsertTaskData(TaskData instance);
55    partial void UpdateTaskData(TaskData instance);
56    partial void DeleteTaskData(TaskData instance);
57    partial void InsertPluginData(PluginData instance);
58    partial void UpdatePluginData(PluginData instance);
59    partial void DeletePluginData(PluginData instance);
60    partial void InsertStateLog(StateLog instance);
61    partial void UpdateStateLog(StateLog instance);
62    partial void DeleteStateLog(StateLog instance);
63    partial void InsertJobPermission(JobPermission instance);
64    partial void UpdateJobPermission(JobPermission instance);
65    partial void DeleteJobPermission(JobPermission instance);
66    partial void InsertLifecycle(Lifecycle instance);
67    partial void UpdateLifecycle(Lifecycle instance);
68    partial void DeleteLifecycle(Lifecycle instance);
69    partial void InsertUserPriority(UserPriority instance);
70    partial void UpdateUserPriority(UserPriority instance);
71    partial void DeleteUserPriority(UserPriority instance);
72    partial void InsertDimClient(DimClient instance);
73    partial void UpdateDimClient(DimClient instance);
74    partial void DeleteDimClient(DimClient instance);
75    partial void InsertFactTask(FactTask instance);
76    partial void UpdateFactTask(FactTask instance);
77    partial void DeleteFactTask(FactTask instance);
78    partial void InsertDimJob(DimJob instance);
79    partial void UpdateDimJob(DimJob instance);
80    partial void DeleteDimJob(DimJob instance);
81    partial void InsertDimTime(DimTime instance);
82    partial void UpdateDimTime(DimTime instance);
83    partial void DeleteDimTime(DimTime instance);
84    partial void InsertDimUser(DimUser instance);
85    partial void UpdateDimUser(DimUser instance);
86    partial void DeleteDimUser(DimUser instance);
87    partial void InsertFactClientInfo(FactClientInfo instance);
88    partial void UpdateFactClientInfo(FactClientInfo instance);
89    partial void DeleteFactClientInfo(FactClientInfo instance);
90    partial void InsertProject(Project instance);
91    partial void UpdateProject(Project instance);
92    partial void DeleteProject(Project instance);
93    partial void InsertProjectPermission(ProjectPermission instance);
94    partial void UpdateProjectPermission(ProjectPermission instance);
95    partial void DeleteProjectPermission(ProjectPermission instance);
96    partial void InsertAssignedTaskResource(AssignedTaskResource instance);
97    partial void UpdateAssignedTaskResource(AssignedTaskResource instance);
98    partial void DeleteAssignedTaskResource(AssignedTaskResource instance);
99    #endregion
100   
101    public HiveDataContext(string connection) :
102        base(connection, mappingSource)
103    {
104      OnCreated();
105    }
106   
107    public HiveDataContext(System.Data.IDbConnection connection) :
108        base(connection, mappingSource)
109    {
110      OnCreated();
111    }
112   
113    public HiveDataContext(string connection, System.Data.Linq.Mapping.MappingSource mappingSource) :
114        base(connection, mappingSource)
115    {
116      OnCreated();
117    }
118   
119    public HiveDataContext(System.Data.IDbConnection connection, System.Data.Linq.Mapping.MappingSource mappingSource) :
120        base(connection, mappingSource)
121    {
122      OnCreated();
123    }
124   
125    public System.Data.Linq.Table<AssignedProjectResource> AssignedProjectResources
126    {
127      get
128      {
129        return this.GetTable<AssignedProjectResource>();
130      }
131    }
132   
133    public System.Data.Linq.Table<Plugin> Plugins
134    {
135      get
136      {
137        return this.GetTable<Plugin>();
138      }
139    }
140   
141    public System.Data.Linq.Table<RequiredPlugin> RequiredPlugins
142    {
143      get
144      {
145        return this.GetTable<RequiredPlugin>();
146      }
147    }
148   
149    public System.Data.Linq.Table<Resource> Resources
150    {
151      get
152      {
153        return this.GetTable<Resource>();
154      }
155    }
156   
157    public System.Data.Linq.Table<Task> Tasks
158    {
159      get
160      {
161        return this.GetTable<Task>();
162      }
163    }
164   
165    public System.Data.Linq.Table<Downtime> Downtimes
166    {
167      get
168      {
169        return this.GetTable<Downtime>();
170      }
171    }
172   
173    public System.Data.Linq.Table<Job> Jobs
174    {
175      get
176      {
177        return this.GetTable<Job>();
178      }
179    }
180   
181    public System.Data.Linq.Table<TaskData> TaskDatas
182    {
183      get
184      {
185        return this.GetTable<TaskData>();
186      }
187    }
188   
189    public System.Data.Linq.Table<PluginData> PluginDatas
190    {
191      get
192      {
193        return this.GetTable<PluginData>();
194      }
195    }
196   
197    public System.Data.Linq.Table<StateLog> StateLogs
198    {
199      get
200      {
201        return this.GetTable<StateLog>();
202      }
203    }
204   
205    public System.Data.Linq.Table<JobPermission> JobPermissions
206    {
207      get
208      {
209        return this.GetTable<JobPermission>();
210      }
211    }
212   
213    public System.Data.Linq.Table<Lifecycle> Lifecycles
214    {
215      get
216      {
217        return this.GetTable<Lifecycle>();
218      }
219    }
220   
221    public System.Data.Linq.Table<UserPriority> UserPriorities
222    {
223      get
224      {
225        return this.GetTable<UserPriority>();
226      }
227    }
228   
229    public System.Data.Linq.Table<DimClient> DimClients
230    {
231      get
232      {
233        return this.GetTable<DimClient>();
234      }
235    }
236   
237    public System.Data.Linq.Table<FactTask> FactTasks
238    {
239      get
240      {
241        return this.GetTable<FactTask>();
242      }
243    }
244   
245    public System.Data.Linq.Table<DimJob> DimJobs
246    {
247      get
248      {
249        return this.GetTable<DimJob>();
250      }
251    }
252   
253    public System.Data.Linq.Table<DimTime> DimTimes
254    {
255      get
256      {
257        return this.GetTable<DimTime>();
258      }
259    }
260   
261    public System.Data.Linq.Table<DimUser> DimUsers
262    {
263      get
264      {
265        return this.GetTable<DimUser>();
266      }
267    }
268   
269    public System.Data.Linq.Table<FactClientInfo> FactClientInfos
270    {
271      get
272      {
273        return this.GetTable<FactClientInfo>();
274      }
275    }
276   
277    public System.Data.Linq.Table<Project> Projects
278    {
279      get
280      {
281        return this.GetTable<Project>();
282      }
283    }
284   
285    public System.Data.Linq.Table<ProjectPermission> ProjectPermissions
286    {
287      get
288      {
289        return this.GetTable<ProjectPermission>();
290      }
291    }
292   
293    public System.Data.Linq.Table<AssignedTaskResource> AssignedTaskResources
294    {
295      get
296      {
297        return this.GetTable<AssignedTaskResource>();
298      }
299    }
300  }
301 
302  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.AssignedProjectResource")]
303  public partial class AssignedProjectResource : INotifyPropertyChanging, INotifyPropertyChanged
304  {
305   
306    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
307   
308    private System.Guid _ResourceId;
309   
310    private System.Guid _JobId;
311   
312    private EntityRef<Resource> _Resource;
313   
314    private EntityRef<Project> _Project;
315   
316    #region Extensibility Method Definitions
317    partial void OnLoaded();
318    partial void OnValidate(System.Data.Linq.ChangeAction action);
319    partial void OnCreated();
320    partial void OnResourceIdChanging(System.Guid value);
321    partial void OnResourceIdChanged();
322    partial void OnProjectIdChanging(System.Guid value);
323    partial void OnProjectIdChanged();
324    #endregion
325   
326    public AssignedProjectResource()
327    {
328      this._Resource = default(EntityRef<Resource>);
329      this._Project = default(EntityRef<Project>);
330      OnCreated();
331    }
332   
333    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
334    public System.Guid ResourceId
335    {
336      get
337      {
338        return this._ResourceId;
339      }
340      set
341      {
342        if ((this._ResourceId != value))
343        {
344          if (this._Resource.HasLoadedOrAssignedValue)
345          {
346            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
347          }
348          this.OnResourceIdChanging(value);
349          this.SendPropertyChanging();
350          this._ResourceId = value;
351          this.SendPropertyChanged("ResourceId");
352          this.OnResourceIdChanged();
353        }
354      }
355    }
356   
357    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
358    public System.Guid ProjectId
359    {
360      get
361      {
362        return this._JobId;
363      }
364      set
365      {
366        if ((this._JobId != value))
367        {
368          if (this._Project.HasLoadedOrAssignedValue)
369          {
370            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
371          }
372          this.OnProjectIdChanging(value);
373          this.SendPropertyChanging();
374          this._JobId = value;
375          this.SendPropertyChanged("ProjectId");
376          this.OnProjectIdChanged();
377        }
378      }
379    }
380   
381    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_AssignedProjectResource", Storage="_Resource", ThisKey="ResourceId", OtherKey="ResourceId", IsForeignKey=true, DeleteRule="CASCADE")]
382    public Resource Resource
383    {
384      get
385      {
386        return this._Resource.Entity;
387      }
388      set
389      {
390        Resource previousValue = this._Resource.Entity;
391        if (((previousValue != value)
392              || (this._Resource.HasLoadedOrAssignedValue == false)))
393        {
394          this.SendPropertyChanging();
395          if ((previousValue != null))
396          {
397            this._Resource.Entity = null;
398            previousValue.AssignedProjectResources.Remove(this);
399          }
400          this._Resource.Entity = value;
401          if ((value != null))
402          {
403            value.AssignedProjectResources.Add(this);
404            this._ResourceId = value.ResourceId;
405          }
406          else
407          {
408            this._ResourceId = default(System.Guid);
409          }
410          this.SendPropertyChanged("Resource");
411        }
412      }
413    }
414   
415    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Project_AssignedProjectResource", Storage="_Project", ThisKey="ProjectId", OtherKey="ProjectId", IsForeignKey=true, DeleteRule="CASCADE")]
416    public Project Project
417    {
418      get
419      {
420        return this._Project.Entity;
421      }
422      set
423      {
424        Project previousValue = this._Project.Entity;
425        if (((previousValue != value)
426              || (this._Project.HasLoadedOrAssignedValue == false)))
427        {
428          this.SendPropertyChanging();
429          if ((previousValue != null))
430          {
431            this._Project.Entity = null;
432            previousValue.AssignedProjectResources.Remove(this);
433          }
434          this._Project.Entity = value;
435          if ((value != null))
436          {
437            value.AssignedProjectResources.Add(this);
438            this._JobId = value.ProjectId;
439          }
440          else
441          {
442            this._JobId = default(System.Guid);
443          }
444          this.SendPropertyChanged("Project");
445        }
446      }
447    }
448   
449    public event PropertyChangingEventHandler PropertyChanging;
450   
451    public event PropertyChangedEventHandler PropertyChanged;
452   
453    protected virtual void SendPropertyChanging()
454    {
455      if ((this.PropertyChanging != null))
456      {
457        this.PropertyChanging(this, emptyChangingEventArgs);
458      }
459    }
460   
461    protected virtual void SendPropertyChanged(String propertyName)
462    {
463      if ((this.PropertyChanged != null))
464      {
465        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
466      }
467    }
468  }
469 
470  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Plugin")]
471  public partial class Plugin : INotifyPropertyChanging, INotifyPropertyChanged
472  {
473   
474    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
475   
476    private System.Guid _PluginId;
477   
478    private string _Name;
479   
480    private string _Version;
481   
482    private System.Guid _UserId;
483   
484    private System.DateTime _DateCreated;
485   
486    private byte[] _Hash;
487   
488    private EntitySet<RequiredPlugin> _RequiredPlugins;
489   
490    private EntitySet<PluginData> _PluginData;
491   
492    #region Extensibility Method Definitions
493    partial void OnLoaded();
494    partial void OnValidate(System.Data.Linq.ChangeAction action);
495    partial void OnCreated();
496    partial void OnPluginIdChanging(System.Guid value);
497    partial void OnPluginIdChanged();
498    partial void OnNameChanging(string value);
499    partial void OnNameChanged();
500    partial void OnVersionChanging(string value);
501    partial void OnVersionChanged();
502    partial void OnUserIdChanging(System.Guid value);
503    partial void OnUserIdChanged();
504    partial void OnDateCreatedChanging(System.DateTime value);
505    partial void OnDateCreatedChanged();
506    partial void OnHashChanging(byte[] value);
507    partial void OnHashChanged();
508    #endregion
509   
510    public Plugin()
511    {
512      this._RequiredPlugins = new EntitySet<RequiredPlugin>(new Action<RequiredPlugin>(this.attach_RequiredPlugins), new Action<RequiredPlugin>(this.detach_RequiredPlugins));
513      this._PluginData = new EntitySet<PluginData>(new Action<PluginData>(this.attach_PluginData), new Action<PluginData>(this.detach_PluginData));
514      OnCreated();
515    }
516   
517    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
518    public System.Guid PluginId
519    {
520      get
521      {
522        return this._PluginId;
523      }
524      set
525      {
526        if ((this._PluginId != value))
527        {
528          this.OnPluginIdChanging(value);
529          this.SendPropertyChanging();
530          this._PluginId = value;
531          this.SendPropertyChanged("PluginId");
532          this.OnPluginIdChanged();
533        }
534      }
535    }
536   
537    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX)", CanBeNull=false)]
538    public string Name
539    {
540      get
541      {
542        return this._Name;
543      }
544      set
545      {
546        if ((this._Name != value))
547        {
548          this.OnNameChanging(value);
549          this.SendPropertyChanging();
550          this._Name = value;
551          this.SendPropertyChanged("Name");
552          this.OnNameChanged();
553        }
554      }
555    }
556   
557    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Version", DbType="VarChar(MAX)", CanBeNull=false)]
558    public string Version
559    {
560      get
561      {
562        return this._Version;
563      }
564      set
565      {
566        if ((this._Version != value))
567        {
568          this.OnVersionChanging(value);
569          this.SendPropertyChanging();
570          this._Version = value;
571          this.SendPropertyChanged("Version");
572          this.OnVersionChanged();
573        }
574      }
575    }
576   
577    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier")]
578    public System.Guid UserId
579    {
580      get
581      {
582        return this._UserId;
583      }
584      set
585      {
586        if ((this._UserId != value))
587        {
588          this.OnUserIdChanging(value);
589          this.SendPropertyChanging();
590          this._UserId = value;
591          this.SendPropertyChanged("UserId");
592          this.OnUserIdChanged();
593        }
594      }
595    }
596   
597    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateCreated", DbType="DateTime")]
598    public System.DateTime DateCreated
599    {
600      get
601      {
602        return this._DateCreated;
603      }
604      set
605      {
606        if ((this._DateCreated != value))
607        {
608          this.OnDateCreatedChanging(value);
609          this.SendPropertyChanging();
610          this._DateCreated = value;
611          this.SendPropertyChanged("DateCreated");
612          this.OnDateCreatedChanged();
613        }
614      }
615    }
616   
617    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Hash", DbType="VarBinary(20) NOT NULL", CanBeNull=false)]
618    public byte[] Hash
619    {
620      get
621      {
622        return this._Hash;
623      }
624      set
625      {
626        if ((this._Hash != value))
627        {
628          this.OnHashChanging(value);
629          this.SendPropertyChanging();
630          this._Hash = value;
631          this.SendPropertyChanged("Hash");
632          this.OnHashChanged();
633        }
634      }
635    }
636   
637    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Plugin_RequiredPlugin", Storage="_RequiredPlugins", ThisKey="PluginId", OtherKey="PluginId")]
638    public EntitySet<RequiredPlugin> RequiredPlugins
639    {
640      get
641      {
642        return this._RequiredPlugins;
643      }
644      set
645      {
646        this._RequiredPlugins.Assign(value);
647      }
648    }
649   
650    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Plugin_PluginData", Storage="_PluginData", ThisKey="PluginId", OtherKey="PluginId")]
651    public EntitySet<PluginData> PluginData
652    {
653      get
654      {
655        return this._PluginData;
656      }
657      set
658      {
659        this._PluginData.Assign(value);
660      }
661    }
662   
663    public event PropertyChangingEventHandler PropertyChanging;
664   
665    public event PropertyChangedEventHandler PropertyChanged;
666   
667    protected virtual void SendPropertyChanging()
668    {
669      if ((this.PropertyChanging != null))
670      {
671        this.PropertyChanging(this, emptyChangingEventArgs);
672      }
673    }
674   
675    protected virtual void SendPropertyChanged(String propertyName)
676    {
677      if ((this.PropertyChanged != null))
678      {
679        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
680      }
681    }
682   
683    private void attach_RequiredPlugins(RequiredPlugin entity)
684    {
685      this.SendPropertyChanging();
686      entity.Plugin = this;
687    }
688   
689    private void detach_RequiredPlugins(RequiredPlugin entity)
690    {
691      this.SendPropertyChanging();
692      entity.Plugin = null;
693    }
694   
695    private void attach_PluginData(PluginData entity)
696    {
697      this.SendPropertyChanging();
698      entity.Plugin = this;
699    }
700   
701    private void detach_PluginData(PluginData entity)
702    {
703      this.SendPropertyChanging();
704      entity.Plugin = null;
705    }
706  }
707 
708  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.RequiredPlugins")]
709  public partial class RequiredPlugin : INotifyPropertyChanging, INotifyPropertyChanged
710  {
711   
712    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
713   
714    private System.Guid _RequiredPluginId;
715   
716    private System.Guid _JobId;
717   
718    private System.Guid _PluginId;
719   
720    private EntityRef<Plugin> _PluginInfo;
721   
722    private EntityRef<Task> _Job;
723   
724    #region Extensibility Method Definitions
725    partial void OnLoaded();
726    partial void OnValidate(System.Data.Linq.ChangeAction action);
727    partial void OnCreated();
728    partial void OnRequiredPluginIdChanging(System.Guid value);
729    partial void OnRequiredPluginIdChanged();
730    partial void OnTaskIdChanging(System.Guid value);
731    partial void OnTaskIdChanged();
732    partial void OnPluginIdChanging(System.Guid value);
733    partial void OnPluginIdChanged();
734    #endregion
735   
736    public RequiredPlugin()
737    {
738      this._PluginInfo = default(EntityRef<Plugin>);
739      this._Job = default(EntityRef<Task>);
740      OnCreated();
741    }
742   
743    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_RequiredPluginId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
744    public System.Guid RequiredPluginId
745    {
746      get
747      {
748        return this._RequiredPluginId;
749      }
750      set
751      {
752        if ((this._RequiredPluginId != value))
753        {
754          this.OnRequiredPluginIdChanging(value);
755          this.SendPropertyChanging();
756          this._RequiredPluginId = value;
757          this.SendPropertyChanged("RequiredPluginId");
758          this.OnRequiredPluginIdChanged();
759        }
760      }
761    }
762   
763    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL")]
764    public System.Guid TaskId
765    {
766      get
767      {
768        return this._JobId;
769      }
770      set
771      {
772        if ((this._JobId != value))
773        {
774          if (this._Job.HasLoadedOrAssignedValue)
775          {
776            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
777          }
778          this.OnTaskIdChanging(value);
779          this.SendPropertyChanging();
780          this._JobId = value;
781          this.SendPropertyChanged("TaskId");
782          this.OnTaskIdChanged();
783        }
784      }
785    }
786   
787    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginId", DbType="UniqueIdentifier NOT NULL")]
788    public System.Guid PluginId
789    {
790      get
791      {
792        return this._PluginId;
793      }
794      set
795      {
796        if ((this._PluginId != value))
797        {
798          if (this._PluginInfo.HasLoadedOrAssignedValue)
799          {
800            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
801          }
802          this.OnPluginIdChanging(value);
803          this.SendPropertyChanging();
804          this._PluginId = value;
805          this.SendPropertyChanged("PluginId");
806          this.OnPluginIdChanged();
807        }
808      }
809    }
810   
811    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Plugin_RequiredPlugin", Storage="_PluginInfo", ThisKey="PluginId", OtherKey="PluginId", IsForeignKey=true, DeleteRule="CASCADE")]
812    public Plugin Plugin
813    {
814      get
815      {
816        return this._PluginInfo.Entity;
817      }
818      set
819      {
820        Plugin previousValue = this._PluginInfo.Entity;
821        if (((previousValue != value)
822              || (this._PluginInfo.HasLoadedOrAssignedValue == false)))
823        {
824          this.SendPropertyChanging();
825          if ((previousValue != null))
826          {
827            this._PluginInfo.Entity = null;
828            previousValue.RequiredPlugins.Remove(this);
829          }
830          this._PluginInfo.Entity = value;
831          if ((value != null))
832          {
833            value.RequiredPlugins.Add(this);
834            this._PluginId = value.PluginId;
835          }
836          else
837          {
838            this._PluginId = default(System.Guid);
839          }
840          this.SendPropertyChanged("Plugin");
841        }
842      }
843    }
844   
845    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_RequiredPlugin", Storage="_Job", ThisKey="TaskId", OtherKey="TaskId", IsForeignKey=true)]
846    public Task Task
847    {
848      get
849      {
850        return this._Job.Entity;
851      }
852      set
853      {
854        Task previousValue = this._Job.Entity;
855        if (((previousValue != value)
856              || (this._Job.HasLoadedOrAssignedValue == false)))
857        {
858          this.SendPropertyChanging();
859          if ((previousValue != null))
860          {
861            this._Job.Entity = null;
862            previousValue.RequiredPlugins.Remove(this);
863          }
864          this._Job.Entity = value;
865          if ((value != null))
866          {
867            value.RequiredPlugins.Add(this);
868            this._JobId = value.TaskId;
869          }
870          else
871          {
872            this._JobId = default(System.Guid);
873          }
874          this.SendPropertyChanged("Task");
875        }
876      }
877    }
878   
879    public event PropertyChangingEventHandler PropertyChanging;
880   
881    public event PropertyChangedEventHandler PropertyChanged;
882   
883    protected virtual void SendPropertyChanging()
884    {
885      if ((this.PropertyChanging != null))
886      {
887        this.PropertyChanging(this, emptyChangingEventArgs);
888      }
889    }
890   
891    protected virtual void SendPropertyChanged(String propertyName)
892    {
893      if ((this.PropertyChanged != null))
894      {
895        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
896      }
897    }
898  }
899 
900  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Resource")]
901  [global::System.Data.Linq.Mapping.InheritanceMappingAttribute(Code="RESOURCE", Type=typeof(Resource))]
902  [global::System.Data.Linq.Mapping.InheritanceMappingAttribute(Code="Slave", Type=typeof(Slave), IsDefault=true)]
903  [global::System.Data.Linq.Mapping.InheritanceMappingAttribute(Code="GROUP", Type=typeof(SlaveGroup))]
904  public partial class Resource : INotifyPropertyChanging, INotifyPropertyChanged
905  {
906   
907    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
908   
909    private System.Guid _ResourceId;
910   
911    private string _Name;
912   
913    private string _ResourceType;
914   
915    private System.Nullable<System.Guid> _ParentResourceId;
916   
917    private int _HbInterval;
918   
919    private System.Nullable<System.Guid> _OwnerUserId;
920   
921    private EntitySet<AssignedProjectResource> _AssignedResources;
922   
923    private EntitySet<Resource> _ChildResources;
924   
925    private EntitySet<Downtime> _UptimeCalendars;
926   
927    private EntitySet<StateLog> _StateLogs;
928   
929    private EntitySet<AssignedTaskResource> _AssignedTaskResources;
930   
931    private EntityRef<Resource> _ParentResource;
932   
933    #region Extensibility Method Definitions
934    partial void OnLoaded();
935    partial void OnValidate(System.Data.Linq.ChangeAction action);
936    partial void OnCreated();
937    partial void OnResourceIdChanging(System.Guid value);
938    partial void OnResourceIdChanged();
939    partial void OnNameChanging(string value);
940    partial void OnNameChanged();
941    partial void OnResourceTypeChanging(string value);
942    partial void OnResourceTypeChanged();
943    partial void OnParentResourceIdChanging(System.Nullable<System.Guid> value);
944    partial void OnParentResourceIdChanged();
945    partial void OnHbIntervalChanging(int value);
946    partial void OnHbIntervalChanged();
947    partial void OnOwnerUserIdChanging(System.Nullable<System.Guid> value);
948    partial void OnOwnerUserIdChanged();
949    #endregion
950   
951    public Resource()
952    {
953      this._AssignedResources = new EntitySet<AssignedProjectResource>(new Action<AssignedProjectResource>(this.attach_AssignedResources), new Action<AssignedProjectResource>(this.detach_AssignedResources));
954      this._ChildResources = new EntitySet<Resource>(new Action<Resource>(this.attach_ChildResources), new Action<Resource>(this.detach_ChildResources));
955      this._UptimeCalendars = new EntitySet<Downtime>(new Action<Downtime>(this.attach_UptimeCalendars), new Action<Downtime>(this.detach_UptimeCalendars));
956      this._StateLogs = new EntitySet<StateLog>(new Action<StateLog>(this.attach_StateLogs), new Action<StateLog>(this.detach_StateLogs));
957      this._AssignedTaskResources = new EntitySet<AssignedTaskResource>(new Action<AssignedTaskResource>(this.attach_AssignedTaskResources), new Action<AssignedTaskResource>(this.detach_AssignedTaskResources));
958      this._ParentResource = default(EntityRef<Resource>);
959      OnCreated();
960    }
961   
962    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
963    public System.Guid ResourceId
964    {
965      get
966      {
967        return this._ResourceId;
968      }
969      set
970      {
971        if ((this._ResourceId != value))
972        {
973          this.OnResourceIdChanging(value);
974          this.SendPropertyChanging();
975          this._ResourceId = value;
976          this.SendPropertyChanged("ResourceId");
977          this.OnResourceIdChanged();
978        }
979      }
980    }
981   
982    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX)", CanBeNull=false)]
983    public string Name
984    {
985      get
986      {
987        return this._Name;
988      }
989      set
990      {
991        if ((this._Name != value))
992        {
993          this.OnNameChanging(value);
994          this.SendPropertyChanging();
995          this._Name = value;
996          this.SendPropertyChanged("Name");
997          this.OnNameChanged();
998        }
999      }
1000    }
1001   
1002    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceType", CanBeNull=false, IsDiscriminator=true)]
1003    public string ResourceType
1004    {
1005      get
1006      {
1007        return this._ResourceType;
1008      }
1009      set
1010      {
1011        if ((this._ResourceType != value))
1012        {
1013          this.OnResourceTypeChanging(value);
1014          this.SendPropertyChanging();
1015          this._ResourceType = value;
1016          this.SendPropertyChanged("ResourceType");
1017          this.OnResourceTypeChanged();
1018        }
1019      }
1020    }
1021   
1022    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ParentResourceId", DbType="UniqueIdentifier")]
1023    public System.Nullable<System.Guid> ParentResourceId
1024    {
1025      get
1026      {
1027        return this._ParentResourceId;
1028      }
1029      set
1030      {
1031        if ((this._ParentResourceId != value))
1032        {
1033          if (this._ParentResource.HasLoadedOrAssignedValue)
1034          {
1035            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
1036          }
1037          this.OnParentResourceIdChanging(value);
1038          this.SendPropertyChanging();
1039          this._ParentResourceId = value;
1040          this.SendPropertyChanged("ParentResourceId");
1041          this.OnParentResourceIdChanged();
1042        }
1043      }
1044    }
1045   
1046    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_HbInterval", DbType="Int")]
1047    public int HbInterval
1048    {
1049      get
1050      {
1051        return this._HbInterval;
1052      }
1053      set
1054      {
1055        if ((this._HbInterval != value))
1056        {
1057          this.OnHbIntervalChanging(value);
1058          this.SendPropertyChanging();
1059          this._HbInterval = value;
1060          this.SendPropertyChanged("HbInterval");
1061          this.OnHbIntervalChanged();
1062        }
1063      }
1064    }
1065   
1066    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_OwnerUserId", DbType="UniqueIdentifier")]
1067    public System.Nullable<System.Guid> OwnerUserId
1068    {
1069      get
1070      {
1071        return this._OwnerUserId;
1072      }
1073      set
1074      {
1075        if ((this._OwnerUserId != value))
1076        {
1077          this.OnOwnerUserIdChanging(value);
1078          this.SendPropertyChanging();
1079          this._OwnerUserId = value;
1080          this.SendPropertyChanged("OwnerUserId");
1081          this.OnOwnerUserIdChanged();
1082        }
1083      }
1084    }
1085   
1086    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_AssignedProjectResource", Storage="_AssignedResources", ThisKey="ResourceId", OtherKey="ResourceId")]
1087    public EntitySet<AssignedProjectResource> AssignedProjectResources
1088    {
1089      get
1090      {
1091        return this._AssignedResources;
1092      }
1093      set
1094      {
1095        this._AssignedResources.Assign(value);
1096      }
1097    }
1098   
1099    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_Resource", Storage="_ChildResources", ThisKey="ResourceId", OtherKey="ParentResourceId")]
1100    public EntitySet<Resource> ChildResources
1101    {
1102      get
1103      {
1104        return this._ChildResources;
1105      }
1106      set
1107      {
1108        this._ChildResources.Assign(value);
1109      }
1110    }
1111   
1112    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_Downtime", Storage="_UptimeCalendars", ThisKey="ResourceId", OtherKey="ResourceId")]
1113    public EntitySet<Downtime> Downtimes
1114    {
1115      get
1116      {
1117        return this._UptimeCalendars;
1118      }
1119      set
1120      {
1121        this._UptimeCalendars.Assign(value);
1122      }
1123    }
1124   
1125    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_StateLog", Storage="_StateLogs", ThisKey="ResourceId", OtherKey="SlaveId")]
1126    public EntitySet<StateLog> StateLogs
1127    {
1128      get
1129      {
1130        return this._StateLogs;
1131      }
1132      set
1133      {
1134        this._StateLogs.Assign(value);
1135      }
1136    }
1137   
1138    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_AssignedTaskResource", Storage="_AssignedTaskResources", ThisKey="ResourceId", OtherKey="ResourceId")]
1139    public EntitySet<AssignedTaskResource> AssignedTaskResources
1140    {
1141      get
1142      {
1143        return this._AssignedTaskResources;
1144      }
1145      set
1146      {
1147        this._AssignedTaskResources.Assign(value);
1148      }
1149    }
1150   
1151    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_Resource", Storage="_ParentResource", ThisKey="ParentResourceId", OtherKey="ResourceId", IsForeignKey=true)]
1152    public Resource ParentResource
1153    {
1154      get
1155      {
1156        return this._ParentResource.Entity;
1157      }
1158      set
1159      {
1160        Resource previousValue = this._ParentResource.Entity;
1161        if (((previousValue != value)
1162              || (this._ParentResource.HasLoadedOrAssignedValue == false)))
1163        {
1164          this.SendPropertyChanging();
1165          if ((previousValue != null))
1166          {
1167            this._ParentResource.Entity = null;
1168            previousValue.ChildResources.Remove(this);
1169          }
1170          this._ParentResource.Entity = value;
1171          if ((value != null))
1172          {
1173            value.ChildResources.Add(this);
1174            this._ParentResourceId = value.ResourceId;
1175          }
1176          else
1177          {
1178            this._ParentResourceId = default(Nullable<System.Guid>);
1179          }
1180          this.SendPropertyChanged("ParentResource");
1181        }
1182      }
1183    }
1184   
1185    public event PropertyChangingEventHandler PropertyChanging;
1186   
1187    public event PropertyChangedEventHandler PropertyChanged;
1188   
1189    protected virtual void SendPropertyChanging()
1190    {
1191      if ((this.PropertyChanging != null))
1192      {
1193        this.PropertyChanging(this, emptyChangingEventArgs);
1194      }
1195    }
1196   
1197    protected virtual void SendPropertyChanged(String propertyName)
1198    {
1199      if ((this.PropertyChanged != null))
1200      {
1201        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1202      }
1203    }
1204   
1205    private void attach_AssignedResources(AssignedProjectResource entity)
1206    {
1207      this.SendPropertyChanging();
1208      entity.Resource = this;
1209    }
1210   
1211    private void detach_AssignedResources(AssignedProjectResource entity)
1212    {
1213      this.SendPropertyChanging();
1214      entity.Resource = null;
1215    }
1216   
1217    private void attach_ChildResources(Resource entity)
1218    {
1219      this.SendPropertyChanging();
1220      entity.ParentResource = this;
1221    }
1222   
1223    private void detach_ChildResources(Resource entity)
1224    {
1225      this.SendPropertyChanging();
1226      entity.ParentResource = null;
1227    }
1228   
1229    private void attach_UptimeCalendars(Downtime entity)
1230    {
1231      this.SendPropertyChanging();
1232      entity.Resource = this;
1233    }
1234   
1235    private void detach_UptimeCalendars(Downtime entity)
1236    {
1237      this.SendPropertyChanging();
1238      entity.Resource = null;
1239    }
1240   
1241    private void attach_StateLogs(StateLog entity)
1242    {
1243      this.SendPropertyChanging();
1244      entity.Resource = this;
1245    }
1246   
1247    private void detach_StateLogs(StateLog entity)
1248    {
1249      this.SendPropertyChanging();
1250      entity.Resource = null;
1251    }
1252   
1253    private void attach_AssignedTaskResources(AssignedTaskResource entity)
1254    {
1255      this.SendPropertyChanging();
1256      entity.Resource = this;
1257    }
1258   
1259    private void detach_AssignedTaskResources(AssignedTaskResource entity)
1260    {
1261      this.SendPropertyChanging();
1262      entity.Resource = null;
1263    }
1264  }
1265 
1266  public partial class Slave : Resource
1267  {
1268   
1269    private System.Nullable<int> _CPUSpeed;
1270   
1271    private System.Nullable<int> _Memory;
1272   
1273    private System.Nullable<System.DateTime> _Login;
1274   
1275    private global::HeuristicLab.Services.Hive.DataAccess.SlaveState _Status;
1276   
1277    private System.Nullable<int> _NumberOfCores;
1278   
1279    private System.Nullable<int> _NumberOfFreeCores;
1280   
1281    private System.Nullable<int> _FreeMemory;
1282   
1283    private bool _IsAllowedToCalculate;
1284   
1285    private global::HeuristicLab.Services.Hive.DataAccess.CpuArchitecture _CpuArchitecture;
1286   
1287    private string _OperatingSystem;
1288   
1289    private System.Nullable<System.DateTime> _LastHeartbeat;
1290   
1291    private double _CpuUtilization;
1292   
1293    private System.Nullable<bool> _IsDisposable;
1294   
1295    #region Extensibility Method Definitions
1296    partial void OnLoaded();
1297    partial void OnValidate(System.Data.Linq.ChangeAction action);
1298    partial void OnCreated();
1299    partial void OnCpuSpeedChanging(System.Nullable<int> value);
1300    partial void OnCpuSpeedChanged();
1301    partial void OnMemoryChanging(System.Nullable<int> value);
1302    partial void OnMemoryChanged();
1303    partial void OnLoginChanging(System.Nullable<System.DateTime> value);
1304    partial void OnLoginChanged();
1305    partial void OnSlaveStateChanging(global::HeuristicLab.Services.Hive.DataAccess.SlaveState value);
1306    partial void OnSlaveStateChanged();
1307    partial void OnCoresChanging(System.Nullable<int> value);
1308    partial void OnCoresChanged();
1309    partial void OnFreeCoresChanging(System.Nullable<int> value);
1310    partial void OnFreeCoresChanged();
1311    partial void OnFreeMemoryChanging(System.Nullable<int> value);
1312    partial void OnFreeMemoryChanged();
1313    partial void OnIsAllowedToCalculateChanging(bool value);
1314    partial void OnIsAllowedToCalculateChanged();
1315    partial void OnCpuArchitectureChanging(global::HeuristicLab.Services.Hive.DataAccess.CpuArchitecture value);
1316    partial void OnCpuArchitectureChanged();
1317    partial void OnOperatingSystemChanging(string value);
1318    partial void OnOperatingSystemChanged();
1319    partial void OnLastHeartbeatChanging(System.Nullable<System.DateTime> value);
1320    partial void OnLastHeartbeatChanged();
1321    partial void OnCpuUtilizationChanging(double value);
1322    partial void OnCpuUtilizationChanged();
1323    partial void OnIsDisposableChanging(System.Nullable<bool> value);
1324    partial void OnIsDisposableChanged();
1325    #endregion
1326   
1327    public Slave()
1328    {
1329      OnCreated();
1330    }
1331   
1332    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CPUSpeed", DbType="Int")]
1333    public System.Nullable<int> CpuSpeed
1334    {
1335      get
1336      {
1337        return this._CPUSpeed;
1338      }
1339      set
1340      {
1341        if ((this._CPUSpeed != value))
1342        {
1343          this.OnCpuSpeedChanging(value);
1344          this.SendPropertyChanging();
1345          this._CPUSpeed = value;
1346          this.SendPropertyChanged("CpuSpeed");
1347          this.OnCpuSpeedChanged();
1348        }
1349      }
1350    }
1351   
1352    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Memory", DbType="Int")]
1353    public System.Nullable<int> Memory
1354    {
1355      get
1356      {
1357        return this._Memory;
1358      }
1359      set
1360      {
1361        if ((this._Memory != value))
1362        {
1363          this.OnMemoryChanging(value);
1364          this.SendPropertyChanging();
1365          this._Memory = value;
1366          this.SendPropertyChanged("Memory");
1367          this.OnMemoryChanged();
1368        }
1369      }
1370    }
1371   
1372    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Login", DbType="DateTime")]
1373    public System.Nullable<System.DateTime> Login
1374    {
1375      get
1376      {
1377        return this._Login;
1378      }
1379      set
1380      {
1381        if ((this._Login != value))
1382        {
1383          this.OnLoginChanging(value);
1384          this.SendPropertyChanging();
1385          this._Login = value;
1386          this.SendPropertyChanged("Login");
1387          this.OnLoginChanged();
1388        }
1389      }
1390    }
1391   
1392    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Status", DbType="VarChar(15)", CanBeNull=true)]
1393    public global::HeuristicLab.Services.Hive.DataAccess.SlaveState SlaveState
1394    {
1395      get
1396      {
1397        return this._Status;
1398      }
1399      set
1400      {
1401        if ((this._Status != value))
1402        {
1403          this.OnSlaveStateChanging(value);
1404          this.SendPropertyChanging();
1405          this._Status = value;
1406          this.SendPropertyChanged("SlaveState");
1407          this.OnSlaveStateChanged();
1408        }
1409      }
1410    }
1411   
1412    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumberOfCores", DbType="Int")]
1413    public System.Nullable<int> Cores
1414    {
1415      get
1416      {
1417        return this._NumberOfCores;
1418      }
1419      set
1420      {
1421        if ((this._NumberOfCores != value))
1422        {
1423          this.OnCoresChanging(value);
1424          this.SendPropertyChanging();
1425          this._NumberOfCores = value;
1426          this.SendPropertyChanged("Cores");
1427          this.OnCoresChanged();
1428        }
1429      }
1430    }
1431   
1432    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumberOfFreeCores", DbType="Int")]
1433    public System.Nullable<int> FreeCores
1434    {
1435      get
1436      {
1437        return this._NumberOfFreeCores;
1438      }
1439      set
1440      {
1441        if ((this._NumberOfFreeCores != value))
1442        {
1443          this.OnFreeCoresChanging(value);
1444          this.SendPropertyChanging();
1445          this._NumberOfFreeCores = value;
1446          this.SendPropertyChanged("FreeCores");
1447          this.OnFreeCoresChanged();
1448        }
1449      }
1450    }
1451   
1452    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_FreeMemory", DbType="Int")]
1453    public System.Nullable<int> FreeMemory
1454    {
1455      get
1456      {
1457        return this._FreeMemory;
1458      }
1459      set
1460      {
1461        if ((this._FreeMemory != value))
1462        {
1463          this.OnFreeMemoryChanging(value);
1464          this.SendPropertyChanging();
1465          this._FreeMemory = value;
1466          this.SendPropertyChanged("FreeMemory");
1467          this.OnFreeMemoryChanged();
1468        }
1469      }
1470    }
1471   
1472    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsAllowedToCalculate", DbType="Bit")]
1473    public bool IsAllowedToCalculate
1474    {
1475      get
1476      {
1477        return this._IsAllowedToCalculate;
1478      }
1479      set
1480      {
1481        if ((this._IsAllowedToCalculate != value))
1482        {
1483          this.OnIsAllowedToCalculateChanging(value);
1484          this.SendPropertyChanging();
1485          this._IsAllowedToCalculate = value;
1486          this.SendPropertyChanged("IsAllowedToCalculate");
1487          this.OnIsAllowedToCalculateChanged();
1488        }
1489      }
1490    }
1491   
1492    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CpuArchitecture", DbType="VarChar(3)", CanBeNull=false)]
1493    public global::HeuristicLab.Services.Hive.DataAccess.CpuArchitecture CpuArchitecture
1494    {
1495      get
1496      {
1497        return this._CpuArchitecture;
1498      }
1499      set
1500      {
1501        if ((this._CpuArchitecture != value))
1502        {
1503          this.OnCpuArchitectureChanging(value);
1504          this.SendPropertyChanging();
1505          this._CpuArchitecture = value;
1506          this.SendPropertyChanged("CpuArchitecture");
1507          this.OnCpuArchitectureChanged();
1508        }
1509      }
1510    }
1511   
1512    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_OperatingSystem", DbType="VarChar(MAX)", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
1513    public string OperatingSystem
1514    {
1515      get
1516      {
1517        return this._OperatingSystem;
1518      }
1519      set
1520      {
1521        if ((this._OperatingSystem != value))
1522        {
1523          this.OnOperatingSystemChanging(value);
1524          this.SendPropertyChanging();
1525          this._OperatingSystem = value;
1526          this.SendPropertyChanged("OperatingSystem");
1527          this.OnOperatingSystemChanged();
1528        }
1529      }
1530    }
1531   
1532    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastHeartbeat", DbType="DateTime")]
1533    public System.Nullable<System.DateTime> LastHeartbeat
1534    {
1535      get
1536      {
1537        return this._LastHeartbeat;
1538      }
1539      set
1540      {
1541        if ((this._LastHeartbeat != value))
1542        {
1543          this.OnLastHeartbeatChanging(value);
1544          this.SendPropertyChanging();
1545          this._LastHeartbeat = value;
1546          this.SendPropertyChanged("LastHeartbeat");
1547          this.OnLastHeartbeatChanged();
1548        }
1549      }
1550    }
1551   
1552    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CpuUtilization", DbType="float")]
1553    public double CpuUtilization
1554    {
1555      get
1556      {
1557        return this._CpuUtilization;
1558      }
1559      set
1560      {
1561        if ((this._CpuUtilization != value))
1562        {
1563          this.OnCpuUtilizationChanging(value);
1564          this.SendPropertyChanging();
1565          this._CpuUtilization = value;
1566          this.SendPropertyChanged("CpuUtilization");
1567          this.OnCpuUtilizationChanged();
1568        }
1569      }
1570    }
1571   
1572    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsDisposable", DbType="Bit")]
1573    public System.Nullable<bool> IsDisposable
1574    {
1575      get
1576      {
1577        return this._IsDisposable;
1578      }
1579      set
1580      {
1581        if ((this._IsDisposable != value))
1582        {
1583          this.OnIsDisposableChanging(value);
1584          this.SendPropertyChanging();
1585          this._IsDisposable = value;
1586          this.SendPropertyChanged("IsDisposable");
1587          this.OnIsDisposableChanged();
1588        }
1589      }
1590    }
1591  }
1592 
1593  public partial class SlaveGroup : Resource
1594  {
1595   
1596    #region Extensibility Method Definitions
1597    partial void OnLoaded();
1598    partial void OnValidate(System.Data.Linq.ChangeAction action);
1599    partial void OnCreated();
1600    #endregion
1601   
1602    public SlaveGroup()
1603    {
1604      OnCreated();
1605    }
1606  }
1607 
1608  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Task")]
1609  public partial class Task : INotifyPropertyChanging, INotifyPropertyChanged
1610  {
1611   
1612    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1613   
1614    private System.Guid _JobId;
1615   
1616    private global::HeuristicLab.Services.Hive.DataAccess.TaskState _State;
1617   
1618    private double _ExecutionTime;
1619   
1620    private System.Nullable<System.DateTime> _LastHeartbeat;
1621   
1622    private System.Nullable<System.Guid> _ParentJobId;
1623   
1624    private int _Priority;
1625   
1626    private int _CoresNeeded;
1627   
1628    private int _MemoryNeeded;
1629   
1630    private bool _IsParentJob;
1631   
1632    private bool _FinishWhenChildJobsFinished;
1633   
1634    private global::HeuristicLab.Services.Hive.DataAccess.Command? _Command;
1635   
1636    private System.Guid _HiveExperimentId;
1637   
1638    private EntitySet<RequiredPlugin> _RequiredPlugins;
1639   
1640    private EntitySet<Task> _Jobs;
1641   
1642    private EntityRef<TaskData> _JobData;
1643   
1644    private EntitySet<StateLog> _StateLogs;
1645   
1646    private EntitySet<AssignedTaskResource> _AssignedTaskResources;
1647   
1648    private EntityRef<Task> _Job1;
1649   
1650    private EntityRef<Job> _HiveExperiment;
1651   
1652    #region Extensibility Method Definitions
1653    partial void OnLoaded();
1654    partial void OnValidate(System.Data.Linq.ChangeAction action);
1655    partial void OnCreated();
1656    partial void OnTaskIdChanging(System.Guid value);
1657    partial void OnTaskIdChanged();
1658    partial void OnStateChanging(global::HeuristicLab.Services.Hive.DataAccess.TaskState value);
1659    partial void OnStateChanged();
1660    partial void OnExecutionTimeMsChanging(double value);
1661    partial void OnExecutionTimeMsChanged();
1662    partial void OnLastHeartbeatChanging(System.Nullable<System.DateTime> value);
1663    partial void OnLastHeartbeatChanged();
1664    partial void OnParentTaskIdChanging(System.Nullable<System.Guid> value);
1665    partial void OnParentTaskIdChanged();
1666    partial void OnPriorityChanging(int value);
1667    partial void OnPriorityChanged();
1668    partial void OnCoresNeededChanging(int value);
1669    partial void OnCoresNeededChanged();
1670    partial void OnMemoryNeededChanging(int value);
1671    partial void OnMemoryNeededChanged();
1672    partial void OnIsParentTaskChanging(bool value);
1673    partial void OnIsParentTaskChanged();
1674    partial void OnFinishWhenChildJobsFinishedChanging(bool value);
1675    partial void OnFinishWhenChildJobsFinishedChanged();
1676    partial void OnCommandChanging(global::HeuristicLab.Services.Hive.DataAccess.Command? value);
1677    partial void OnCommandChanged();
1678    partial void OnJobIdChanging(System.Guid value);
1679    partial void OnJobIdChanged();
1680    #endregion
1681   
1682    public Task()
1683    {
1684      this._RequiredPlugins = new EntitySet<RequiredPlugin>(new Action<RequiredPlugin>(this.attach_RequiredPlugins), new Action<RequiredPlugin>(this.detach_RequiredPlugins));
1685      this._Jobs = new EntitySet<Task>(new Action<Task>(this.attach_Jobs), new Action<Task>(this.detach_Jobs));
1686      this._JobData = default(EntityRef<TaskData>);
1687      this._StateLogs = new EntitySet<StateLog>(new Action<StateLog>(this.attach_StateLogs), new Action<StateLog>(this.detach_StateLogs));
1688      this._AssignedTaskResources = new EntitySet<AssignedTaskResource>(new Action<AssignedTaskResource>(this.attach_AssignedTaskResources), new Action<AssignedTaskResource>(this.detach_AssignedTaskResources));
1689      this._Job1 = default(EntityRef<Task>);
1690      this._HiveExperiment = default(EntityRef<Job>);
1691      OnCreated();
1692    }
1693   
1694    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
1695    public System.Guid TaskId
1696    {
1697      get
1698      {
1699        return this._JobId;
1700      }
1701      set
1702      {
1703        if ((this._JobId != value))
1704        {
1705          this.OnTaskIdChanging(value);
1706          this.SendPropertyChanging();
1707          this._JobId = value;
1708          this.SendPropertyChanged("TaskId");
1709          this.OnTaskIdChanged();
1710        }
1711      }
1712    }
1713   
1714    [global::System.Data.Linq.Mapping.ColumnAttribute(Name="TaskState", Storage="_State", DbType="VarChar(30)", CanBeNull=false)]
1715    public global::HeuristicLab.Services.Hive.DataAccess.TaskState State
1716    {
1717      get
1718      {
1719        return this._State;
1720      }
1721      set
1722      {
1723        if ((this._State != value))
1724        {
1725          this.OnStateChanging(value);
1726          this.SendPropertyChanging();
1727          this._State = value;
1728          this.SendPropertyChanged("State");
1729          this.OnStateChanged();
1730        }
1731      }
1732    }
1733   
1734    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ExecutionTime", DbType="float")]
1735    public double ExecutionTimeMs
1736    {
1737      get
1738      {
1739        return this._ExecutionTime;
1740      }
1741      set
1742      {
1743        if ((this._ExecutionTime != value))
1744        {
1745          this.OnExecutionTimeMsChanging(value);
1746          this.SendPropertyChanging();
1747          this._ExecutionTime = value;
1748          this.SendPropertyChanged("ExecutionTimeMs");
1749          this.OnExecutionTimeMsChanged();
1750        }
1751      }
1752    }
1753   
1754    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastHeartbeat", DbType="DateTime")]
1755    public System.Nullable<System.DateTime> LastHeartbeat
1756    {
1757      get
1758      {
1759        return this._LastHeartbeat;
1760      }
1761      set
1762      {
1763        if ((this._LastHeartbeat != value))
1764        {
1765          this.OnLastHeartbeatChanging(value);
1766          this.SendPropertyChanging();
1767          this._LastHeartbeat = value;
1768          this.SendPropertyChanged("LastHeartbeat");
1769          this.OnLastHeartbeatChanged();
1770        }
1771      }
1772    }
1773   
1774    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ParentJobId", DbType="UniqueIdentifier")]
1775    public System.Nullable<System.Guid> ParentTaskId
1776    {
1777      get
1778      {
1779        return this._ParentJobId;
1780      }
1781      set
1782      {
1783        if ((this._ParentJobId != value))
1784        {
1785          if (this._Job1.HasLoadedOrAssignedValue)
1786          {
1787            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
1788          }
1789          this.OnParentTaskIdChanging(value);
1790          this.SendPropertyChanging();
1791          this._ParentJobId = value;
1792          this.SendPropertyChanged("ParentTaskId");
1793          this.OnParentTaskIdChanged();
1794        }
1795      }
1796    }
1797   
1798    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Priority", DbType="Int NOT NULL")]
1799    public int Priority
1800    {
1801      get
1802      {
1803        return this._Priority;
1804      }
1805      set
1806      {
1807        if ((this._Priority != value))
1808        {
1809          this.OnPriorityChanging(value);
1810          this.SendPropertyChanging();
1811          this._Priority = value;
1812          this.SendPropertyChanged("Priority");
1813          this.OnPriorityChanged();
1814        }
1815      }
1816    }
1817   
1818    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CoresNeeded", DbType="Int NOT NULL")]
1819    public int CoresNeeded
1820    {
1821      get
1822      {
1823        return this._CoresNeeded;
1824      }
1825      set
1826      {
1827        if ((this._CoresNeeded != value))
1828        {
1829          this.OnCoresNeededChanging(value);
1830          this.SendPropertyChanging();
1831          this._CoresNeeded = value;
1832          this.SendPropertyChanged("CoresNeeded");
1833          this.OnCoresNeededChanged();
1834        }
1835      }
1836    }
1837   
1838    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_MemoryNeeded", DbType="Int NOT NULL")]
1839    public int MemoryNeeded
1840    {
1841      get
1842      {
1843        return this._MemoryNeeded;
1844      }
1845      set
1846      {
1847        if ((this._MemoryNeeded != value))
1848        {
1849          this.OnMemoryNeededChanging(value);
1850          this.SendPropertyChanging();
1851          this._MemoryNeeded = value;
1852          this.SendPropertyChanged("MemoryNeeded");
1853          this.OnMemoryNeededChanged();
1854        }
1855      }
1856    }
1857   
1858    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsParentJob", DbType="Bit")]
1859    public bool IsParentTask
1860    {
1861      get
1862      {
1863        return this._IsParentJob;
1864      }
1865      set
1866      {
1867        if ((this._IsParentJob != value))
1868        {
1869          this.OnIsParentTaskChanging(value);
1870          this.SendPropertyChanging();
1871          this._IsParentJob = value;
1872          this.SendPropertyChanged("IsParentTask");
1873          this.OnIsParentTaskChanged();
1874        }
1875      }
1876    }
1877   
1878    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_FinishWhenChildJobsFinished", DbType="Bit")]
1879    public bool FinishWhenChildJobsFinished
1880    {
1881      get
1882      {
1883        return this._FinishWhenChildJobsFinished;
1884      }
1885      set
1886      {
1887        if ((this._FinishWhenChildJobsFinished != value))
1888        {
1889          this.OnFinishWhenChildJobsFinishedChanging(value);
1890          this.SendPropertyChanging();
1891          this._FinishWhenChildJobsFinished = value;
1892          this.SendPropertyChanged("FinishWhenChildJobsFinished");
1893          this.OnFinishWhenChildJobsFinishedChanged();
1894        }
1895      }
1896    }
1897   
1898    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Command", DbType="VarChar(30)", CanBeNull=true)]
1899    public global::HeuristicLab.Services.Hive.DataAccess.Command? Command
1900    {
1901      get
1902      {
1903        return this._Command;
1904      }
1905      set
1906      {
1907        if ((this._Command != value))
1908        {
1909          this.OnCommandChanging(value);
1910          this.SendPropertyChanging();
1911          this._Command = value;
1912          this.SendPropertyChanged("Command");
1913          this.OnCommandChanged();
1914        }
1915      }
1916    }
1917   
1918    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_HiveExperimentId", DbType="UniqueIdentifier NOT NULL")]
1919    public System.Guid JobId
1920    {
1921      get
1922      {
1923        return this._HiveExperimentId;
1924      }
1925      set
1926      {
1927        if ((this._HiveExperimentId != value))
1928        {
1929          if (this._HiveExperiment.HasLoadedOrAssignedValue)
1930          {
1931            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
1932          }
1933          this.OnJobIdChanging(value);
1934          this.SendPropertyChanging();
1935          this._HiveExperimentId = value;
1936          this.SendPropertyChanged("JobId");
1937          this.OnJobIdChanged();
1938        }
1939      }
1940    }
1941   
1942    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_RequiredPlugin", Storage="_RequiredPlugins", ThisKey="TaskId", OtherKey="TaskId")]
1943    public EntitySet<RequiredPlugin> RequiredPlugins
1944    {
1945      get
1946      {
1947        return this._RequiredPlugins;
1948      }
1949      set
1950      {
1951        this._RequiredPlugins.Assign(value);
1952      }
1953    }
1954   
1955    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_Task", Storage="_Jobs", ThisKey="TaskId", OtherKey="ParentTaskId")]
1956    public EntitySet<Task> ChildJobs
1957    {
1958      get
1959      {
1960        return this._Jobs;
1961      }
1962      set
1963      {
1964        this._Jobs.Assign(value);
1965      }
1966    }
1967   
1968    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_TaskData", Storage="_JobData", ThisKey="TaskId", OtherKey="TaskId", IsUnique=true, IsForeignKey=false)]
1969    public TaskData JobData
1970    {
1971      get
1972      {
1973        return this._JobData.Entity;
1974      }
1975      set
1976      {
1977        TaskData previousValue = this._JobData.Entity;
1978        if (((previousValue != value)
1979              || (this._JobData.HasLoadedOrAssignedValue == false)))
1980        {
1981          this.SendPropertyChanging();
1982          if ((previousValue != null))
1983          {
1984            this._JobData.Entity = null;
1985            previousValue.Task = null;
1986          }
1987          this._JobData.Entity = value;
1988          if ((value != null))
1989          {
1990            value.Task = this;
1991          }
1992          this.SendPropertyChanged("JobData");
1993        }
1994      }
1995    }
1996   
1997    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_StateLog", Storage="_StateLogs", ThisKey="TaskId", OtherKey="TaskId")]
1998    public EntitySet<StateLog> StateLogs
1999    {
2000      get
2001      {
2002        return this._StateLogs;
2003      }
2004      set
2005      {
2006        this._StateLogs.Assign(value);
2007      }
2008    }
2009   
2010    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_AssignedTaskResource", Storage="_AssignedTaskResources", ThisKey="TaskId", OtherKey="TaskId")]
2011    public EntitySet<AssignedTaskResource> AssignedTaskResources
2012    {
2013      get
2014      {
2015        return this._AssignedTaskResources;
2016      }
2017      set
2018      {
2019        this._AssignedTaskResources.Assign(value);
2020      }
2021    }
2022   
2023    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_Task", Storage="_Job1", ThisKey="ParentTaskId", OtherKey="TaskId", IsForeignKey=true)]
2024    public Task ParentJob
2025    {
2026      get
2027      {
2028        return this._Job1.Entity;
2029      }
2030      set
2031      {
2032        Task previousValue = this._Job1.Entity;
2033        if (((previousValue != value)
2034              || (this._Job1.HasLoadedOrAssignedValue == false)))
2035        {
2036          this.SendPropertyChanging();
2037          if ((previousValue != null))
2038          {
2039            this._Job1.Entity = null;
2040            previousValue.ChildJobs.Remove(this);
2041          }
2042          this._Job1.Entity = value;
2043          if ((value != null))
2044          {
2045            value.ChildJobs.Add(this);
2046            this._ParentJobId = value.TaskId;
2047          }
2048          else
2049          {
2050            this._ParentJobId = default(Nullable<System.Guid>);
2051          }
2052          this.SendPropertyChanged("ParentJob");
2053        }
2054      }
2055    }
2056   
2057    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_Task", Storage="_HiveExperiment", ThisKey="JobId", OtherKey="JobId", IsForeignKey=true)]
2058    public Job Job
2059    {
2060      get
2061      {
2062        return this._HiveExperiment.Entity;
2063      }
2064      set
2065      {
2066        Job previousValue = this._HiveExperiment.Entity;
2067        if (((previousValue != value)
2068              || (this._HiveExperiment.HasLoadedOrAssignedValue == false)))
2069        {
2070          this.SendPropertyChanging();
2071          if ((previousValue != null))
2072          {
2073            this._HiveExperiment.Entity = null;
2074            previousValue.Tasks.Remove(this);
2075          }
2076          this._HiveExperiment.Entity = value;
2077          if ((value != null))
2078          {
2079            value.Tasks.Add(this);
2080            this._HiveExperimentId = value.JobId;
2081          }
2082          else
2083          {
2084            this._HiveExperimentId = default(System.Guid);
2085          }
2086          this.SendPropertyChanged("Job");
2087        }
2088      }
2089    }
2090   
2091    public event PropertyChangingEventHandler PropertyChanging;
2092   
2093    public event PropertyChangedEventHandler PropertyChanged;
2094   
2095    protected virtual void SendPropertyChanging()
2096    {
2097      if ((this.PropertyChanging != null))
2098      {
2099        this.PropertyChanging(this, emptyChangingEventArgs);
2100      }
2101    }
2102   
2103    protected virtual void SendPropertyChanged(String propertyName)
2104    {
2105      if ((this.PropertyChanged != null))
2106      {
2107        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2108      }
2109    }
2110   
2111    private void attach_RequiredPlugins(RequiredPlugin entity)
2112    {
2113      this.SendPropertyChanging();
2114      entity.Task = this;
2115    }
2116   
2117    private void detach_RequiredPlugins(RequiredPlugin entity)
2118    {
2119      this.SendPropertyChanging();
2120      entity.Task = null;
2121    }
2122   
2123    private void attach_Jobs(Task entity)
2124    {
2125      this.SendPropertyChanging();
2126      entity.ParentJob = this;
2127    }
2128   
2129    private void detach_Jobs(Task entity)
2130    {
2131      this.SendPropertyChanging();
2132      entity.ParentJob = null;
2133    }
2134   
2135    private void attach_StateLogs(StateLog entity)
2136    {
2137      this.SendPropertyChanging();
2138      entity.Task = this;
2139    }
2140   
2141    private void detach_StateLogs(StateLog entity)
2142    {
2143      this.SendPropertyChanging();
2144      entity.Task = null;
2145    }
2146   
2147    private void attach_AssignedTaskResources(AssignedTaskResource entity)
2148    {
2149      this.SendPropertyChanging();
2150      entity.Task = this;
2151    }
2152   
2153    private void detach_AssignedTaskResources(AssignedTaskResource entity)
2154    {
2155      this.SendPropertyChanging();
2156      entity.Task = null;
2157    }
2158  }
2159 
2160  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Downtime")]
2161  public partial class Downtime : INotifyPropertyChanging, INotifyPropertyChanged
2162  {
2163   
2164    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2165   
2166    private System.Guid _UptimeCalendarId;
2167   
2168    private System.Guid _ResourceId;
2169   
2170    private System.DateTime _StartDate;
2171   
2172    private System.DateTime _EndDate;
2173   
2174    private bool _AllDayEvent;
2175   
2176    private bool _Recurring;
2177   
2178    private System.Guid _RecurringId;
2179   
2180    private global::HeuristicLab.Services.Hive.DataAccess.DowntimeType _Type;
2181   
2182    private EntityRef<Resource> _Resource;
2183   
2184    #region Extensibility Method Definitions
2185    partial void OnLoaded();
2186    partial void OnValidate(System.Data.Linq.ChangeAction action);
2187    partial void OnCreated();
2188    partial void OnDowntimeIdChanging(System.Guid value);
2189    partial void OnDowntimeIdChanged();
2190    partial void OnResourceIdChanging(System.Guid value);
2191    partial void OnResourceIdChanged();
2192    partial void OnStartDateChanging(System.DateTime value);
2193    partial void OnStartDateChanged();
2194    partial void OnEndDateChanging(System.DateTime value);
2195    partial void OnEndDateChanged();
2196    partial void OnAllDayEventChanging(bool value);
2197    partial void OnAllDayEventChanged();
2198    partial void OnRecurringChanging(bool value);
2199    partial void OnRecurringChanged();
2200    partial void OnRecurringIdChanging(System.Guid value);
2201    partial void OnRecurringIdChanged();
2202    partial void OnDowntimeTypeChanging(global::HeuristicLab.Services.Hive.DataAccess.DowntimeType value);
2203    partial void OnDowntimeTypeChanged();
2204    #endregion
2205   
2206    public Downtime()
2207    {
2208      this._Resource = default(EntityRef<Resource>);
2209      OnCreated();
2210    }
2211   
2212    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UptimeCalendarId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier", IsPrimaryKey=true, IsDbGenerated=true)]
2213    public System.Guid DowntimeId
2214    {
2215      get
2216      {
2217        return this._UptimeCalendarId;
2218      }
2219      set
2220      {
2221        if ((this._UptimeCalendarId != value))
2222        {
2223          this.OnDowntimeIdChanging(value);
2224          this.SendPropertyChanging();
2225          this._UptimeCalendarId = value;
2226          this.SendPropertyChanged("DowntimeId");
2227          this.OnDowntimeIdChanged();
2228        }
2229      }
2230    }
2231   
2232    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier")]
2233    public System.Guid ResourceId
2234    {
2235      get
2236      {
2237        return this._ResourceId;
2238      }
2239      set
2240      {
2241        if ((this._ResourceId != value))
2242        {
2243          if (this._Resource.HasLoadedOrAssignedValue)
2244          {
2245            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2246          }
2247          this.OnResourceIdChanging(value);
2248          this.SendPropertyChanging();
2249          this._ResourceId = value;
2250          this.SendPropertyChanged("ResourceId");
2251          this.OnResourceIdChanged();
2252        }
2253      }
2254    }
2255   
2256    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StartDate", DbType="DateTime")]
2257    public System.DateTime StartDate
2258    {
2259      get
2260      {
2261        return this._StartDate;
2262      }
2263      set
2264      {
2265        if ((this._StartDate != value))
2266        {
2267          this.OnStartDateChanging(value);
2268          this.SendPropertyChanging();
2269          this._StartDate = value;
2270          this.SendPropertyChanged("StartDate");
2271          this.OnStartDateChanged();
2272        }
2273      }
2274    }
2275   
2276    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_EndDate", DbType="DateTime")]
2277    public System.DateTime EndDate
2278    {
2279      get
2280      {
2281        return this._EndDate;
2282      }
2283      set
2284      {
2285        if ((this._EndDate != value))
2286        {
2287          this.OnEndDateChanging(value);
2288          this.SendPropertyChanging();
2289          this._EndDate = value;
2290          this.SendPropertyChanged("EndDate");
2291          this.OnEndDateChanged();
2292        }
2293      }
2294    }
2295   
2296    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_AllDayEvent", DbType="Bit")]
2297    public bool AllDayEvent
2298    {
2299      get
2300      {
2301        return this._AllDayEvent;
2302      }
2303      set
2304      {
2305        if ((this._AllDayEvent != value))
2306        {
2307          this.OnAllDayEventChanging(value);
2308          this.SendPropertyChanging();
2309          this._AllDayEvent = value;
2310          this.SendPropertyChanged("AllDayEvent");
2311          this.OnAllDayEventChanged();
2312        }
2313      }
2314    }
2315   
2316    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Recurring", DbType="Bit")]
2317    public bool Recurring
2318    {
2319      get
2320      {
2321        return this._Recurring;
2322      }
2323      set
2324      {
2325        if ((this._Recurring != value))
2326        {
2327          this.OnRecurringChanging(value);
2328          this.SendPropertyChanging();
2329          this._Recurring = value;
2330          this.SendPropertyChanged("Recurring");
2331          this.OnRecurringChanged();
2332        }
2333      }
2334    }
2335   
2336    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_RecurringId", DbType="UniqueIdentifier")]
2337    public System.Guid RecurringId
2338    {
2339      get
2340      {
2341        return this._RecurringId;
2342      }
2343      set
2344      {
2345        if ((this._RecurringId != value))
2346        {
2347          this.OnRecurringIdChanging(value);
2348          this.SendPropertyChanging();
2349          this._RecurringId = value;
2350          this.SendPropertyChanged("RecurringId");
2351          this.OnRecurringIdChanged();
2352        }
2353      }
2354    }
2355   
2356    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Type", DbType="VarChar(MAX)", CanBeNull=false)]
2357    public global::HeuristicLab.Services.Hive.DataAccess.DowntimeType DowntimeType
2358    {
2359      get
2360      {
2361        return this._Type;
2362      }
2363      set
2364      {
2365        if ((this._Type != value))
2366        {
2367          this.OnDowntimeTypeChanging(value);
2368          this.SendPropertyChanging();
2369          this._Type = value;
2370          this.SendPropertyChanged("DowntimeType");
2371          this.OnDowntimeTypeChanged();
2372        }
2373      }
2374    }
2375   
2376    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_Downtime", Storage="_Resource", ThisKey="ResourceId", OtherKey="ResourceId", IsForeignKey=true, DeleteRule="CASCADE")]
2377    public Resource Resource
2378    {
2379      get
2380      {
2381        return this._Resource.Entity;
2382      }
2383      set
2384      {
2385        Resource previousValue = this._Resource.Entity;
2386        if (((previousValue != value)
2387              || (this._Resource.HasLoadedOrAssignedValue == false)))
2388        {
2389          this.SendPropertyChanging();
2390          if ((previousValue != null))
2391          {
2392            this._Resource.Entity = null;
2393            previousValue.Downtimes.Remove(this);
2394          }
2395          this._Resource.Entity = value;
2396          if ((value != null))
2397          {
2398            value.Downtimes.Add(this);
2399            this._ResourceId = value.ResourceId;
2400          }
2401          else
2402          {
2403            this._ResourceId = default(System.Guid);
2404          }
2405          this.SendPropertyChanged("Resource");
2406        }
2407      }
2408    }
2409   
2410    public event PropertyChangingEventHandler PropertyChanging;
2411   
2412    public event PropertyChangedEventHandler PropertyChanged;
2413   
2414    protected virtual void SendPropertyChanging()
2415    {
2416      if ((this.PropertyChanging != null))
2417      {
2418        this.PropertyChanging(this, emptyChangingEventArgs);
2419      }
2420    }
2421   
2422    protected virtual void SendPropertyChanged(String propertyName)
2423    {
2424      if ((this.PropertyChanged != null))
2425      {
2426        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2427      }
2428    }
2429  }
2430 
2431  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Job")]
2432  public partial class Job : INotifyPropertyChanging, INotifyPropertyChanged
2433  {
2434   
2435    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2436   
2437    private System.Guid _HiveExperimentId;
2438   
2439    private string _Name;
2440   
2441    private string _Description;
2442   
2443    private System.Guid _UserId;
2444   
2445    private System.DateTime _DateCreated;
2446   
2447    private System.Guid _ProjectId;
2448   
2449    private EntitySet<Task> _Jobs;
2450   
2451    private EntitySet<JobPermission> _HiveExperimentPermissions;
2452   
2453    private EntityRef<Project> _Project;
2454   
2455    #region Extensibility Method Definitions
2456    partial void OnLoaded();
2457    partial void OnValidate(System.Data.Linq.ChangeAction action);
2458    partial void OnCreated();
2459    partial void OnJobIdChanging(System.Guid value);
2460    partial void OnJobIdChanged();
2461    partial void OnNameChanging(string value);
2462    partial void OnNameChanged();
2463    partial void OnDescriptionChanging(string value);
2464    partial void OnDescriptionChanged();
2465    partial void OnOwnerUserIdChanging(System.Guid value);
2466    partial void OnOwnerUserIdChanged();
2467    partial void OnDateCreatedChanging(System.DateTime value);
2468    partial void OnDateCreatedChanged();
2469    partial void OnProjectIdChanging(System.Guid value);
2470    partial void OnProjectIdChanged();
2471    #endregion
2472   
2473    public Job()
2474    {
2475      this._Jobs = new EntitySet<Task>(new Action<Task>(this.attach_Jobs), new Action<Task>(this.detach_Jobs));
2476      this._HiveExperimentPermissions = new EntitySet<JobPermission>(new Action<JobPermission>(this.attach_HiveExperimentPermissions), new Action<JobPermission>(this.detach_HiveExperimentPermissions));
2477      this._Project = default(EntityRef<Project>);
2478      OnCreated();
2479    }
2480   
2481    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_HiveExperimentId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
2482    public System.Guid JobId
2483    {
2484      get
2485      {
2486        return this._HiveExperimentId;
2487      }
2488      set
2489      {
2490        if ((this._HiveExperimentId != value))
2491        {
2492          this.OnJobIdChanging(value);
2493          this.SendPropertyChanging();
2494          this._HiveExperimentId = value;
2495          this.SendPropertyChanged("JobId");
2496          this.OnJobIdChanged();
2497        }
2498      }
2499    }
2500   
2501    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX)", CanBeNull=false)]
2502    public string Name
2503    {
2504      get
2505      {
2506        return this._Name;
2507      }
2508      set
2509      {
2510        if ((this._Name != value))
2511        {
2512          this.OnNameChanging(value);
2513          this.SendPropertyChanging();
2514          this._Name = value;
2515          this.SendPropertyChanged("Name");
2516          this.OnNameChanged();
2517        }
2518      }
2519    }
2520   
2521    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Description", DbType="VarChar(MAX)")]
2522    public string Description
2523    {
2524      get
2525      {
2526        return this._Description;
2527      }
2528      set
2529      {
2530        if ((this._Description != value))
2531        {
2532          this.OnDescriptionChanging(value);
2533          this.SendPropertyChanging();
2534          this._Description = value;
2535          this.SendPropertyChanged("Description");
2536          this.OnDescriptionChanged();
2537        }
2538      }
2539    }
2540   
2541    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier")]
2542    public System.Guid OwnerUserId
2543    {
2544      get
2545      {
2546        return this._UserId;
2547      }
2548      set
2549      {
2550        if ((this._UserId != value))
2551        {
2552          this.OnOwnerUserIdChanging(value);
2553          this.SendPropertyChanging();
2554          this._UserId = value;
2555          this.SendPropertyChanged("OwnerUserId");
2556          this.OnOwnerUserIdChanged();
2557        }
2558      }
2559    }
2560   
2561    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateCreated", DbType="DateTime")]
2562    public System.DateTime DateCreated
2563    {
2564      get
2565      {
2566        return this._DateCreated;
2567      }
2568      set
2569      {
2570        if ((this._DateCreated != value))
2571        {
2572          this.OnDateCreatedChanging(value);
2573          this.SendPropertyChanging();
2574          this._DateCreated = value;
2575          this.SendPropertyChanged("DateCreated");
2576          this.OnDateCreatedChanged();
2577        }
2578      }
2579    }
2580   
2581    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ProjectId", DbType="UniqueIdentifier NOT NULL")]
2582    public System.Guid ProjectId
2583    {
2584      get
2585      {
2586        return this._ProjectId;
2587      }
2588      set
2589      {
2590        if ((this._ProjectId != value))
2591        {
2592          if (this._Project.HasLoadedOrAssignedValue)
2593          {
2594            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2595          }
2596          this.OnProjectIdChanging(value);
2597          this.SendPropertyChanging();
2598          this._ProjectId = value;
2599          this.SendPropertyChanged("ProjectId");
2600          this.OnProjectIdChanged();
2601        }
2602      }
2603    }
2604   
2605    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_Task", Storage="_Jobs", ThisKey="JobId", OtherKey="JobId")]
2606    public EntitySet<Task> Tasks
2607    {
2608      get
2609      {
2610        return this._Jobs;
2611      }
2612      set
2613      {
2614        this._Jobs.Assign(value);
2615      }
2616    }
2617   
2618    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_JobPermission", Storage="_HiveExperimentPermissions", ThisKey="JobId", OtherKey="JobId")]
2619    public EntitySet<JobPermission> JobPermissions
2620    {
2621      get
2622      {
2623        return this._HiveExperimentPermissions;
2624      }
2625      set
2626      {
2627        this._HiveExperimentPermissions.Assign(value);
2628      }
2629    }
2630   
2631    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Project_Job", Storage="_Project", ThisKey="ProjectId", OtherKey="ProjectId", IsForeignKey=true)]
2632    public Project Project
2633    {
2634      get
2635      {
2636        return this._Project.Entity;
2637      }
2638      set
2639      {
2640        Project previousValue = this._Project.Entity;
2641        if (((previousValue != value)
2642              || (this._Project.HasLoadedOrAssignedValue == false)))
2643        {
2644          this.SendPropertyChanging();
2645          if ((previousValue != null))
2646          {
2647            this._Project.Entity = null;
2648            previousValue.Jobs.Remove(this);
2649          }
2650          this._Project.Entity = value;
2651          if ((value != null))
2652          {
2653            value.Jobs.Add(this);
2654            this._ProjectId = value.ProjectId;
2655          }
2656          else
2657          {
2658            this._ProjectId = default(System.Guid);
2659          }
2660          this.SendPropertyChanged("Project");
2661        }
2662      }
2663    }
2664   
2665    public event PropertyChangingEventHandler PropertyChanging;
2666   
2667    public event PropertyChangedEventHandler PropertyChanged;
2668   
2669    protected virtual void SendPropertyChanging()
2670    {
2671      if ((this.PropertyChanging != null))
2672      {
2673        this.PropertyChanging(this, emptyChangingEventArgs);
2674      }
2675    }
2676   
2677    protected virtual void SendPropertyChanged(String propertyName)
2678    {
2679      if ((this.PropertyChanged != null))
2680      {
2681        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2682      }
2683    }
2684   
2685    private void attach_Jobs(Task entity)
2686    {
2687      this.SendPropertyChanging();
2688      entity.Job = this;
2689    }
2690   
2691    private void detach_Jobs(Task entity)
2692    {
2693      this.SendPropertyChanging();
2694      entity.Job = null;
2695    }
2696   
2697    private void attach_HiveExperimentPermissions(JobPermission entity)
2698    {
2699      this.SendPropertyChanging();
2700      entity.Job = this;
2701    }
2702   
2703    private void detach_HiveExperimentPermissions(JobPermission entity)
2704    {
2705      this.SendPropertyChanging();
2706      entity.Job = null;
2707    }
2708  }
2709 
2710  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.TaskData")]
2711  public partial class TaskData : INotifyPropertyChanging, INotifyPropertyChanged
2712  {
2713   
2714    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2715   
2716    private System.Guid _JobId;
2717   
2718    private System.Data.Linq.Link<byte[]> _Data;
2719   
2720    private System.DateTime _LastUpdate;
2721   
2722    private EntityRef<Task> _Job;
2723   
2724    #region Extensibility Method Definitions
2725    partial void OnLoaded();
2726    partial void OnValidate(System.Data.Linq.ChangeAction action);
2727    partial void OnCreated();
2728    partial void OnTaskIdChanging(System.Guid value);
2729    partial void OnTaskIdChanged();
2730    partial void OnDataChanging(byte[] value);
2731    partial void OnDataChanged();
2732    partial void OnLastUpdateChanging(System.DateTime value);
2733    partial void OnLastUpdateChanged();
2734    #endregion
2735   
2736    public TaskData()
2737    {
2738      this._Job = default(EntityRef<Task>);
2739      OnCreated();
2740    }
2741   
2742    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
2743    public System.Guid TaskId
2744    {
2745      get
2746      {
2747        return this._JobId;
2748      }
2749      set
2750      {
2751        if ((this._JobId != value))
2752        {
2753          if (this._Job.HasLoadedOrAssignedValue)
2754          {
2755            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2756          }
2757          this.OnTaskIdChanging(value);
2758          this.SendPropertyChanging();
2759          this._JobId = value;
2760          this.SendPropertyChanged("TaskId");
2761          this.OnTaskIdChanged();
2762        }
2763      }
2764    }
2765   
2766    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Data", DbType="VarBinary(MAX)", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
2767    public byte[] Data
2768    {
2769      get
2770      {
2771        return this._Data.Value;
2772      }
2773      set
2774      {
2775        if ((this._Data.Value != value))
2776        {
2777          this.OnDataChanging(value);
2778          this.SendPropertyChanging();
2779          this._Data.Value = value;
2780          this.SendPropertyChanged("Data");
2781          this.OnDataChanged();
2782        }
2783      }
2784    }
2785   
2786    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastUpdate", DbType="DateTime")]
2787    public System.DateTime LastUpdate
2788    {
2789      get
2790      {
2791        return this._LastUpdate;
2792      }
2793      set
2794      {
2795        if ((this._LastUpdate != value))
2796        {
2797          this.OnLastUpdateChanging(value);
2798          this.SendPropertyChanging();
2799          this._LastUpdate = value;
2800          this.SendPropertyChanged("LastUpdate");
2801          this.OnLastUpdateChanged();
2802        }
2803      }
2804    }
2805   
2806    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_TaskData", Storage="_Job", ThisKey="TaskId", OtherKey="TaskId", IsForeignKey=true)]
2807    public Task Task
2808    {
2809      get
2810      {
2811        return this._Job.Entity;
2812      }
2813      set
2814      {
2815        Task previousValue = this._Job.Entity;
2816        if (((previousValue != value)
2817              || (this._Job.HasLoadedOrAssignedValue == false)))
2818        {
2819          this.SendPropertyChanging();
2820          if ((previousValue != null))
2821          {
2822            this._Job.Entity = null;
2823            previousValue.JobData = null;
2824          }
2825          this._Job.Entity = value;
2826          if ((value != null))
2827          {
2828            value.JobData = this;
2829            this._JobId = value.TaskId;
2830          }
2831          else
2832          {
2833            this._JobId = default(System.Guid);
2834          }
2835          this.SendPropertyChanged("Task");
2836        }
2837      }
2838    }
2839   
2840    public event PropertyChangingEventHandler PropertyChanging;
2841   
2842    public event PropertyChangedEventHandler PropertyChanged;
2843   
2844    protected virtual void SendPropertyChanging()
2845    {
2846      if ((this.PropertyChanging != null))
2847      {
2848        this.PropertyChanging(this, emptyChangingEventArgs);
2849      }
2850    }
2851   
2852    protected virtual void SendPropertyChanged(String propertyName)
2853    {
2854      if ((this.PropertyChanged != null))
2855      {
2856        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2857      }
2858    }
2859  }
2860 
2861  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.PluginData")]
2862  public partial class PluginData : INotifyPropertyChanging, INotifyPropertyChanged
2863  {
2864   
2865    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2866   
2867    private System.Guid _PluginDataId;
2868   
2869    private System.Guid _PluginId;
2870   
2871    private System.Data.Linq.Link<byte[]> _Data;
2872   
2873    private string _FileName;
2874   
2875    private EntityRef<Plugin> _Plugin;
2876   
2877    #region Extensibility Method Definitions
2878    partial void OnLoaded();
2879    partial void OnValidate(System.Data.Linq.ChangeAction action);
2880    partial void OnCreated();
2881    partial void OnPluginDataIdChanging(System.Guid value);
2882    partial void OnPluginDataIdChanged();
2883    partial void OnPluginIdChanging(System.Guid value);
2884    partial void OnPluginIdChanged();
2885    partial void OnDataChanging(byte[] value);
2886    partial void OnDataChanged();
2887    partial void OnFileNameChanging(string value);
2888    partial void OnFileNameChanged();
2889    #endregion
2890   
2891    public PluginData()
2892    {
2893      this._Plugin = default(EntityRef<Plugin>);
2894      OnCreated();
2895    }
2896   
2897    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginDataId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
2898    public System.Guid PluginDataId
2899    {
2900      get
2901      {
2902        return this._PluginDataId;
2903      }
2904      set
2905      {
2906        if ((this._PluginDataId != value))
2907        {
2908          this.OnPluginDataIdChanging(value);
2909          this.SendPropertyChanging();
2910          this._PluginDataId = value;
2911          this.SendPropertyChanged("PluginDataId");
2912          this.OnPluginDataIdChanged();
2913        }
2914      }
2915    }
2916   
2917    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginId", DbType="UniqueIdentifier NOT NULL")]
2918    public System.Guid PluginId
2919    {
2920      get
2921      {
2922        return this._PluginId;
2923      }
2924      set
2925      {
2926        if ((this._PluginId != value))
2927        {
2928          if (this._Plugin.HasLoadedOrAssignedValue)
2929          {
2930            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2931          }
2932          this.OnPluginIdChanging(value);
2933          this.SendPropertyChanging();
2934          this._PluginId = value;
2935          this.SendPropertyChanged("PluginId");
2936          this.OnPluginIdChanged();
2937        }
2938      }
2939    }
2940   
2941    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Data", DbType="VarBinary(MAX) NOT NULL", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
2942    public byte[] Data
2943    {
2944      get
2945      {
2946        return this._Data.Value;
2947      }
2948      set
2949      {
2950        if ((this._Data.Value != value))
2951        {
2952          this.OnDataChanging(value);
2953          this.SendPropertyChanging();
2954          this._Data.Value = value;
2955          this.SendPropertyChanged("Data");
2956          this.OnDataChanged();
2957        }
2958      }
2959    }
2960   
2961    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_FileName", DbType="VarChar(MAX)", CanBeNull=false)]
2962    public string FileName
2963    {
2964      get
2965      {
2966        return this._FileName;
2967      }
2968      set
2969      {
2970        if ((this._FileName != value))
2971        {
2972          this.OnFileNameChanging(value);
2973          this.SendPropertyChanging();
2974          this._FileName = value;
2975          this.SendPropertyChanged("FileName");
2976          this.OnFileNameChanged();
2977        }
2978      }
2979    }
2980   
2981    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Plugin_PluginData", Storage="_Plugin", ThisKey="PluginId", OtherKey="PluginId", IsForeignKey=true)]
2982    public Plugin Plugin
2983    {
2984      get
2985      {
2986        return this._Plugin.Entity;
2987      }
2988      set
2989      {
2990        Plugin previousValue = this._Plugin.Entity;
2991        if (((previousValue != value)
2992              || (this._Plugin.HasLoadedOrAssignedValue == false)))
2993        {
2994          this.SendPropertyChanging();
2995          if ((previousValue != null))
2996          {
2997            this._Plugin.Entity = null;
2998            previousValue.PluginData.Remove(this);
2999          }
3000          this._Plugin.Entity = value;
3001          if ((value != null))
3002          {
3003            value.PluginData.Add(this);
3004            this._PluginId = value.PluginId;
3005          }
3006          else
3007          {
3008            this._PluginId = default(System.Guid);
3009          }
3010          this.SendPropertyChanged("Plugin");
3011        }
3012      }
3013    }
3014   
3015    public event PropertyChangingEventHandler PropertyChanging;
3016   
3017    public event PropertyChangedEventHandler PropertyChanged;
3018   
3019    protected virtual void SendPropertyChanging()
3020    {
3021      if ((this.PropertyChanging != null))
3022      {
3023        this.PropertyChanging(this, emptyChangingEventArgs);
3024      }
3025    }
3026   
3027    protected virtual void SendPropertyChanged(String propertyName)
3028    {
3029      if ((this.PropertyChanged != null))
3030      {
3031        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3032      }
3033    }
3034  }
3035 
3036  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.StateLog")]
3037  public partial class StateLog : INotifyPropertyChanging, INotifyPropertyChanged
3038  {
3039   
3040    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3041   
3042    private System.Guid _StateLogId;
3043   
3044    private global::HeuristicLab.Services.Hive.DataAccess.TaskState _State;
3045   
3046    private System.DateTime _DateTime;
3047   
3048    private System.Guid _JobId;
3049   
3050    private System.Nullable<System.Guid> _UserId;
3051   
3052    private System.Nullable<System.Guid> _SlaveId;
3053   
3054    private string _Exception;
3055   
3056    private EntityRef<Task> _Job;
3057   
3058    private EntityRef<Resource> _Resource;
3059   
3060    #region Extensibility Method Definitions
3061    partial void OnLoaded();
3062    partial void OnValidate(System.Data.Linq.ChangeAction action);
3063    partial void OnCreated();
3064    partial void OnStateLogIdChanging(System.Guid value);
3065    partial void OnStateLogIdChanged();
3066    partial void OnStateChanging(global::HeuristicLab.Services.Hive.DataAccess.TaskState value);
3067    partial void OnStateChanged();
3068    partial void OnDateTimeChanging(System.DateTime value);
3069    partial void OnDateTimeChanged();
3070    partial void OnTaskIdChanging(System.Guid value);
3071    partial void OnTaskIdChanged();
3072    partial void OnUserIdChanging(System.Nullable<System.Guid> value);
3073    partial void OnUserIdChanged();
3074    partial void OnSlaveIdChanging(System.Nullable<System.Guid> value);
3075    partial void OnSlaveIdChanged();
3076    partial void OnExceptionChanging(string value);
3077    partial void OnExceptionChanged();
3078    #endregion
3079   
3080    public StateLog()
3081    {
3082      this._Job = default(EntityRef<Task>);
3083      this._Resource = default(EntityRef<Resource>);
3084      OnCreated();
3085    }
3086   
3087    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StateLogId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
3088    public System.Guid StateLogId
3089    {
3090      get
3091      {
3092        return this._StateLogId;
3093      }
3094      set
3095      {
3096        if ((this._StateLogId != value))
3097        {
3098          this.OnStateLogIdChanging(value);
3099          this.SendPropertyChanging();
3100          this._StateLogId = value;
3101          this.SendPropertyChanged("StateLogId");
3102          this.OnStateLogIdChanged();
3103        }
3104      }
3105    }
3106   
3107    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_State", DbType="VarChar(30) NOT NULL", CanBeNull=false)]
3108    public global::HeuristicLab.Services.Hive.DataAccess.TaskState State
3109    {
3110      get
3111      {
3112        return this._State;
3113      }
3114      set
3115      {
3116        if ((this._State != value))
3117        {
3118          this.OnStateChanging(value);
3119          this.SendPropertyChanging();
3120          this._State = value;
3121          this.SendPropertyChanged("State");
3122          this.OnStateChanged();
3123        }
3124      }
3125    }
3126   
3127    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateTime", DbType="DateTime NOT NULL")]
3128    public System.DateTime DateTime
3129    {
3130      get
3131      {
3132        return this._DateTime;
3133      }
3134      set
3135      {
3136        if ((this._DateTime != value))
3137        {
3138          this.OnDateTimeChanging(value);
3139          this.SendPropertyChanging();
3140          this._DateTime = value;
3141          this.SendPropertyChanged("DateTime");
3142          this.OnDateTimeChanged();
3143        }
3144      }
3145    }
3146   
3147    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL")]
3148    public System.Guid TaskId
3149    {
3150      get
3151      {
3152        return this._JobId;
3153      }
3154      set
3155      {
3156        if ((this._JobId != value))
3157        {
3158          if (this._Job.HasLoadedOrAssignedValue)
3159          {
3160            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3161          }
3162          this.OnTaskIdChanging(value);
3163          this.SendPropertyChanging();
3164          this._JobId = value;
3165          this.SendPropertyChanged("TaskId");
3166          this.OnTaskIdChanged();
3167        }
3168      }
3169    }
3170   
3171    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier")]
3172    public System.Nullable<System.Guid> UserId
3173    {
3174      get
3175      {
3176        return this._UserId;
3177      }
3178      set
3179      {
3180        if ((this._UserId != value))
3181        {
3182          this.OnUserIdChanging(value);
3183          this.SendPropertyChanging();
3184          this._UserId = value;
3185          this.SendPropertyChanged("UserId");
3186          this.OnUserIdChanged();
3187        }
3188      }
3189    }
3190   
3191    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_SlaveId", DbType="UniqueIdentifier")]
3192    public System.Nullable<System.Guid> SlaveId
3193    {
3194      get
3195      {
3196        return this._SlaveId;
3197      }
3198      set
3199      {
3200        if ((this._SlaveId != value))
3201        {
3202          if (this._Resource.HasLoadedOrAssignedValue)
3203          {
3204            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3205          }
3206          this.OnSlaveIdChanging(value);
3207          this.SendPropertyChanging();
3208          this._SlaveId = value;
3209          this.SendPropertyChanged("SlaveId");
3210          this.OnSlaveIdChanged();
3211        }
3212      }
3213    }
3214   
3215    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Exception", DbType="VarChar(MAX)", CanBeNull=false)]
3216    public string Exception
3217    {
3218      get
3219      {
3220        return this._Exception;
3221      }
3222      set
3223      {
3224        if ((this._Exception != value))
3225        {
3226          this.OnExceptionChanging(value);
3227          this.SendPropertyChanging();
3228          this._Exception = value;
3229          this.SendPropertyChanged("Exception");
3230          this.OnExceptionChanged();
3231        }
3232      }
3233    }
3234   
3235    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_StateLog", Storage="_Job", ThisKey="TaskId", OtherKey="TaskId", IsForeignKey=true)]
3236    public Task Task
3237    {
3238      get
3239      {
3240        return this._Job.Entity;
3241      }
3242      set
3243      {
3244        Task previousValue = this._Job.Entity;
3245        if (((previousValue != value)
3246              || (this._Job.HasLoadedOrAssignedValue == false)))
3247        {
3248          this.SendPropertyChanging();
3249          if ((previousValue != null))
3250          {
3251            this._Job.Entity = null;
3252            previousValue.StateLogs.Remove(this);
3253          }
3254          this._Job.Entity = value;
3255          if ((value != null))
3256          {
3257            value.StateLogs.Add(this);
3258            this._JobId = value.TaskId;
3259          }
3260          else
3261          {
3262            this._JobId = default(System.Guid);
3263          }
3264          this.SendPropertyChanged("Task");
3265        }
3266      }
3267    }
3268   
3269    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_StateLog", Storage="_Resource", ThisKey="SlaveId", OtherKey="ResourceId", IsForeignKey=true)]
3270    public Resource Resource
3271    {
3272      get
3273      {
3274        return this._Resource.Entity;
3275      }
3276      set
3277      {
3278        Resource previousValue = this._Resource.Entity;
3279        if (((previousValue != value)
3280              || (this._Resource.HasLoadedOrAssignedValue == false)))
3281        {
3282          this.SendPropertyChanging();
3283          if ((previousValue != null))
3284          {
3285            this._Resource.Entity = null;
3286            previousValue.StateLogs.Remove(this);
3287          }
3288          this._Resource.Entity = value;
3289          if ((value != null))
3290          {
3291            value.StateLogs.Add(this);
3292            this._SlaveId = value.ResourceId;
3293          }
3294          else
3295          {
3296            this._SlaveId = default(Nullable<System.Guid>);
3297          }
3298          this.SendPropertyChanged("Resource");
3299        }
3300      }
3301    }
3302   
3303    public event PropertyChangingEventHandler PropertyChanging;
3304   
3305    public event PropertyChangedEventHandler PropertyChanged;
3306   
3307    protected virtual void SendPropertyChanging()
3308    {
3309      if ((this.PropertyChanging != null))
3310      {
3311        this.PropertyChanging(this, emptyChangingEventArgs);
3312      }
3313    }
3314   
3315    protected virtual void SendPropertyChanged(String propertyName)
3316    {
3317      if ((this.PropertyChanged != null))
3318      {
3319        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3320      }
3321    }
3322  }
3323 
3324  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.JobPermission")]
3325  public partial class JobPermission : INotifyPropertyChanging, INotifyPropertyChanged
3326  {
3327   
3328    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3329   
3330    private System.Guid _HiveExperimentId;
3331   
3332    private System.Guid _GrantedUserId;
3333   
3334    private System.Guid _GrantedByUserId;
3335   
3336    private global::HeuristicLab.Services.Hive.DataAccess.Permission _Permission;
3337   
3338    private EntityRef<Job> _HiveExperiment;
3339   
3340    #region Extensibility Method Definitions
3341    partial void OnLoaded();
3342    partial void OnValidate(System.Data.Linq.ChangeAction action);
3343    partial void OnCreated();
3344    partial void OnJobIdChanging(System.Guid value);
3345    partial void OnJobIdChanged();
3346    partial void OnGrantedUserIdChanging(System.Guid value);
3347    partial void OnGrantedUserIdChanged();
3348    partial void OnGrantedByUserIdChanging(System.Guid value);
3349    partial void OnGrantedByUserIdChanged();
3350    partial void OnPermissionChanging(global::HeuristicLab.Services.Hive.DataAccess.Permission value);
3351    partial void OnPermissionChanged();
3352    #endregion
3353   
3354    public JobPermission()
3355    {
3356      this._HiveExperiment = default(EntityRef<Job>);
3357      OnCreated();
3358    }
3359   
3360    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_HiveExperimentId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
3361    public System.Guid JobId
3362    {
3363      get
3364      {
3365        return this._HiveExperimentId;
3366      }
3367      set
3368      {
3369        if ((this._HiveExperimentId != value))
3370        {
3371          if (this._HiveExperiment.HasLoadedOrAssignedValue)
3372          {
3373            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3374          }
3375          this.OnJobIdChanging(value);
3376          this.SendPropertyChanging();
3377          this._HiveExperimentId = value;
3378          this.SendPropertyChanged("JobId");
3379          this.OnJobIdChanged();
3380        }
3381      }
3382    }
3383   
3384    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GrantedUserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
3385    public System.Guid GrantedUserId
3386    {
3387      get
3388      {
3389        return this._GrantedUserId;
3390      }
3391      set
3392      {
3393        if ((this._GrantedUserId != value))
3394        {
3395          this.OnGrantedUserIdChanging(value);
3396          this.SendPropertyChanging();
3397          this._GrantedUserId = value;
3398          this.SendPropertyChanged("GrantedUserId");
3399          this.OnGrantedUserIdChanged();
3400        }
3401      }
3402    }
3403   
3404    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GrantedByUserId", DbType="UniqueIdentifier NOT NULL")]
3405    public System.Guid GrantedByUserId
3406    {
3407      get
3408      {
3409        return this._GrantedByUserId;
3410      }
3411      set
3412      {
3413        if ((this._GrantedByUserId != value))
3414        {
3415          this.OnGrantedByUserIdChanging(value);
3416          this.SendPropertyChanging();
3417          this._GrantedByUserId = value;
3418          this.SendPropertyChanged("GrantedByUserId");
3419          this.OnGrantedByUserIdChanged();
3420        }
3421      }
3422    }
3423   
3424    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Permission", DbType="VarChar(15) NOT NULL", CanBeNull=false)]
3425    public global::HeuristicLab.Services.Hive.DataAccess.Permission Permission
3426    {
3427      get
3428      {
3429        return this._Permission;
3430      }
3431      set
3432      {
3433        if ((this._Permission != value))
3434        {
3435          this.OnPermissionChanging(value);
3436          this.SendPropertyChanging();
3437          this._Permission = value;
3438          this.SendPropertyChanged("Permission");
3439          this.OnPermissionChanged();
3440        }
3441      }
3442    }
3443   
3444    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_JobPermission", Storage="_HiveExperiment", ThisKey="JobId", OtherKey="JobId", IsForeignKey=true)]
3445    public Job Job
3446    {
3447      get
3448      {
3449        return this._HiveExperiment.Entity;
3450      }
3451      set
3452      {
3453        Job previousValue = this._HiveExperiment.Entity;
3454        if (((previousValue != value)
3455              || (this._HiveExperiment.HasLoadedOrAssignedValue == false)))
3456        {
3457          this.SendPropertyChanging();
3458          if ((previousValue != null))
3459          {
3460            this._HiveExperiment.Entity = null;
3461            previousValue.JobPermissions.Remove(this);
3462          }
3463          this._HiveExperiment.Entity = value;
3464          if ((value != null))
3465          {
3466            value.JobPermissions.Add(this);
3467            this._HiveExperimentId = value.JobId;
3468          }
3469          else
3470          {
3471            this._HiveExperimentId = default(System.Guid);
3472          }
3473          this.SendPropertyChanged("Job");
3474        }
3475      }
3476    }
3477   
3478    public event PropertyChangingEventHandler PropertyChanging;
3479   
3480    public event PropertyChangedEventHandler PropertyChanged;
3481   
3482    protected virtual void SendPropertyChanging()
3483    {
3484      if ((this.PropertyChanging != null))
3485      {
3486        this.PropertyChanging(this, emptyChangingEventArgs);
3487      }
3488    }
3489   
3490    protected virtual void SendPropertyChanged(String propertyName)
3491    {
3492      if ((this.PropertyChanged != null))
3493      {
3494        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3495      }
3496    }
3497  }
3498 
3499  [global::System.Data.Linq.Mapping.TableAttribute(Name="")]
3500  public partial class Lifecycle : INotifyPropertyChanging, INotifyPropertyChanged
3501  {
3502   
3503    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3504   
3505    private int _LifecycleId;
3506   
3507    private System.DateTime _LastCleanup;
3508   
3509    #region Extensibility Method Definitions
3510    partial void OnLoaded();
3511    partial void OnValidate(System.Data.Linq.ChangeAction action);
3512    partial void OnCreated();
3513    partial void OnLifecycleIdChanging(int value);
3514    partial void OnLifecycleIdChanged();
3515    partial void OnLastCleanupChanging(System.DateTime value);
3516    partial void OnLastCleanupChanged();
3517    #endregion
3518   
3519    public Lifecycle()
3520    {
3521      OnCreated();
3522    }
3523   
3524    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LifecycleId", DbType="Int", IsPrimaryKey=true)]
3525    public int LifecycleId
3526    {
3527      get
3528      {
3529        return this._LifecycleId;
3530      }
3531      set
3532      {
3533        if ((this._LifecycleId != value))
3534        {
3535          this.OnLifecycleIdChanging(value);
3536          this.SendPropertyChanging();
3537          this._LifecycleId = value;
3538          this.SendPropertyChanged("LifecycleId");
3539          this.OnLifecycleIdChanged();
3540        }
3541      }
3542    }
3543   
3544    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastCleanup", DbType="DateTime")]
3545    public System.DateTime LastCleanup
3546    {
3547      get
3548      {
3549        return this._LastCleanup;
3550      }
3551      set
3552      {
3553        if ((this._LastCleanup != value))
3554        {
3555          this.OnLastCleanupChanging(value);
3556          this.SendPropertyChanging();
3557          this._LastCleanup = value;
3558          this.SendPropertyChanged("LastCleanup");
3559          this.OnLastCleanupChanged();
3560        }
3561      }
3562    }
3563   
3564    public event PropertyChangingEventHandler PropertyChanging;
3565   
3566    public event PropertyChangedEventHandler PropertyChanged;
3567   
3568    protected virtual void SendPropertyChanging()
3569    {
3570      if ((this.PropertyChanging != null))
3571      {
3572        this.PropertyChanging(this, emptyChangingEventArgs);
3573      }
3574    }
3575   
3576    protected virtual void SendPropertyChanged(String propertyName)
3577    {
3578      if ((this.PropertyChanged != null))
3579      {
3580        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3581      }
3582    }
3583  }
3584 
3585  [global::System.Data.Linq.Mapping.TableAttribute(Name="")]
3586  public partial class UserPriority : INotifyPropertyChanging, INotifyPropertyChanged
3587  {
3588   
3589    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3590   
3591    private System.Guid _UserId;
3592   
3593    private System.DateTime _DateEnqueued;
3594   
3595    #region Extensibility Method Definitions
3596    partial void OnLoaded();
3597    partial void OnValidate(System.Data.Linq.ChangeAction action);
3598    partial void OnCreated();
3599    partial void OnUserIdChanging(System.Guid value);
3600    partial void OnUserIdChanged();
3601    partial void OnDateEnqueuedChanging(System.DateTime value);
3602    partial void OnDateEnqueuedChanged();
3603    #endregion
3604   
3605    public UserPriority()
3606    {
3607      OnCreated();
3608    }
3609   
3610    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
3611    public System.Guid UserId
3612    {
3613      get
3614      {
3615        return this._UserId;
3616      }
3617      set
3618      {
3619        if ((this._UserId != value))
3620        {
3621          this.OnUserIdChanging(value);
3622          this.SendPropertyChanging();
3623          this._UserId = value;
3624          this.SendPropertyChanged("UserId");
3625          this.OnUserIdChanged();
3626        }
3627      }
3628    }
3629   
3630    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateEnqueued", DbType="DateTime NOT NULL")]
3631    public System.DateTime DateEnqueued
3632    {
3633      get
3634      {
3635        return this._DateEnqueued;
3636      }
3637      set
3638      {
3639        if ((this._DateEnqueued != value))
3640        {
3641          this.OnDateEnqueuedChanging(value);
3642          this.SendPropertyChanging();
3643          this._DateEnqueued = value;
3644          this.SendPropertyChanged("DateEnqueued");
3645          this.OnDateEnqueuedChanged();
3646        }
3647      }
3648    }
3649   
3650    public event PropertyChangingEventHandler PropertyChanging;
3651   
3652    public event PropertyChangedEventHandler PropertyChanged;
3653   
3654    protected virtual void SendPropertyChanging()
3655    {
3656      if ((this.PropertyChanging != null))
3657      {
3658        this.PropertyChanging(this, emptyChangingEventArgs);
3659      }
3660    }
3661   
3662    protected virtual void SendPropertyChanged(String propertyName)
3663    {
3664      if ((this.PropertyChanged != null))
3665      {
3666        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3667      }
3668    }
3669  }
3670 
3671  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimClient")]
3672  public partial class DimClient : INotifyPropertyChanging, INotifyPropertyChanged
3673  {
3674   
3675    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3676   
3677    private System.Guid _Id;
3678   
3679    private string _Name;
3680   
3681    private System.Guid _ResourceId;
3682   
3683    private System.Nullable<System.DateTime> _ExpirationTime;
3684   
3685    private System.Nullable<System.Guid> _ResourceGroupId;
3686   
3687    private System.Nullable<System.Guid> _ResourceGroup2Id;
3688   
3689    private string _GroupName;
3690   
3691    private string _GroupName2;
3692   
3693    private EntitySet<FactTask> _FactTasks;
3694   
3695    private EntitySet<FactClientInfo> _FactClientInfos;
3696   
3697    #region Extensibility Method Definitions
3698    partial void OnLoaded();
3699    partial void OnValidate(System.Data.Linq.ChangeAction action);
3700    partial void OnCreated();
3701    partial void OnIdChanging(System.Guid value);
3702    partial void OnIdChanged();
3703    partial void OnNameChanging(string value);
3704    partial void OnNameChanged();
3705    partial void OnResourceIdChanging(System.Guid value);
3706    partial void OnResourceIdChanged();
3707    partial void OnExpirationTimeChanging(System.Nullable<System.DateTime> value);
3708    partial void OnExpirationTimeChanged();
3709    partial void OnResourceGroupIdChanging(System.Nullable<System.Guid> value);
3710    partial void OnResourceGroupIdChanged();
3711    partial void OnResourceGroup2IdChanging(System.Nullable<System.Guid> value);
3712    partial void OnResourceGroup2IdChanged();
3713    partial void OnGroupNameChanging(string value);
3714    partial void OnGroupNameChanged();
3715    partial void OnGroupName2Changing(string value);
3716    partial void OnGroupName2Changed();
3717    #endregion
3718   
3719    public DimClient()
3720    {
3721      this._FactTasks = new EntitySet<FactTask>(new Action<FactTask>(this.attach_FactTasks), new Action<FactTask>(this.detach_FactTasks));
3722      this._FactClientInfos = new EntitySet<FactClientInfo>(new Action<FactClientInfo>(this.attach_FactClientInfos), new Action<FactClientInfo>(this.detach_FactClientInfos));
3723      OnCreated();
3724    }
3725   
3726    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
3727    public System.Guid Id
3728    {
3729      get
3730      {
3731        return this._Id;
3732      }
3733      set
3734      {
3735        if ((this._Id != value))
3736        {
3737          this.OnIdChanging(value);
3738          this.SendPropertyChanging();
3739          this._Id = value;
3740          this.SendPropertyChanged("Id");
3741          this.OnIdChanged();
3742        }
3743      }
3744    }
3745   
3746    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
3747    public string Name
3748    {
3749      get
3750      {
3751        return this._Name;
3752      }
3753      set
3754      {
3755        if ((this._Name != value))
3756        {
3757          this.OnNameChanging(value);
3758          this.SendPropertyChanging();
3759          this._Name = value;
3760          this.SendPropertyChanged("Name");
3761          this.OnNameChanged();
3762        }
3763      }
3764    }
3765   
3766    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier NOT NULL")]
3767    public System.Guid ResourceId
3768    {
3769      get
3770      {
3771        return this._ResourceId;
3772      }
3773      set
3774      {
3775        if ((this._ResourceId != value))
3776        {
3777          this.OnResourceIdChanging(value);
3778          this.SendPropertyChanging();
3779          this._ResourceId = value;
3780          this.SendPropertyChanged("ResourceId");
3781          this.OnResourceIdChanged();
3782        }
3783      }
3784    }
3785   
3786    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ExpirationTime", DbType="DateTime")]
3787    public System.Nullable<System.DateTime> ExpirationTime
3788    {
3789      get
3790      {
3791        return this._ExpirationTime;
3792      }
3793      set
3794      {
3795        if ((this._ExpirationTime != value))
3796        {
3797          this.OnExpirationTimeChanging(value);
3798          this.SendPropertyChanging();
3799          this._ExpirationTime = value;
3800          this.SendPropertyChanged("ExpirationTime");
3801          this.OnExpirationTimeChanged();
3802        }
3803      }
3804    }
3805   
3806    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceGroupId", DbType="UniqueIdentifier")]
3807    public System.Nullable<System.Guid> ResourceGroupId
3808    {
3809      get
3810      {
3811        return this._ResourceGroupId;
3812      }
3813      set
3814      {
3815        if ((this._ResourceGroupId != value))
3816        {
3817          this.OnResourceGroupIdChanging(value);
3818          this.SendPropertyChanging();
3819          this._ResourceGroupId = value;
3820          this.SendPropertyChanged("ResourceGroupId");
3821          this.OnResourceGroupIdChanged();
3822        }
3823      }
3824    }
3825   
3826    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceGroup2Id", DbType="UniqueIdentifier")]
3827    public System.Nullable<System.Guid> ResourceGroup2Id
3828    {
3829      get
3830      {
3831        return this._ResourceGroup2Id;
3832      }
3833      set
3834      {
3835        if ((this._ResourceGroup2Id != value))
3836        {
3837          this.OnResourceGroup2IdChanging(value);
3838          this.SendPropertyChanging();
3839          this._ResourceGroup2Id = value;
3840          this.SendPropertyChanged("ResourceGroup2Id");
3841          this.OnResourceGroup2IdChanged();
3842        }
3843      }
3844    }
3845   
3846    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GroupName")]
3847    public string GroupName
3848    {
3849      get
3850      {
3851        return this._GroupName;
3852      }
3853      set
3854      {
3855        if ((this._GroupName != value))
3856        {
3857          this.OnGroupNameChanging(value);
3858          this.SendPropertyChanging();
3859          this._GroupName = value;
3860          this.SendPropertyChanged("GroupName");
3861          this.OnGroupNameChanged();
3862        }
3863      }
3864    }
3865   
3866    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GroupName2")]
3867    public string GroupName2
3868    {
3869      get
3870      {
3871        return this._GroupName2;
3872      }
3873      set
3874      {
3875        if ((this._GroupName2 != value))
3876        {
3877          this.OnGroupName2Changing(value);
3878          this.SendPropertyChanging();
3879          this._GroupName2 = value;
3880          this.SendPropertyChanged("GroupName2");
3881          this.OnGroupName2Changed();
3882        }
3883      }
3884    }
3885   
3886    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactTask", Storage="_FactTasks", ThisKey="Id", OtherKey="LastClientId")]
3887    public EntitySet<FactTask> FactTasks
3888    {
3889      get
3890      {
3891        return this._FactTasks;
3892      }
3893      set
3894      {
3895        this._FactTasks.Assign(value);
3896      }
3897    }
3898   
3899    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactClientInfo", Storage="_FactClientInfos", ThisKey="Id", OtherKey="ClientId")]
3900    public EntitySet<FactClientInfo> FactClientInfos
3901    {
3902      get
3903      {
3904        return this._FactClientInfos;
3905      }
3906      set
3907      {
3908        this._FactClientInfos.Assign(value);
3909      }
3910    }
3911   
3912    public event PropertyChangingEventHandler PropertyChanging;
3913   
3914    public event PropertyChangedEventHandler PropertyChanged;
3915   
3916    protected virtual void SendPropertyChanging()
3917    {
3918      if ((this.PropertyChanging != null))
3919      {
3920        this.PropertyChanging(this, emptyChangingEventArgs);
3921      }
3922    }
3923   
3924    protected virtual void SendPropertyChanged(String propertyName)
3925    {
3926      if ((this.PropertyChanged != null))
3927      {
3928        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3929      }
3930    }
3931   
3932    private void attach_FactTasks(FactTask entity)
3933    {
3934      this.SendPropertyChanging();
3935      entity.DimClient = this;
3936    }
3937   
3938    private void detach_FactTasks(FactTask entity)
3939    {
3940      this.SendPropertyChanging();
3941      entity.DimClient = null;
3942    }
3943   
3944    private void attach_FactClientInfos(FactClientInfo entity)
3945    {
3946      this.SendPropertyChanging();
3947      entity.DimClient = this;
3948    }
3949   
3950    private void detach_FactClientInfos(FactClientInfo entity)
3951    {
3952      this.SendPropertyChanging();
3953      entity.DimClient = null;
3954    }
3955  }
3956 
3957  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].FactTask")]
3958  public partial class FactTask : INotifyPropertyChanging, INotifyPropertyChanged
3959  {
3960   
3961    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3962   
3963    private System.Guid _TaskId;
3964   
3965    private long _TotalRuntime;
3966   
3967    private long _TotalWaitingTime;
3968   
3969    private long _TotalTransferTime;
3970   
3971    private int _NumCalculationRuns;
3972   
3973    private int _NumFails;
3974   
3975    private int _CoresRequired;
3976   
3977    private int _MemoryRequired;
3978   
3979    private int _Priority;
3980   
3981    private System.Nullable<System.Guid> _LastClientId;
3982   
3983    private System.Guid _JobId;
3984   
3985    private System.Nullable<System.DateTime> _EndTime;
3986   
3987    private global::HeuristicLab.Services.Hive.DataAccess.TaskState _TaskState;
3988   
3989    private string _Exception;
3990   
3991    private long _InitialWaitingTimeMs;
3992   
3993    private System.Nullable<System.DateTime> _StartTime;
3994   
3995    private EntityRef<DimClient> _DimClient;
3996   
3997    private EntityRef<DimJob> _DimJob;
3998   
3999    #region Extensibility Method Definitions
4000    partial void OnLoaded();
4001    partial void OnValidate(System.Data.Linq.ChangeAction action);
4002    partial void OnCreated();
4003    partial void OnTaskIdChanging(System.Guid value);
4004    partial void OnTaskIdChanged();
4005    partial void OnCalculatingTimeChanging(long value);
4006    partial void OnCalculatingTimeChanged();
4007    partial void OnWaitingTimeChanging(long value);
4008    partial void OnWaitingTimeChanged();
4009    partial void OnTransferTimeChanging(long value);
4010    partial void OnTransferTimeChanged();
4011    partial void OnNumCalculationRunsChanging(int value);
4012    partial void OnNumCalculationRunsChanged();
4013    partial void OnNumRetriesChanging(int value);
4014    partial void OnNumRetriesChanged();
4015    partial void OnCoresRequiredChanging(int value);
4016    partial void OnCoresRequiredChanged();
4017    partial void OnMemoryRequiredChanging(int value);
4018    partial void OnMemoryRequiredChanged();
4019    partial void OnPriorityChanging(int value);
4020    partial void OnPriorityChanged();
4021    partial void OnLastClientIdChanging(System.Nullable<System.Guid> value);
4022    partial void OnLastClientIdChanged();
4023    partial void OnJobIdChanging(System.Guid value);
4024    partial void OnJobIdChanged();
4025    partial void OnEndTimeChanging(System.Nullable<System.DateTime> value);
4026    partial void OnEndTimeChanged();
4027    partial void OnTaskStateChanging(global::HeuristicLab.Services.Hive.DataAccess.TaskState value);
4028    partial void OnTaskStateChanged();
4029    partial void OnExceptionChanging(string value);
4030    partial void OnExceptionChanged();
4031    partial void OnInitialWaitingTimeChanging(long value);
4032    partial void OnInitialWaitingTimeChanged();
4033    partial void OnStartTimeChanging(System.Nullable<System.DateTime> value);
4034    partial void OnStartTimeChanged();
4035    #endregion
4036   
4037    public FactTask()
4038    {
4039      this._DimClient = default(EntityRef<DimClient>);
4040      this._DimJob = default(EntityRef<DimJob>);
4041      OnCreated();
4042    }
4043   
4044    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TaskId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
4045    public System.Guid TaskId
4046    {
4047      get
4048      {
4049        return this._TaskId;
4050      }
4051      set
4052      {
4053        if ((this._TaskId != value))
4054        {
4055          this.OnTaskIdChanging(value);
4056          this.SendPropertyChanging();
4057          this._TaskId = value;
4058          this.SendPropertyChanged("TaskId");
4059          this.OnTaskIdChanged();
4060        }
4061      }
4062    }
4063   
4064    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalRuntime", DbType="INT NOT NULL")]
4065    public long CalculatingTime
4066    {
4067      get
4068      {
4069        return this._TotalRuntime;
4070      }
4071      set
4072      {
4073        if ((this._TotalRuntime != value))
4074        {
4075          this.OnCalculatingTimeChanging(value);
4076          this.SendPropertyChanging();
4077          this._TotalRuntime = value;
4078          this.SendPropertyChanged("CalculatingTime");
4079          this.OnCalculatingTimeChanged();
4080        }
4081      }
4082    }
4083   
4084    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalWaitingTime", DbType="INT NOT NULL")]
4085    public long WaitingTime
4086    {
4087      get
4088      {
4089        return this._TotalWaitingTime;
4090      }
4091      set
4092      {
4093        if ((this._TotalWaitingTime != value))
4094        {
4095          this.OnWaitingTimeChanging(value);
4096          this.SendPropertyChanging();
4097          this._TotalWaitingTime = value;
4098          this.SendPropertyChanged("WaitingTime");
4099          this.OnWaitingTimeChanged();
4100        }
4101      }
4102    }
4103   
4104    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTransferTime", DbType="INT NOT NULL")]
4105    public long TransferTime
4106    {
4107      get
4108      {
4109        return this._TotalTransferTime;
4110      }
4111      set
4112      {
4113        if ((this._TotalTransferTime != value))
4114        {
4115          this.OnTransferTimeChanging(value);
4116          this.SendPropertyChanging();
4117          this._TotalTransferTime = value;
4118          this.SendPropertyChanged("TransferTime");
4119          this.OnTransferTimeChanged();
4120        }
4121      }
4122    }
4123   
4124    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumCalculationRuns", DbType="Int NOT NULL")]
4125    public int NumCalculationRuns
4126    {
4127      get
4128      {
4129        return this._NumCalculationRuns;
4130      }
4131      set
4132      {
4133        if ((this._NumCalculationRuns != value))
4134        {
4135          this.OnNumCalculationRunsChanging(value);
4136          this.SendPropertyChanging();
4137          this._NumCalculationRuns = value;
4138          this.SendPropertyChanged("NumCalculationRuns");
4139          this.OnNumCalculationRunsChanged();
4140        }
4141      }
4142    }
4143   
4144    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumFails", DbType="Int NOT NULL")]
4145    public int NumRetries
4146    {
4147      get
4148      {
4149        return this._NumFails;
4150      }
4151      set
4152      {
4153        if ((this._NumFails != value))
4154        {
4155          this.OnNumRetriesChanging(value);
4156          this.SendPropertyChanging();
4157          this._NumFails = value;
4158          this.SendPropertyChanged("NumRetries");
4159          this.OnNumRetriesChanged();
4160        }
4161      }
4162    }
4163   
4164    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CoresRequired", DbType="Int NOT NULL")]
4165    public int CoresRequired
4166    {
4167      get
4168      {
4169        return this._CoresRequired;
4170      }
4171      set
4172      {
4173        if ((this._CoresRequired != value))
4174        {
4175          this.OnCoresRequiredChanging(value);
4176          this.SendPropertyChanging();
4177          this._CoresRequired = value;
4178          this.SendPropertyChanged("CoresRequired");
4179          this.OnCoresRequiredChanged();
4180        }
4181      }
4182    }
4183   
4184    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_MemoryRequired", DbType="Int NOT NULL")]
4185    public int MemoryRequired
4186    {
4187      get
4188      {
4189        return this._MemoryRequired;
4190      }
4191      set
4192      {
4193        if ((this._MemoryRequired != value))
4194        {
4195          this.OnMemoryRequiredChanging(value);
4196          this.SendPropertyChanging();
4197          this._MemoryRequired = value;
4198          this.SendPropertyChanged("MemoryRequired");
4199          this.OnMemoryRequiredChanged();
4200        }
4201      }
4202    }
4203   
4204    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Priority", DbType="Int NOT NULL")]
4205    public int Priority
4206    {
4207      get
4208      {
4209        return this._Priority;
4210      }
4211      set
4212      {
4213        if ((this._Priority != value))
4214        {
4215          this.OnPriorityChanging(value);
4216          this.SendPropertyChanging();
4217          this._Priority = value;
4218          this.SendPropertyChanged("Priority");
4219          this.OnPriorityChanged();
4220        }
4221      }
4222    }
4223   
4224    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastClientId", DbType="UniqueIdentifier NOT NULL")]
4225    public System.Nullable<System.Guid> LastClientId
4226    {
4227      get
4228      {
4229        return this._LastClientId;
4230      }
4231      set
4232      {
4233        if ((this._LastClientId != value))
4234        {
4235          if (this._DimClient.HasLoadedOrAssignedValue)
4236          {
4237            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
4238          }
4239          this.OnLastClientIdChanging(value);
4240          this.SendPropertyChanging();
4241          this._LastClientId = value;
4242          this.SendPropertyChanged("LastClientId");
4243          this.OnLastClientIdChanged();
4244        }
4245      }
4246    }
4247   
4248    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL")]
4249    public System.Guid JobId
4250    {
4251      get
4252      {
4253        return this._JobId;
4254      }
4255      set
4256      {
4257        if ((this._JobId != value))
4258        {
4259          if (this._DimJob.HasLoadedOrAssignedValue)
4260          {
4261            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
4262          }
4263          this.OnJobIdChanging(value);
4264          this.SendPropertyChanging();
4265          this._JobId = value;
4266          this.SendPropertyChanged("JobId");
4267          this.OnJobIdChanged();
4268        }
4269      }
4270    }
4271   
4272    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_EndTime", DbType="DateTime NOT NULL")]
4273    public System.Nullable<System.DateTime> EndTime
4274    {
4275      get
4276      {
4277        return this._EndTime;
4278      }
4279      set
4280      {
4281        if ((this._EndTime != value))
4282        {
4283          this.OnEndTimeChanging(value);
4284          this.SendPropertyChanging();
4285          this._EndTime = value;
4286          this.SendPropertyChanged("EndTime");
4287          this.OnEndTimeChanged();
4288        }
4289      }
4290    }
4291   
4292    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TaskState", DbType="varchar(30)", CanBeNull=false)]
4293    public global::HeuristicLab.Services.Hive.DataAccess.TaskState TaskState
4294    {
4295      get
4296      {
4297        return this._TaskState;
4298      }
4299      set
4300      {
4301        if ((this._TaskState != value))
4302        {
4303          this.OnTaskStateChanging(value);
4304          this.SendPropertyChanging();
4305          this._TaskState = value;
4306          this.SendPropertyChanged("TaskState");
4307          this.OnTaskStateChanged();
4308        }
4309      }
4310    }
4311   
4312    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Exception", DbType="varchar(MAX)")]
4313    public string Exception
4314    {
4315      get
4316      {
4317        return this._Exception;
4318      }
4319      set
4320      {
4321        if ((this._Exception != value))
4322        {
4323          this.OnExceptionChanging(value);
4324          this.SendPropertyChanging();
4325          this._Exception = value;
4326          this.SendPropertyChanged("Exception");
4327          this.OnExceptionChanged();
4328        }
4329      }
4330    }
4331   
4332    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_InitialWaitingTimeMs", DbType="INT")]
4333    public long InitialWaitingTime
4334    {
4335      get
4336      {
4337        return this._InitialWaitingTimeMs;
4338      }
4339      set
4340      {
4341        if ((this._InitialWaitingTimeMs != value))
4342        {
4343          this.OnInitialWaitingTimeChanging(value);
4344          this.SendPropertyChanging();
4345          this._InitialWaitingTimeMs = value;
4346          this.SendPropertyChanged("InitialWaitingTime");
4347          this.OnInitialWaitingTimeChanged();
4348        }
4349      }
4350    }
4351   
4352    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StartTime")]
4353    public System.Nullable<System.DateTime> StartTime
4354    {
4355      get
4356      {
4357        return this._StartTime;
4358      }
4359      set
4360      {
4361        if ((this._StartTime != value))
4362        {
4363          this.OnStartTimeChanging(value);
4364          this.SendPropertyChanging();
4365          this._StartTime = value;
4366          this.SendPropertyChanged("StartTime");
4367          this.OnStartTimeChanged();
4368        }
4369      }
4370    }
4371   
4372    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactTask", Storage="_DimClient", ThisKey="LastClientId", OtherKey="Id", IsForeignKey=true)]
4373    public DimClient DimClient
4374    {
4375      get
4376      {
4377        return this._DimClient.Entity;
4378      }
4379      set
4380      {
4381        DimClient previousValue = this._DimClient.Entity;
4382        if (((previousValue != value)
4383              || (this._DimClient.HasLoadedOrAssignedValue == false)))
4384        {
4385          this.SendPropertyChanging();
4386          if ((previousValue != null))
4387          {
4388            this._DimClient.Entity = null;
4389            previousValue.FactTasks.Remove(this);
4390          }
4391          this._DimClient.Entity = value;
4392          if ((value != null))
4393          {
4394            value.FactTasks.Add(this);
4395            this._LastClientId = value.Id;
4396          }
4397          else
4398          {
4399            this._LastClientId = default(Nullable<System.Guid>);
4400          }
4401          this.SendPropertyChanged("DimClient");
4402        }
4403      }
4404    }
4405   
4406    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimJob_FactTask", Storage="_DimJob", ThisKey="JobId", OtherKey="JobId", IsForeignKey=true)]
4407    public DimJob DimJob
4408    {
4409      get
4410      {
4411        return this._DimJob.Entity;
4412      }
4413      set
4414      {
4415        DimJob previousValue = this._DimJob.Entity;
4416        if (((previousValue != value)
4417              || (this._DimJob.HasLoadedOrAssignedValue == false)))
4418        {
4419          this.SendPropertyChanging();
4420          if ((previousValue != null))
4421          {
4422            this._DimJob.Entity = null;
4423            previousValue.FactTasks.Remove(this);
4424          }
4425          this._DimJob.Entity = value;
4426          if ((value != null))
4427          {
4428            value.FactTasks.Add(this);
4429            this._JobId = value.JobId;
4430          }
4431          else
4432          {
4433            this._JobId = default(System.Guid);
4434          }
4435          this.SendPropertyChanged("DimJob");
4436        }
4437      }
4438    }
4439   
4440    public event PropertyChangingEventHandler PropertyChanging;
4441   
4442    public event PropertyChangedEventHandler PropertyChanged;
4443   
4444    protected virtual void SendPropertyChanging()
4445    {
4446      if ((this.PropertyChanging != null))
4447      {
4448        this.PropertyChanging(this, emptyChangingEventArgs);
4449      }
4450    }
4451   
4452    protected virtual void SendPropertyChanged(String propertyName)
4453    {
4454      if ((this.PropertyChanged != null))
4455      {
4456        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
4457      }
4458    }
4459  }
4460 
4461  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimJob")]
4462  public partial class DimJob : INotifyPropertyChanging, INotifyPropertyChanged
4463  {
4464   
4465    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
4466   
4467    private System.Guid _JobId;
4468   
4469    private System.Guid _UserId;
4470   
4471    private string _JobName;
4472   
4473    private string _UserName;
4474   
4475    private System.DateTime _DateCreated;
4476   
4477    private int _TotalTasks;
4478   
4479    private int _CompletedTasks;
4480   
4481    private System.Nullable<System.DateTime> _DateCompleted;
4482   
4483    private EntitySet<FactTask> _FactTasks;
4484   
4485    #region Extensibility Method Definitions
4486    partial void OnLoaded();
4487    partial void OnValidate(System.Data.Linq.ChangeAction action);
4488    partial void OnCreated();
4489    partial void OnJobIdChanging(System.Guid value);
4490    partial void OnJobIdChanged();
4491    partial void OnUserIdChanging(System.Guid value);
4492    partial void OnUserIdChanged();
4493    partial void OnJobNameChanging(string value);
4494    partial void OnJobNameChanged();
4495    partial void OnUserNameChanging(string value);
4496    partial void OnUserNameChanged();
4497    partial void OnDateCreatedChanging(System.DateTime value);
4498    partial void OnDateCreatedChanged();
4499    partial void OnTotalTasksChanging(int value);
4500    partial void OnTotalTasksChanged();
4501    partial void OnCompletedTasksChanging(int value);
4502    partial void OnCompletedTasksChanged();
4503    partial void OnDateCompletedChanging(System.Nullable<System.DateTime> value);
4504    partial void OnDateCompletedChanged();
4505    #endregion
4506   
4507    public DimJob()
4508    {
4509      this._FactTasks = new EntitySet<FactTask>(new Action<FactTask>(this.attach_FactTasks), new Action<FactTask>(this.detach_FactTasks));
4510      OnCreated();
4511    }
4512   
4513    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
4514    public System.Guid JobId
4515    {
4516      get
4517      {
4518        return this._JobId;
4519      }
4520      set
4521      {
4522        if ((this._JobId != value))
4523        {
4524          this.OnJobIdChanging(value);
4525          this.SendPropertyChanging();
4526          this._JobId = value;
4527          this.SendPropertyChanged("JobId");
4528          this.OnJobIdChanged();
4529        }
4530      }
4531    }
4532   
4533    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL")]
4534    public System.Guid UserId
4535    {
4536      get
4537      {
4538        return this._UserId;
4539      }
4540      set
4541      {
4542        if ((this._UserId != value))
4543        {
4544          this.OnUserIdChanging(value);
4545          this.SendPropertyChanging();
4546          this._UserId = value;
4547          this.SendPropertyChanged("UserId");
4548          this.OnUserIdChanged();
4549        }
4550      }
4551    }
4552   
4553    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobName", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
4554    public string JobName
4555    {
4556      get
4557      {
4558        return this._JobName;
4559      }
4560      set
4561      {
4562        if ((this._JobName != value))
4563        {
4564          this.OnJobNameChanging(value);
4565          this.SendPropertyChanging();
4566          this._JobName = value;
4567          this.SendPropertyChanged("JobName");
4568          this.OnJobNameChanged();
4569        }
4570      }
4571    }
4572   
4573    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserName", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
4574    public string UserName
4575    {
4576      get
4577      {
4578        return this._UserName;
4579      }
4580      set
4581      {
4582        if ((this._UserName != value))
4583        {
4584          this.OnUserNameChanging(value);
4585          this.SendPropertyChanging();
4586          this._UserName = value;
4587          this.SendPropertyChanged("UserName");
4588          this.OnUserNameChanged();
4589        }
4590      }
4591    }
4592   
4593    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateCreated", DbType="DateTime NOT NULL")]
4594    public System.DateTime DateCreated
4595    {
4596      get
4597      {
4598        return this._DateCreated;
4599      }
4600      set
4601      {
4602        if ((this._DateCreated != value))
4603        {
4604          this.OnDateCreatedChanging(value);
4605          this.SendPropertyChanging();
4606          this._DateCreated = value;
4607          this.SendPropertyChanged("DateCreated");
4608          this.OnDateCreatedChanged();
4609        }
4610      }
4611    }
4612   
4613    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTasks", DbType="INT NOT NULL")]
4614    public int TotalTasks
4615    {
4616      get
4617      {
4618        return this._TotalTasks;
4619      }
4620      set
4621      {
4622        if ((this._TotalTasks != value))
4623        {
4624          this.OnTotalTasksChanging(value);
4625          this.SendPropertyChanging();
4626          this._TotalTasks = value;
4627          this.SendPropertyChanged("TotalTasks");
4628          this.OnTotalTasksChanged();
4629        }
4630      }
4631    }
4632   
4633    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CompletedTasks", DbType="INT NOT NULL")]
4634    public int CompletedTasks
4635    {
4636      get
4637      {
4638        return this._CompletedTasks;
4639      }
4640      set
4641      {
4642        if ((this._CompletedTasks != value))
4643        {
4644          this.OnCompletedTasksChanging(value);
4645          this.SendPropertyChanging();
4646          this._CompletedTasks = value;
4647          this.SendPropertyChanged("CompletedTasks");
4648          this.OnCompletedTasksChanged();
4649        }
4650      }
4651    }
4652   
4653    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateCompleted", DbType="DateTime NULL")]
4654    public System.Nullable<System.DateTime> DateCompleted
4655    {
4656      get
4657      {
4658        return this._DateCompleted;
4659      }
4660      set
4661      {
4662        if ((this._DateCompleted != value))
4663        {
4664          this.OnDateCompletedChanging(value);
4665          this.SendPropertyChanging();
4666          this._DateCompleted = value;
4667          this.SendPropertyChanged("DateCompleted");
4668          this.OnDateCompletedChanged();
4669        }
4670      }
4671    }
4672   
4673    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimJob_FactTask", Storage="_FactTasks", ThisKey="JobId", OtherKey="JobId")]
4674    public EntitySet<FactTask> FactTasks
4675    {
4676      get
4677      {
4678        return this._FactTasks;
4679      }
4680      set
4681      {
4682        this._FactTasks.Assign(value);
4683      }
4684    }
4685   
4686    public event PropertyChangingEventHandler PropertyChanging;
4687   
4688    public event PropertyChangedEventHandler PropertyChanged;
4689   
4690    protected virtual void SendPropertyChanging()
4691    {
4692      if ((this.PropertyChanging != null))
4693      {
4694        this.PropertyChanging(this, emptyChangingEventArgs);
4695      }
4696    }
4697   
4698    protected virtual void SendPropertyChanged(String propertyName)
4699    {
4700      if ((this.PropertyChanged != null))
4701      {
4702        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
4703      }
4704    }
4705   
4706    private void attach_FactTasks(FactTask entity)
4707    {
4708      this.SendPropertyChanging();
4709      entity.DimJob = this;
4710    }
4711   
4712    private void detach_FactTasks(FactTask entity)
4713    {
4714      this.SendPropertyChanging();
4715      entity.DimJob = null;
4716    }
4717  }
4718 
4719  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimTime")]
4720  public partial class DimTime : INotifyPropertyChanging, INotifyPropertyChanged
4721  {
4722   
4723    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
4724   
4725    private System.DateTime _Time;
4726   
4727    private System.DateTime _Hour;
4728   
4729    private System.DateTime _Day;
4730   
4731    private System.DateTime _Month;
4732   
4733    private System.DateTime _Year;
4734   
4735    private System.DateTime _Minute;
4736   
4737    private EntitySet<FactClientInfo> _FactClientInfos;
4738   
4739    #region Extensibility Method Definitions
4740    partial void OnLoaded();
4741    partial void OnValidate(System.Data.Linq.ChangeAction action);
4742    partial void OnCreated();
4743    partial void OnTimeChanging(System.DateTime value);
4744    partial void OnTimeChanged();
4745    partial void OnHourChanging(System.DateTime value);
4746    partial void OnHourChanged();
4747    partial void OnDayChanging(System.DateTime value);
4748    partial void OnDayChanged();
4749    partial void OnMonthChanging(System.DateTime value);
4750    partial void OnMonthChanged();
4751    partial void OnYearChanging(System.DateTime value);
4752    partial void OnYearChanged();
4753    partial void OnMinuteChanging(System.DateTime value);
4754    partial void OnMinuteChanged();
4755    #endregion
4756   
4757    public DimTime()
4758    {
4759      this._FactClientInfos = new EntitySet<FactClientInfo>(new Action<FactClientInfo>(this.attach_FactClientInfos), new Action<FactClientInfo>(this.detach_FactClientInfos));
4760      OnCreated();
4761    }
4762   
4763    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Time", DbType="DateTime NOT NULL", IsPrimaryKey=true)]
4764    public System.DateTime Time
4765    {
4766      get
4767      {
4768        return this._Time;
4769      }
4770      set
4771      {
4772        if ((this._Time != value))
4773        {
4774          this.OnTimeChanging(value);
4775          this.SendPropertyChanging();
4776          this._Time = value;
4777          this.SendPropertyChanged("Time");
4778          this.OnTimeChanged();
4779        }
4780      }
4781    }
4782   
4783    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Hour", DbType="DateTime NOT NULL")]
4784    public System.DateTime Hour
4785    {
4786      get
4787      {
4788        return this._Hour;
4789      }
4790      set
4791      {
4792        if ((this._Hour != value))
4793        {
4794          this.OnHourChanging(value);
4795          this.SendPropertyChanging();
4796          this._Hour = value;
4797          this.SendPropertyChanged("Hour");
4798          this.OnHourChanged();
4799        }
4800      }
4801    }
4802   
4803    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Day", DbType="Date NOT NULL")]
4804    public System.DateTime Day
4805    {
4806      get
4807      {
4808        return this._Day;
4809      }
4810      set
4811      {
4812        if ((this._Day != value))
4813        {
4814          this.OnDayChanging(value);
4815          this.SendPropertyChanging();
4816          this._Day = value;
4817          this.SendPropertyChanged("Day");
4818          this.OnDayChanged();
4819        }
4820      }
4821    }
4822   
4823    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Month", DbType="Date NOT NULL")]
4824    public System.DateTime Month
4825    {
4826      get
4827      {
4828        return this._Month;
4829      }
4830      set
4831      {
4832        if ((this._Month != value))
4833        {
4834          this.OnMonthChanging(value);
4835          this.SendPropertyChanging();
4836          this._Month = value;
4837          this.SendPropertyChanged("Month");
4838          this.OnMonthChanged();
4839        }
4840      }
4841    }
4842   
4843    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Year", DbType="Date NOT NULL")]
4844    public System.DateTime Year
4845    {
4846      get
4847      {
4848        return this._Year;
4849      }
4850      set
4851      {
4852        if ((this._Year != value))
4853        {
4854          this.OnYearChanging(value);
4855          this.SendPropertyChanging();
4856          this._Year = value;
4857          this.SendPropertyChanged("Year");
4858          this.OnYearChanged();
4859        }
4860      }
4861    }
4862   
4863    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Minute")]
4864    public System.DateTime Minute
4865    {
4866      get
4867      {
4868        return this._Minute;
4869      }
4870      set
4871      {
4872        if ((this._Minute != value))
4873        {
4874          this.OnMinuteChanging(value);
4875          this.SendPropertyChanging();
4876          this._Minute = value;
4877          this.SendPropertyChanged("Minute");
4878          this.OnMinuteChanged();
4879        }
4880      }
4881    }
4882   
4883    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimTime_FactClientInfo", Storage="_FactClientInfos", ThisKey="Time", OtherKey="Time")]
4884    public EntitySet<FactClientInfo> FactClientInfos
4885    {
4886      get
4887      {
4888        return this._FactClientInfos;
4889      }
4890      set
4891      {
4892        this._FactClientInfos.Assign(value);
4893      }
4894    }
4895   
4896    public event PropertyChangingEventHandler PropertyChanging;
4897   
4898    public event PropertyChangedEventHandler PropertyChanged;
4899   
4900    protected virtual void SendPropertyChanging()
4901    {
4902      if ((this.PropertyChanging != null))
4903      {
4904        this.PropertyChanging(this, emptyChangingEventArgs);
4905      }
4906    }
4907   
4908    protected virtual void SendPropertyChanged(String propertyName)
4909    {
4910      if ((this.PropertyChanged != null))
4911      {
4912        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
4913      }
4914    }
4915   
4916    private void attach_FactClientInfos(FactClientInfo entity)
4917    {
4918      this.SendPropertyChanging();
4919      entity.DimTime = this;
4920    }
4921   
4922    private void detach_FactClientInfos(FactClientInfo entity)
4923    {
4924      this.SendPropertyChanging();
4925      entity.DimTime = null;
4926    }
4927  }
4928 
4929  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimUser")]
4930  public partial class DimUser : INotifyPropertyChanging, INotifyPropertyChanged
4931  {
4932   
4933    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
4934   
4935    private System.Guid _UserId;
4936   
4937    private string _Name;
4938   
4939    private EntitySet<FactClientInfo> _FactClientInfos;
4940   
4941    #region Extensibility Method Definitions
4942    partial void OnLoaded();
4943    partial void OnValidate(System.Data.Linq.ChangeAction action);
4944    partial void OnCreated();
4945    partial void OnUserIdChanging(System.Guid value);
4946    partial void OnUserIdChanged();
4947    partial void OnNameChanging(string value);
4948    partial void OnNameChanged();
4949    #endregion
4950   
4951    public DimUser()
4952    {
4953      this._FactClientInfos = new EntitySet<FactClientInfo>(new Action<FactClientInfo>(this.attach_FactClientInfos), new Action<FactClientInfo>(this.detach_FactClientInfos));
4954      OnCreated();
4955    }
4956   
4957    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
4958    public System.Guid UserId
4959    {
4960      get
4961      {
4962        return this._UserId;
4963      }
4964      set
4965      {
4966        if ((this._UserId != value))
4967        {
4968          this.OnUserIdChanging(value);
4969          this.SendPropertyChanging();
4970          this._UserId = value;
4971          this.SendPropertyChanged("UserId");
4972          this.OnUserIdChanged();
4973        }
4974      }
4975    }
4976   
4977    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
4978    public string Name
4979    {
4980      get
4981      {
4982        return this._Name;
4983      }
4984      set
4985      {
4986        if ((this._Name != value))
4987        {
4988          this.OnNameChanging(value);
4989          this.SendPropertyChanging();
4990          this._Name = value;
4991          this.SendPropertyChanged("Name");
4992          this.OnNameChanged();
4993        }
4994      }
4995    }
4996   
4997    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimUser_FactClientInfo", Storage="_FactClientInfos", ThisKey="UserId", OtherKey="UserId")]
4998    public EntitySet<FactClientInfo> FactClientInfos
4999    {
5000      get
5001      {
5002        return this._FactClientInfos;
5003      }
5004      set
5005      {
5006        this._FactClientInfos.Assign(value);
5007      }
5008    }
5009   
5010    public event PropertyChangingEventHandler PropertyChanging;
5011   
5012    public event PropertyChangedEventHandler PropertyChanged;
5013   
5014    protected virtual void SendPropertyChanging()
5015    {
5016      if ((this.PropertyChanging != null))
5017      {
5018        this.PropertyChanging(this, emptyChangingEventArgs);
5019      }
5020    }
5021   
5022    protected virtual void SendPropertyChanged(String propertyName)
5023    {
5024      if ((this.PropertyChanged != null))
5025      {
5026        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
5027      }
5028    }
5029   
5030    private void attach_FactClientInfos(FactClientInfo entity)
5031    {
5032      this.SendPropertyChanging();
5033      entity.DimUser = this;
5034    }
5035   
5036    private void detach_FactClientInfos(FactClientInfo entity)
5037    {
5038      this.SendPropertyChanging();
5039      entity.DimUser = null;
5040    }
5041  }
5042 
5043  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].FactClientInfo")]
5044  public partial class FactClientInfo : INotifyPropertyChanging, INotifyPropertyChanged
5045  {
5046   
5047    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
5048   
5049    private System.Guid _ClientId;
5050   
5051    private System.DateTime _Time;
5052   
5053    private System.Guid _UserId;
5054   
5055    private int _NumUsedCores;
5056   
5057    private int _NumTotalCores;
5058   
5059    private int _UsedMemory;
5060   
5061    private int _TotalMemory;
5062   
5063    private double _CpuUtilization;
5064   
5065    private long _TotalTimeIdle;
5066   
5067    private long _TotalTimeOffline;
5068   
5069    private long _TotalTimeUnavailable;
5070   
5071    private global::HeuristicLab.Services.Hive.DataAccess.SlaveState _SlaveState;
5072   
5073    private bool _IsAllowedToCalculate;
5074   
5075    private EntityRef<DimClient> _DimClient;
5076   
5077    private EntityRef<DimTime> _DimTime;
5078   
5079    private EntityRef<DimUser> _DimUser;
5080   
5081    #region Extensibility Method Definitions
5082    partial void OnLoaded();
5083    partial void OnValidate(System.Data.Linq.ChangeAction action);
5084    partial void OnCreated();
5085    partial void OnClientIdChanging(System.Guid value);
5086    partial void OnClientIdChanged();
5087    partial void OnTimeChanging(System.DateTime value);
5088    partial void OnTimeChanged();
5089    partial void OnUserIdChanging(System.Guid value);
5090    partial void OnUserIdChanged();
5091    partial void OnNumUsedCoresChanging(int value);
5092    partial void OnNumUsedCoresChanged();
5093    partial void OnNumTotalCoresChanging(int value);
5094    partial void OnNumTotalCoresChanged();
5095    partial void OnUsedMemoryChanging(int value);
5096    partial void OnUsedMemoryChanged();
5097    partial void OnTotalMemoryChanging(int value);
5098    partial void OnTotalMemoryChanged();
5099    partial void OnCpuUtilizationChanging(double value);
5100    partial void OnCpuUtilizationChanged();
5101    partial void OnIdleTimeChanging(long value);
5102    partial void OnIdleTimeChanged();
5103    partial void OnOfflineTimeChanging(long value);
5104    partial void OnOfflineTimeChanged();
5105    partial void OnUnavailableTimeChanging(long value);
5106    partial void OnUnavailableTimeChanged();
5107    partial void OnSlaveStateChanging(global::HeuristicLab.Services.Hive.DataAccess.SlaveState value);
5108    partial void OnSlaveStateChanged();
5109    partial void OnIsAllowedToCalculateChanging(bool value);
5110    partial void OnIsAllowedToCalculateChanged();
5111    #endregion
5112   
5113    public FactClientInfo()
5114    {
5115      this._DimClient = default(EntityRef<DimClient>);
5116      this._DimTime = default(EntityRef<DimTime>);
5117      this._DimUser = default(EntityRef<DimUser>);
5118      OnCreated();
5119    }
5120   
5121    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ClientId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
5122    public System.Guid ClientId
5123    {
5124      get
5125      {
5126        return this._ClientId;
5127      }
5128      set
5129      {
5130        if ((this._ClientId != value))
5131        {
5132          if (this._DimClient.HasLoadedOrAssignedValue)
5133          {
5134            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
5135          }
5136          this.OnClientIdChanging(value);
5137          this.SendPropertyChanging();
5138          this._ClientId = value;
5139          this.SendPropertyChanged("ClientId");
5140          this.OnClientIdChanged();
5141        }
5142      }
5143    }
5144   
5145    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Time", DbType="DateTime NOT NULL", IsPrimaryKey=true)]
5146    public System.DateTime Time
5147    {
5148      get
5149      {
5150        return this._Time;
5151      }
5152      set
5153      {
5154        if ((this._Time != value))
5155        {
5156          if (this._DimTime.HasLoadedOrAssignedValue)
5157          {
5158            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
5159          }
5160          this.OnTimeChanging(value);
5161          this.SendPropertyChanging();
5162          this._Time = value;
5163          this.SendPropertyChanged("Time");
5164          this.OnTimeChanged();
5165        }
5166      }
5167    }
5168   
5169    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
5170    public System.Guid UserId
5171    {
5172      get
5173      {
5174        return this._UserId;
5175      }
5176      set
5177      {
5178        if ((this._UserId != value))
5179        {
5180          if (this._DimUser.HasLoadedOrAssignedValue)
5181          {
5182            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
5183          }
5184          this.OnUserIdChanging(value);
5185          this.SendPropertyChanging();
5186          this._UserId = value;
5187          this.SendPropertyChanged("UserId");
5188          this.OnUserIdChanged();
5189        }
5190      }
5191    }
5192   
5193    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumUsedCores", DbType="Int NOT NULL")]
5194    public int NumUsedCores
5195    {
5196      get
5197      {
5198        return this._NumUsedCores;
5199      }
5200      set
5201      {
5202        if ((this._NumUsedCores != value))
5203        {
5204          this.OnNumUsedCoresChanging(value);
5205          this.SendPropertyChanging();
5206          this._NumUsedCores = value;
5207          this.SendPropertyChanged("NumUsedCores");
5208          this.OnNumUsedCoresChanged();
5209        }
5210      }
5211    }
5212   
5213    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumTotalCores", DbType="Int NOT NULL")]
5214    public int NumTotalCores
5215    {
5216      get
5217      {
5218        return this._NumTotalCores;
5219      }
5220      set
5221      {
5222        if ((this._NumTotalCores != value))
5223        {
5224          this.OnNumTotalCoresChanging(value);
5225          this.SendPropertyChanging();
5226          this._NumTotalCores = value;
5227          this.SendPropertyChanged("NumTotalCores");
5228          this.OnNumTotalCoresChanged();
5229        }
5230      }
5231    }
5232   
5233    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UsedMemory", DbType="Int NOT NULL")]
5234    public int UsedMemory
5235    {
5236      get
5237      {
5238        return this._UsedMemory;
5239      }
5240      set
5241      {
5242        if ((this._UsedMemory != value))
5243        {
5244          this.OnUsedMemoryChanging(value);
5245          this.SendPropertyChanging();
5246          this._UsedMemory = value;
5247          this.SendPropertyChanged("UsedMemory");
5248          this.OnUsedMemoryChanged();
5249        }
5250      }
5251    }
5252   
5253    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalMemory", DbType="Int NOT NULL")]
5254    public int TotalMemory
5255    {
5256      get
5257      {
5258        return this._TotalMemory;
5259      }
5260      set
5261      {
5262        if ((this._TotalMemory != value))
5263        {
5264          this.OnTotalMemoryChanging(value);
5265          this.SendPropertyChanging();
5266          this._TotalMemory = value;
5267          this.SendPropertyChanged("TotalMemory");
5268          this.OnTotalMemoryChanged();
5269        }
5270      }
5271    }
5272   
5273    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CpuUtilization", DbType="Float NOT NULL")]
5274    public double CpuUtilization
5275    {
5276      get
5277      {
5278        return this._CpuUtilization;
5279      }
5280      set
5281      {
5282        if ((this._CpuUtilization != value))
5283        {
5284          this.OnCpuUtilizationChanging(value);
5285          this.SendPropertyChanging();
5286          this._CpuUtilization = value;
5287          this.SendPropertyChanged("CpuUtilization");
5288          this.OnCpuUtilizationChanged();
5289        }
5290      }
5291    }
5292   
5293    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTimeIdle", DbType="INT NOT NULL")]
5294    public long IdleTime
5295    {
5296      get
5297      {
5298        return this._TotalTimeIdle;
5299      }
5300      set
5301      {
5302        if ((this._TotalTimeIdle != value))
5303        {
5304          this.OnIdleTimeChanging(value);
5305          this.SendPropertyChanging();
5306          this._TotalTimeIdle = value;
5307          this.SendPropertyChanged("IdleTime");
5308          this.OnIdleTimeChanged();
5309        }
5310      }
5311    }
5312   
5313    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTimeOffline", DbType="INT NOT NULL")]
5314    public long OfflineTime
5315    {
5316      get
5317      {
5318        return this._TotalTimeOffline;
5319      }
5320      set
5321      {
5322        if ((this._TotalTimeOffline != value))
5323        {
5324          this.OnOfflineTimeChanging(value);
5325          this.SendPropertyChanging();
5326          this._TotalTimeOffline = value;
5327          this.SendPropertyChanged("OfflineTime");
5328          this.OnOfflineTimeChanged();
5329        }
5330      }
5331    }
5332   
5333    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTimeUnavailable", DbType="INT NOT NULL")]
5334    public long UnavailableTime
5335    {
5336      get
5337      {
5338        return this._TotalTimeUnavailable;
5339      }
5340      set
5341      {
5342        if ((this._TotalTimeUnavailable != value))
5343        {
5344          this.OnUnavailableTimeChanging(value);
5345          this.SendPropertyChanging();
5346          this._TotalTimeUnavailable = value;
5347          this.SendPropertyChanged("UnavailableTime");
5348          this.OnUnavailableTimeChanged();
5349        }
5350      }
5351    }
5352   
5353    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_SlaveState", DbType="VarChar(15)", CanBeNull=false)]
5354    public global::HeuristicLab.Services.Hive.DataAccess.SlaveState SlaveState
5355    {
5356      get
5357      {
5358        return this._SlaveState;
5359      }
5360      set
5361      {
5362        if ((this._SlaveState != value))
5363        {
5364          this.OnSlaveStateChanging(value);
5365          this.SendPropertyChanging();
5366          this._SlaveState = value;
5367          this.SendPropertyChanged("SlaveState");
5368          this.OnSlaveStateChanged();
5369        }
5370      }
5371    }
5372   
5373    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsAllowedToCalculate", DbType="BIT")]
5374    public bool IsAllowedToCalculate
5375    {
5376      get
5377      {
5378        return this._IsAllowedToCalculate;
5379      }
5380      set
5381      {
5382        if ((this._IsAllowedToCalculate != value))
5383        {
5384          this.OnIsAllowedToCalculateChanging(value);
5385          this.SendPropertyChanging();
5386          this._IsAllowedToCalculate = value;
5387          this.SendPropertyChanged("IsAllowedToCalculate");
5388          this.OnIsAllowedToCalculateChanged();
5389        }
5390      }
5391    }
5392   
5393    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactClientInfo", Storage="_DimClient", ThisKey="ClientId", OtherKey="Id", IsForeignKey=true)]
5394    public DimClient DimClient
5395    {
5396      get
5397      {
5398        return this._DimClient.Entity;
5399      }
5400      set
5401      {
5402        DimClient previousValue = this._DimClient.Entity;
5403        if (((previousValue != value)
5404              || (this._DimClient.HasLoadedOrAssignedValue == false)))
5405        {
5406          this.SendPropertyChanging();
5407          if ((previousValue != null))
5408          {
5409            this._DimClient.Entity = null;
5410            previousValue.FactClientInfos.Remove(this);
5411          }
5412          this._DimClient.Entity = value;
5413          if ((value != null))
5414          {
5415            value.FactClientInfos.Add(this);
5416            this._ClientId = value.Id;
5417          }
5418          else
5419          {
5420            this._ClientId = default(System.Guid);
5421          }
5422          this.SendPropertyChanged("DimClient");
5423        }
5424      }
5425    }
5426   
5427    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimTime_FactClientInfo", Storage="_DimTime", ThisKey="Time", OtherKey="Time", IsForeignKey=true)]
5428    public DimTime DimTime
5429    {
5430      get
5431      {
5432        return this._DimTime.Entity;
5433      }
5434      set
5435      {
5436        DimTime previousValue = this._DimTime.Entity;
5437        if (((previousValue != value)
5438              || (this._DimTime.HasLoadedOrAssignedValue == false)))
5439        {
5440          this.SendPropertyChanging();
5441          if ((previousValue != null))
5442          {
5443            this._DimTime.Entity = null;
5444            previousValue.FactClientInfos.Remove(this);
5445          }
5446          this._DimTime.Entity = value;
5447          if ((value != null))
5448          {
5449            value.FactClientInfos.Add(this);
5450            this._Time = value.Time;
5451          }
5452          else
5453          {
5454            this._Time = default(System.DateTime);
5455          }
5456          this.SendPropertyChanged("DimTime");
5457        }
5458      }
5459    }
5460   
5461    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimUser_FactClientInfo", Storage="_DimUser", ThisKey="UserId", OtherKey="UserId", IsForeignKey=true)]
5462    public DimUser DimUser
5463    {
5464      get
5465      {
5466        return this._DimUser.Entity;
5467      }
5468      set
5469      {
5470        DimUser previousValue = this._DimUser.Entity;
5471        if (((previousValue != value)
5472              || (this._DimUser.HasLoadedOrAssignedValue == false)))
5473        {
5474          this.SendPropertyChanging();
5475          if ((previousValue != null))
5476          {
5477            this._DimUser.Entity = null;
5478            previousValue.FactClientInfos.Remove(this);
5479          }
5480          this._DimUser.Entity = value;
5481          if ((value != null))
5482          {
5483            value.FactClientInfos.Add(this);
5484            this._UserId = value.UserId;
5485          }
5486          else
5487          {
5488            this._UserId = default(System.Guid);
5489          }
5490          this.SendPropertyChanged("DimUser");
5491        }
5492      }
5493    }
5494   
5495    public event PropertyChangingEventHandler PropertyChanging;
5496   
5497    public event PropertyChangedEventHandler PropertyChanged;
5498   
5499    protected virtual void SendPropertyChanging()
5500    {
5501      if ((this.PropertyChanging != null))
5502      {
5503        this.PropertyChanging(this, emptyChangingEventArgs);
5504      }
5505    }
5506   
5507    protected virtual void SendPropertyChanged(String propertyName)
5508    {
5509      if ((this.PropertyChanged != null))
5510      {
5511        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
5512      }
5513    }
5514  }
5515 
5516  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Project")]
5517  public partial class Project : INotifyPropertyChanging, INotifyPropertyChanged
5518  {
5519   
5520    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
5521   
5522    private System.Guid _ProjectId;
5523   
5524    private System.Nullable<System.Guid> _ParentProjectId;
5525   
5526    private System.DateTime _DateCreated;
5527   
5528    private string _Name;
5529   
5530    private string _Description;
5531   
5532    private System.Guid _OwnerUserId;
5533   
5534    private System.DateTime _StartDate;
5535   
5536    private System.Nullable<System.DateTime> _EndDate;
5537   
5538    private EntitySet<AssignedProjectResource> _AssignedResources;
5539   
5540    private EntitySet<Job> _Jobs;
5541   
5542    private EntitySet<Project> _Projects;
5543   
5544    private EntitySet<ProjectPermission> _ProjectPermissions;
5545   
5546    private EntityRef<Project> _Project1;
5547   
5548    #region Extensibility Method Definitions
5549    partial void OnLoaded();
5550    partial void OnValidate(System.Data.Linq.ChangeAction action);
5551    partial void OnCreated();
5552    partial void OnProjectIdChanging(System.Guid value);
5553    partial void OnProjectIdChanged();
5554    partial void OnParentProjectIdChanging(System.Nullable<System.Guid> value);
5555    partial void OnParentProjectIdChanged();
5556    partial void OnDateCreatedChanging(System.DateTime value);
5557    partial void OnDateCreatedChanged();
5558    partial void OnNameChanging(string value);
5559    partial void OnNameChanged();
5560    partial void OnDescriptionChanging(string value);
5561    partial void OnDescriptionChanged();
5562    partial void OnOwnerUserIdChanging(System.Guid value);
5563    partial void OnOwnerUserIdChanged();
5564    partial void OnStartDateChanging(System.DateTime value);
5565    partial void OnStartDateChanged();
5566    partial void OnEndDateChanging(System.Nullable<System.DateTime> value);
5567    partial void OnEndDateChanged();
5568    #endregion
5569   
5570    public Project()
5571    {
5572      this._AssignedResources = new EntitySet<AssignedProjectResource>(new Action<AssignedProjectResource>(this.attach_AssignedResources), new Action<AssignedProjectResource>(this.detach_AssignedResources));
5573      this._Jobs = new EntitySet<Job>(new Action<Job>(this.attach_Jobs), new Action<Job>(this.detach_Jobs));
5574      this._Projects = new EntitySet<Project>(new Action<Project>(this.attach_Projects), new Action<Project>(this.detach_Projects));
5575      this._ProjectPermissions = new EntitySet<ProjectPermission>(new Action<ProjectPermission>(this.attach_ProjectPermissions), new Action<ProjectPermission>(this.detach_ProjectPermissions));
5576      this._Project1 = default(EntityRef<Project>);
5577      OnCreated();
5578    }
5579   
5580    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ProjectId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
5581    public System.Guid ProjectId
5582    {
5583      get
5584      {
5585        return this._ProjectId;
5586      }
5587      set
5588      {
5589        if ((this._ProjectId != value))
5590        {
5591          this.OnProjectIdChanging(value);
5592          this.SendPropertyChanging();
5593          this._ProjectId = value;
5594          this.SendPropertyChanged("ProjectId");
5595          this.OnProjectIdChanged();
5596        }
5597      }
5598    }
5599   
5600    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ParentProjectId", DbType="UniqueIdentifier")]
5601    public System.Nullable<System.Guid> ParentProjectId
5602    {
5603      get
5604      {
5605        return this._ParentProjectId;
5606      }
5607      set
5608      {
5609        if ((this._ParentProjectId != value))
5610        {
5611          if (this._Project1.HasLoadedOrAssignedValue)
5612          {
5613            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
5614          }
5615          this.OnParentProjectIdChanging(value);
5616          this.SendPropertyChanging();
5617          this._ParentProjectId = value;
5618          this.SendPropertyChanged("ParentProjectId");
5619          this.OnParentProjectIdChanged();
5620        }
5621      }
5622    }
5623   
5624    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateCreated", DbType="DateTime NOT NULL")]
5625    public System.DateTime DateCreated
5626    {
5627      get
5628      {
5629        return this._DateCreated;
5630      }
5631      set
5632      {
5633        if ((this._DateCreated != value))
5634        {
5635          this.OnDateCreatedChanging(value);
5636          this.SendPropertyChanging();
5637          this._DateCreated = value;
5638          this.SendPropertyChanged("DateCreated");
5639          this.OnDateCreatedChanged();
5640        }
5641      }
5642    }
5643   
5644    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
5645    public string Name
5646    {
5647      get
5648      {
5649        return this._Name;
5650      }
5651      set
5652      {
5653        if ((this._Name != value))
5654        {
5655          this.OnNameChanging(value);
5656          this.SendPropertyChanging();
5657          this._Name = value;
5658          this.SendPropertyChanged("Name");
5659          this.OnNameChanged();
5660        }
5661      }
5662    }
5663   
5664    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Description", DbType="VarChar(MAX)")]
5665    public string Description
5666    {
5667      get
5668      {
5669        return this._Description;
5670      }
5671      set
5672      {
5673        if ((this._Description != value))
5674        {
5675          this.OnDescriptionChanging(value);
5676          this.SendPropertyChanging();
5677          this._Description = value;
5678          this.SendPropertyChanged("Description");
5679          this.OnDescriptionChanged();
5680        }
5681      }
5682    }
5683   
5684    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_OwnerUserId", DbType="UniqueIdentifier NOT NULL")]
5685    public System.Guid OwnerUserId
5686    {
5687      get
5688      {
5689        return this._OwnerUserId;
5690      }
5691      set
5692      {
5693        if ((this._OwnerUserId != value))
5694        {
5695          this.OnOwnerUserIdChanging(value);
5696          this.SendPropertyChanging();
5697          this._OwnerUserId = value;
5698          this.SendPropertyChanged("OwnerUserId");
5699          this.OnOwnerUserIdChanged();
5700        }
5701      }
5702    }
5703   
5704    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StartDate", DbType="DateTime NOT NULL")]
5705    public System.DateTime StartDate
5706    {
5707      get
5708      {
5709        return this._StartDate;
5710      }
5711      set
5712      {
5713        if ((this._StartDate != value))
5714        {
5715          this.OnStartDateChanging(value);
5716          this.SendPropertyChanging();
5717          this._StartDate = value;
5718          this.SendPropertyChanged("StartDate");
5719          this.OnStartDateChanged();
5720        }
5721      }
5722    }
5723   
5724    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_EndDate", DbType="DateTime")]
5725    public System.Nullable<System.DateTime> EndDate
5726    {
5727      get
5728      {
5729        return this._EndDate;
5730      }
5731      set
5732      {
5733        if ((this._EndDate != value))
5734        {
5735          this.OnEndDateChanging(value);
5736          this.SendPropertyChanging();
5737          this._EndDate = value;
5738          this.SendPropertyChanged("EndDate");
5739          this.OnEndDateChanged();
5740        }
5741      }
5742    }
5743   
5744    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Project_AssignedProjectResource", Storage="_AssignedResources", ThisKey="ProjectId", OtherKey="ProjectId")]
5745    public EntitySet<AssignedProjectResource> AssignedProjectResources
5746    {
5747      get
5748      {
5749        return this._AssignedResources;
5750      }
5751      set
5752      {
5753        this._AssignedResources.Assign(value);
5754      }
5755    }
5756   
5757    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Project_Job", Storage="_Jobs", ThisKey="ProjectId", OtherKey="ProjectId")]
5758    public EntitySet<Job> Jobs
5759    {
5760      get
5761      {
5762        return this._Jobs;
5763      }
5764      set
5765      {
5766        this._Jobs.Assign(value);
5767      }
5768    }
5769   
5770    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Project_Project", Storage="_Projects", ThisKey="ProjectId", OtherKey="ParentProjectId")]
5771    public EntitySet<Project> ChildProjects
5772    {
5773      get
5774      {
5775        return this._Projects;
5776      }
5777      set
5778      {
5779        this._Projects.Assign(value);
5780      }
5781    }
5782   
5783    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Project_ProjectPermission", Storage="_ProjectPermissions", ThisKey="ProjectId", OtherKey="ProjectId")]
5784    public EntitySet<ProjectPermission> ProjectPermissions
5785    {
5786      get
5787      {
5788        return this._ProjectPermissions;
5789      }
5790      set
5791      {
5792        this._ProjectPermissions.Assign(value);
5793      }
5794    }
5795   
5796    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Project_Project", Storage="_Project1", ThisKey="ParentProjectId", OtherKey="ProjectId", IsForeignKey=true)]
5797    public Project ParentProject
5798    {
5799      get
5800      {
5801        return this._Project1.Entity;
5802      }
5803      set
5804      {
5805        Project previousValue = this._Project1.Entity;
5806        if (((previousValue != value)
5807              || (this._Project1.HasLoadedOrAssignedValue == false)))
5808        {
5809          this.SendPropertyChanging();
5810          if ((previousValue != null))
5811          {
5812            this._Project1.Entity = null;
5813            previousValue.ChildProjects.Remove(this);
5814          }
5815          this._Project1.Entity = value;
5816          if ((value != null))
5817          {
5818            value.ChildProjects.Add(this);
5819            this._ParentProjectId = value.ProjectId;
5820          }
5821          else
5822          {
5823            this._ParentProjectId = default(Nullable<System.Guid>);
5824          }
5825          this.SendPropertyChanged("ParentProject");
5826        }
5827      }
5828    }
5829   
5830    public event PropertyChangingEventHandler PropertyChanging;
5831   
5832    public event PropertyChangedEventHandler PropertyChanged;
5833   
5834    protected virtual void SendPropertyChanging()
5835    {
5836      if ((this.PropertyChanging != null))
5837      {
5838        this.PropertyChanging(this, emptyChangingEventArgs);
5839      }
5840    }
5841   
5842    protected virtual void SendPropertyChanged(String propertyName)
5843    {
5844      if ((this.PropertyChanged != null))
5845      {
5846        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
5847      }
5848    }
5849   
5850    private void attach_AssignedResources(AssignedProjectResource entity)
5851    {
5852      this.SendPropertyChanging();
5853      entity.Project = this;
5854    }
5855   
5856    private void detach_AssignedResources(AssignedProjectResource entity)
5857    {
5858      this.SendPropertyChanging();
5859      entity.Project = null;
5860    }
5861   
5862    private void attach_Jobs(Job entity)
5863    {
5864      this.SendPropertyChanging();
5865      entity.Project = this;
5866    }
5867   
5868    private void detach_Jobs(Job entity)
5869    {
5870      this.SendPropertyChanging();
5871      entity.Project = null;
5872    }
5873   
5874    private void attach_Projects(Project entity)
5875    {
5876      this.SendPropertyChanging();
5877      entity.ParentProject = this;
5878    }
5879   
5880    private void detach_Projects(Project entity)
5881    {
5882      this.SendPropertyChanging();
5883      entity.ParentProject = null;
5884    }
5885   
5886    private void attach_ProjectPermissions(ProjectPermission entity)
5887    {
5888      this.SendPropertyChanging();
5889      entity.Project = this;
5890    }
5891   
5892    private void detach_ProjectPermissions(ProjectPermission entity)
5893    {
5894      this.SendPropertyChanging();
5895      entity.Project = null;
5896    }
5897  }
5898 
5899  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.ProjectPermission")]
5900  public partial class ProjectPermission : INotifyPropertyChanging, INotifyPropertyChanged
5901  {
5902   
5903    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
5904   
5905    private System.Guid _ProjectId;
5906   
5907    private System.Guid _GrantedUserId;
5908   
5909    private System.Guid _GrantedByUserId;
5910   
5911    private EntityRef<Project> _Project;
5912   
5913    #region Extensibility Method Definitions
5914    partial void OnLoaded();
5915    partial void OnValidate(System.Data.Linq.ChangeAction action);
5916    partial void OnCreated();
5917    partial void OnProjectIdChanging(System.Guid value);
5918    partial void OnProjectIdChanged();
5919    partial void OnGrantedUserIdChanging(System.Guid value);
5920    partial void OnGrantedUserIdChanged();
5921    partial void OnGrantedByUserIdChanging(System.Guid value);
5922    partial void OnGrantedByUserIdChanged();
5923    #endregion
5924   
5925    public ProjectPermission()
5926    {
5927      this._Project = default(EntityRef<Project>);
5928      OnCreated();
5929    }
5930   
5931    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ProjectId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
5932    public System.Guid ProjectId
5933    {
5934      get
5935      {
5936        return this._ProjectId;
5937      }
5938      set
5939      {
5940        if ((this._ProjectId != value))
5941        {
5942          if (this._Project.HasLoadedOrAssignedValue)
5943          {
5944            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
5945          }
5946          this.OnProjectIdChanging(value);
5947          this.SendPropertyChanging();
5948          this._ProjectId = value;
5949          this.SendPropertyChanged("ProjectId");
5950          this.OnProjectIdChanged();
5951        }
5952      }
5953    }
5954   
5955    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GrantedUserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
5956    public System.Guid GrantedUserId
5957    {
5958      get
5959      {
5960        return this._GrantedUserId;
5961      }
5962      set
5963      {
5964        if ((this._GrantedUserId != value))
5965        {
5966          this.OnGrantedUserIdChanging(value);
5967          this.SendPropertyChanging();
5968          this._GrantedUserId = value;
5969          this.SendPropertyChanged("GrantedUserId");
5970          this.OnGrantedUserIdChanged();
5971        }
5972      }
5973    }
5974   
5975    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GrantedByUserId", DbType="UniqueIdentifier NOT NULL")]
5976    public System.Guid GrantedByUserId
5977    {
5978      get
5979      {
5980        return this._GrantedByUserId;
5981      }
5982      set
5983      {
5984        if ((this._GrantedByUserId != value))
5985        {
5986          this.OnGrantedByUserIdChanging(value);
5987          this.SendPropertyChanging();
5988          this._GrantedByUserId = value;
5989          this.SendPropertyChanged("GrantedByUserId");
5990          this.OnGrantedByUserIdChanged();
5991        }
5992      }
5993    }
5994   
5995    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Project_ProjectPermission", Storage="_Project", ThisKey="ProjectId", OtherKey="ProjectId", IsForeignKey=true)]
5996    public Project Project
5997    {
5998      get
5999      {
6000        return this._Project.Entity;
6001      }
6002      set
6003      {
6004        Project previousValue = this._Project.Entity;
6005        if (((previousValue != value)
6006              || (this._Project.HasLoadedOrAssignedValue == false)))
6007        {
6008          this.SendPropertyChanging();
6009          if ((previousValue != null))
6010          {
6011            this._Project.Entity = null;
6012            previousValue.ProjectPermissions.Remove(this);
6013          }
6014          this._Project.Entity = value;
6015          if ((value != null))
6016          {
6017            value.ProjectPermissions.Add(this);
6018            this._ProjectId = value.ProjectId;
6019          }
6020          else
6021          {
6022            this._ProjectId = default(System.Guid);
6023          }
6024          this.SendPropertyChanged("Project");
6025        }
6026      }
6027    }
6028   
6029    public event PropertyChangingEventHandler PropertyChanging;
6030   
6031    public event PropertyChangedEventHandler PropertyChanged;
6032   
6033    protected virtual void SendPropertyChanging()
6034    {
6035      if ((this.PropertyChanging != null))
6036      {
6037        this.PropertyChanging(this, emptyChangingEventArgs);
6038      }
6039    }
6040   
6041    protected virtual void SendPropertyChanged(String propertyName)
6042    {
6043      if ((this.PropertyChanged != null))
6044      {
6045        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
6046      }
6047    }
6048  }
6049 
6050  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.AssignedTaskResource")]
6051  public partial class AssignedTaskResource : INotifyPropertyChanging, INotifyPropertyChanged
6052  {
6053   
6054    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
6055   
6056    private System.Guid _ResourceId;
6057   
6058    private System.Guid _TaskId;
6059   
6060    private EntityRef<Task> _Task;
6061   
6062    private EntityRef<Resource> _Resource;
6063   
6064    #region Extensibility Method Definitions
6065    partial void OnLoaded();
6066    partial void OnValidate(System.Data.Linq.ChangeAction action);
6067    partial void OnCreated();
6068    partial void OnResourceIdChanging(System.Guid value);
6069    partial void OnResourceIdChanged();
6070    partial void OnTaskIdChanging(System.Guid value);
6071    partial void OnTaskIdChanged();
6072    #endregion
6073   
6074    public AssignedTaskResource()
6075    {
6076      this._Task = default(EntityRef<Task>);
6077      this._Resource = default(EntityRef<Resource>);
6078      OnCreated();
6079    }
6080   
6081    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
6082    public System.Guid ResourceId
6083    {
6084      get
6085      {
6086        return this._ResourceId;
6087      }
6088      set
6089      {
6090        if ((this._ResourceId != value))
6091        {
6092          if (this._Resource.HasLoadedOrAssignedValue)
6093          {
6094            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
6095          }
6096          this.OnResourceIdChanging(value);
6097          this.SendPropertyChanging();
6098          this._ResourceId = value;
6099          this.SendPropertyChanged("ResourceId");
6100          this.OnResourceIdChanged();
6101        }
6102      }
6103    }
6104   
6105    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TaskId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
6106    public System.Guid TaskId
6107    {
6108      get
6109      {
6110        return this._TaskId;
6111      }
6112      set
6113      {
6114        if ((this._TaskId != value))
6115        {
6116          if (this._Task.HasLoadedOrAssignedValue)
6117          {
6118            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
6119          }
6120          this.OnTaskIdChanging(value);
6121          this.SendPropertyChanging();
6122          this._TaskId = value;
6123          this.SendPropertyChanged("TaskId");
6124          this.OnTaskIdChanged();
6125        }
6126      }
6127    }
6128   
6129    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_AssignedTaskResource", Storage="_Task", ThisKey="TaskId", OtherKey="TaskId", IsForeignKey=true)]
6130    public Task Task
6131    {
6132      get
6133      {
6134        return this._Task.Entity;
6135      }
6136      set
6137      {
6138        Task previousValue = this._Task.Entity;
6139        if (((previousValue != value)
6140              || (this._Task.HasLoadedOrAssignedValue == false)))
6141        {
6142          this.SendPropertyChanging();
6143          if ((previousValue != null))
6144          {
6145            this._Task.Entity = null;
6146            previousValue.AssignedTaskResources.Remove(this);
6147          }
6148          this._Task.Entity = value;
6149          if ((value != null))
6150          {
6151            value.AssignedTaskResources.Add(this);
6152            this._TaskId = value.TaskId;
6153          }
6154          else
6155          {
6156            this._TaskId = default(System.Guid);
6157          }
6158          this.SendPropertyChanged("Task");
6159        }
6160      }
6161    }
6162   
6163    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_AssignedTaskResource", Storage="_Resource", ThisKey="ResourceId", OtherKey="ResourceId", IsForeignKey=true)]
6164    public Resource Resource
6165    {
6166      get
6167      {
6168        return this._Resource.Entity;
6169      }
6170      set
6171      {
6172        Resource previousValue = this._Resource.Entity;
6173        if (((previousValue != value)
6174              || (this._Resource.HasLoadedOrAssignedValue == false)))
6175        {
6176          this.SendPropertyChanging();
6177          if ((previousValue != null))
6178          {
6179            this._Resource.Entity = null;
6180            previousValue.AssignedTaskResources.Remove(this);
6181          }
6182          this._Resource.Entity = value;
6183          if ((value != null))
6184          {
6185            value.AssignedTaskResources.Add(this);
6186            this._ResourceId = value.ResourceId;
6187          }
6188          else
6189          {
6190            this._ResourceId = default(System.Guid);
6191          }
6192          this.SendPropertyChanged("Resource");
6193        }
6194      }
6195    }
6196   
6197    public event PropertyChangingEventHandler PropertyChanging;
6198   
6199    public event PropertyChangedEventHandler PropertyChanged;
6200   
6201    protected virtual void SendPropertyChanging()
6202    {
6203      if ((this.PropertyChanging != null))
6204      {
6205        this.PropertyChanging(this, emptyChangingEventArgs);
6206      }
6207    }
6208   
6209    protected virtual void SendPropertyChanged(String propertyName)
6210    {
6211      if ((this.PropertyChanged != null))
6212      {
6213        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
6214      }
6215    }
6216  }
6217}
6218#pragma warning restore 1591
Note: See TracBrowser for help on using the repository browser.