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

Last change on this file since 15411 was 15411, checked in by jkarder, 4 years ago

#2839: worked on database model

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