Free cookie consent management tool by TermsFeed Policy Generator

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

Last change on this file since 15644 was 15644, checked in by jzenisek, 6 years ago

#2839 removed AssignedTaskResource entity

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