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

Last change on this file since 15671 was 15671, checked in by jzenisek, 19 months ago

#2839

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