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

Last change on this file since 15643 was 15643, checked in by jzenisek, 3 years ago

#2839

  • worked on UpdateJob(..)
  • adapted permission and assignment handling methods
  • adpated dbml of HiveDataContext using the designer (added delete rules and onNull-handling)
File size: 170.1 KB
Line 
1#pragma warning disable 1591
2//------------------------------------------------------------------------------
3// <auto-generated>
4//     This code was generated by a tool.
5//     Runtime Version:4.0.30319.42000
6//
7//     Changes to this file may cause incorrect behavior and will be lost if
8//     the code is regenerated.
9// </auto-generated>
10//------------------------------------------------------------------------------
11
12namespace HeuristicLab.Services.Hive.DataAccess
13{
14  using System.Data.Linq;
15  using System.Data.Linq.Mapping;
16  using System.Data;
17  using System.Collections.Generic;
18  using System.Reflection;
19  using System.Linq;
20  using System.Linq.Expressions;
21  using System.ComponentModel;
22  using System;
23 
24 
25  [global::System.Data.Linq.Mapping.DatabaseAttribute(Name="HeuristicLab.Hive")]
26  public partial class HiveDataContext : System.Data.Linq.DataContext
27  {
28   
29    private static System.Data.Linq.Mapping.MappingSource mappingSource = new AttributeMappingSource();
30   
31    #region Extensibility Method Definitions
32    partial void OnCreated();
33    partial void InsertAssignedProjectResource(AssignedProjectResource instance);
34    partial void UpdateAssignedProjectResource(AssignedProjectResource instance);
35    partial void DeleteAssignedProjectResource(AssignedProjectResource instance);
36    partial void InsertPlugin(Plugin instance);
37    partial void UpdatePlugin(Plugin instance);
38    partial void DeletePlugin(Plugin instance);
39    partial void InsertRequiredPlugin(RequiredPlugin instance);
40    partial void UpdateRequiredPlugin(RequiredPlugin instance);
41    partial void DeleteRequiredPlugin(RequiredPlugin instance);
42    partial void InsertResource(Resource instance);
43    partial void UpdateResource(Resource instance);
44    partial void DeleteResource(Resource instance);
45    partial void InsertTask(Task instance);
46    partial void UpdateTask(Task instance);
47    partial void DeleteTask(Task instance);
48    partial void InsertDowntime(Downtime instance);
49    partial void UpdateDowntime(Downtime instance);
50    partial void DeleteDowntime(Downtime instance);
51    partial void InsertJob(Job instance);
52    partial void UpdateJob(Job instance);
53    partial void DeleteJob(Job instance);
54    partial void InsertTaskData(TaskData instance);
55    partial void UpdateTaskData(TaskData instance);
56    partial void DeleteTaskData(TaskData instance);
57    partial void InsertPluginData(PluginData instance);
58    partial void UpdatePluginData(PluginData instance);
59    partial void DeletePluginData(PluginData instance);
60    partial void InsertStateLog(StateLog instance);
61    partial void UpdateStateLog(StateLog instance);
62    partial void DeleteStateLog(StateLog instance);
63    partial void InsertJobPermission(JobPermission instance);
64    partial void UpdateJobPermission(JobPermission instance);
65    partial void DeleteJobPermission(JobPermission instance);
66    partial void InsertLifecycle(Lifecycle instance);
67    partial void UpdateLifecycle(Lifecycle instance);
68    partial void DeleteLifecycle(Lifecycle instance);
69    partial void InsertUserPriority(UserPriority instance);
70    partial void UpdateUserPriority(UserPriority instance);
71    partial void DeleteUserPriority(UserPriority instance);
72    partial void InsertDimClient(DimClient instance);
73    partial void UpdateDimClient(DimClient instance);
74    partial void DeleteDimClient(DimClient instance);
75    partial void InsertFactTask(FactTask instance);
76    partial void UpdateFactTask(FactTask instance);
77    partial void DeleteFactTask(FactTask instance);
78    partial void InsertDimJob(DimJob instance);
79    partial void UpdateDimJob(DimJob instance);
80    partial void DeleteDimJob(DimJob instance);
81    partial void InsertDimTime(DimTime instance);
82    partial void UpdateDimTime(DimTime instance);
83    partial void DeleteDimTime(DimTime instance);
84    partial void InsertDimUser(DimUser instance);
85    partial void UpdateDimUser(DimUser instance);
86    partial void DeleteDimUser(DimUser instance);
87    partial void InsertFactClientInfo(FactClientInfo instance);
88    partial void UpdateFactClientInfo(FactClientInfo instance);
89    partial void DeleteFactClientInfo(FactClientInfo instance);
90    partial void InsertProject(Project instance);
91    partial void UpdateProject(Project instance);
92    partial void DeleteProject(Project instance);
93    partial void InsertProjectPermission(ProjectPermission instance);
94    partial void UpdateProjectPermission(ProjectPermission instance);
95    partial void DeleteProjectPermission(ProjectPermission instance);
96    partial void InsertAssignedTaskResource(AssignedTaskResource instance);
97    partial void UpdateAssignedTaskResource(AssignedTaskResource instance);
98    partial void DeleteAssignedTaskResource(AssignedTaskResource instance);
99    partial void InsertAssignedJobResource(AssignedJobResource instance);
100    partial void UpdateAssignedJobResource(AssignedJobResource instance);
101    partial void DeleteAssignedJobResource(AssignedJobResource 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<UserPriority> UserPriorities
225    {
226      get
227      {
228        return this.GetTable<UserPriority>();
229      }
230    }
231   
232    public System.Data.Linq.Table<DimClient> DimClients
233    {
234      get
235      {
236        return this.GetTable<DimClient>();
237      }
238    }
239   
240    public System.Data.Linq.Table<FactTask> FactTasks
241    {
242      get
243      {
244        return this.GetTable<FactTask>();
245      }
246    }
247   
248    public System.Data.Linq.Table<DimJob> DimJobs
249    {
250      get
251      {
252        return this.GetTable<DimJob>();
253      }
254    }
255   
256    public System.Data.Linq.Table<DimTime> DimTimes
257    {
258      get
259      {
260        return this.GetTable<DimTime>();
261      }
262    }
263   
264    public System.Data.Linq.Table<DimUser> DimUsers
265    {
266      get
267      {
268        return this.GetTable<DimUser>();
269      }
270    }
271   
272    public System.Data.Linq.Table<FactClientInfo> FactClientInfos
273    {
274      get
275      {
276        return this.GetTable<FactClientInfo>();
277      }
278    }
279   
280    public System.Data.Linq.Table<Project> Projects
281    {
282      get
283      {
284        return this.GetTable<Project>();
285      }
286    }
287   
288    public System.Data.Linq.Table<ProjectPermission> ProjectPermissions
289    {
290      get
291      {
292        return this.GetTable<ProjectPermission>();
293      }
294    }
295   
296    public System.Data.Linq.Table<AssignedTaskResource> AssignedTaskResources
297    {
298      get
299      {
300        return this.GetTable<AssignedTaskResource>();
301      }
302    }
303   
304    public System.Data.Linq.Table<AssignedJobResource> AssignedJobResources
305    {
306      get
307      {
308        return this.GetTable<AssignedJobResource>();
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", DeleteOnNull=true)]
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", DeleteOnNull=true)]
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<AssignedTaskResource> _AssignedTaskResources;
941   
942    private EntitySet<AssignedJobResource> _AssignedJobResources;
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._AssignedTaskResources = new EntitySet<AssignedTaskResource>(new Action<AssignedTaskResource>(this.attach_AssignedTaskResources), new Action<AssignedTaskResource>(this.detach_AssignedTaskResources));
971      this._AssignedJobResources = new EntitySet<AssignedJobResource>(new Action<AssignedJobResource>(this.attach_AssignedJobResources), new Action<AssignedJobResource>(this.detach_AssignedJobResources));
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", DeleteRule="CASCADE")]
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_AssignedTaskResource", Storage="_AssignedTaskResources", ThisKey="ResourceId", OtherKey="ResourceId")]
1153    public EntitySet<AssignedTaskResource> AssignedTaskResources
1154    {
1155      get
1156      {
1157        return this._AssignedTaskResources;
1158      }
1159      set
1160      {
1161        this._AssignedTaskResources.Assign(value);
1162      }
1163    }
1164   
1165    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_AssignedJobResource", Storage="_AssignedJobResources", ThisKey="ResourceId", OtherKey="ResourceId", DeleteRule="CASCADE")]
1166    public EntitySet<AssignedJobResource> AssignedJobResources
1167    {
1168      get
1169      {
1170        return this._AssignedJobResources;
1171      }
1172      set
1173      {
1174        this._AssignedJobResources.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_AssignedTaskResources(AssignedTaskResource entity)
1281    {
1282      this.SendPropertyChanging();
1283      entity.Resource = this;
1284    }
1285   
1286    private void detach_AssignedTaskResources(AssignedTaskResource entity)
1287    {
1288      this.SendPropertyChanging();
1289      entity.Resource = null;
1290    }
1291   
1292    private void attach_AssignedJobResources(AssignedJobResource entity)
1293    {
1294      this.SendPropertyChanging();
1295      entity.Resource = this;
1296    }
1297   
1298    private void detach_AssignedJobResources(AssignedJobResource 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 System.Guid _UserId;
2483   
2484    private System.DateTime _DateCreated;
2485   
2486    private System.Guid _ProjectId;
2487   
2488    private global::HeuristicLab.Services.Hive.DataAccess.JobState _State;
2489   
2490    private EntitySet<Task> _Jobs;
2491   
2492    private EntitySet<JobPermission> _HiveExperimentPermissions;
2493   
2494    private EntitySet<AssignedJobResource> _AssignedJobResources;
2495   
2496    private EntityRef<Project> _Project;
2497   
2498    #region Extensibility Method Definitions
2499    partial void OnLoaded();
2500    partial void OnValidate(System.Data.Linq.ChangeAction action);
2501    partial void OnCreated();
2502    partial void OnJobIdChanging(System.Guid value);
2503    partial void OnJobIdChanged();
2504    partial void OnNameChanging(string value);
2505    partial void OnNameChanged();
2506    partial void OnDescriptionChanging(string value);
2507    partial void OnDescriptionChanged();
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    partial void OnStateChanging(global::HeuristicLab.Services.Hive.DataAccess.JobState value);
2515    partial void OnStateChanged();
2516    #endregion
2517   
2518    public Job()
2519    {
2520      this._Jobs = new EntitySet<Task>(new Action<Task>(this.attach_Jobs), new Action<Task>(this.detach_Jobs));
2521      this._HiveExperimentPermissions = new EntitySet<JobPermission>(new Action<JobPermission>(this.attach_HiveExperimentPermissions), new Action<JobPermission>(this.detach_HiveExperimentPermissions));
2522      this._AssignedJobResources = new EntitySet<AssignedJobResource>(new Action<AssignedJobResource>(this.attach_AssignedJobResources), new Action<AssignedJobResource>(this.detach_AssignedJobResources));
2523      this._Project = default(EntityRef<Project>);
2524      OnCreated();
2525    }
2526   
2527    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_HiveExperimentId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
2528    public System.Guid JobId
2529    {
2530      get
2531      {
2532        return this._HiveExperimentId;
2533      }
2534      set
2535      {
2536        if ((this._HiveExperimentId != value))
2537        {
2538          this.OnJobIdChanging(value);
2539          this.SendPropertyChanging();
2540          this._HiveExperimentId = value;
2541          this.SendPropertyChanged("JobId");
2542          this.OnJobIdChanged();
2543        }
2544      }
2545    }
2546   
2547    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX)", CanBeNull=false)]
2548    public string Name
2549    {
2550      get
2551      {
2552        return this._Name;
2553      }
2554      set
2555      {
2556        if ((this._Name != value))
2557        {
2558          this.OnNameChanging(value);
2559          this.SendPropertyChanging();
2560          this._Name = value;
2561          this.SendPropertyChanged("Name");
2562          this.OnNameChanged();
2563        }
2564      }
2565    }
2566   
2567    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Description", DbType="VarChar(MAX)")]
2568    public string Description
2569    {
2570      get
2571      {
2572        return this._Description;
2573      }
2574      set
2575      {
2576        if ((this._Description != value))
2577        {
2578          this.OnDescriptionChanging(value);
2579          this.SendPropertyChanging();
2580          this._Description = value;
2581          this.SendPropertyChanged("Description");
2582          this.OnDescriptionChanged();
2583        }
2584      }
2585    }
2586   
2587    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier")]
2588    public System.Guid OwnerUserId
2589    {
2590      get
2591      {
2592        return this._UserId;
2593      }
2594      set
2595      {
2596        if ((this._UserId != value))
2597        {
2598          this.OnOwnerUserIdChanging(value);
2599          this.SendPropertyChanging();
2600          this._UserId = value;
2601          this.SendPropertyChanged("OwnerUserId");
2602          this.OnOwnerUserIdChanged();
2603        }
2604      }
2605    }
2606   
2607    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateCreated", DbType="DateTime")]
2608    public System.DateTime DateCreated
2609    {
2610      get
2611      {
2612        return this._DateCreated;
2613      }
2614      set
2615      {
2616        if ((this._DateCreated != value))
2617        {
2618          this.OnDateCreatedChanging(value);
2619          this.SendPropertyChanging();
2620          this._DateCreated = value;
2621          this.SendPropertyChanged("DateCreated");
2622          this.OnDateCreatedChanged();
2623        }
2624      }
2625    }
2626   
2627    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ProjectId", DbType="UniqueIdentifier NOT NULL")]
2628    public System.Guid ProjectId
2629    {
2630      get
2631      {
2632        return this._ProjectId;
2633      }
2634      set
2635      {
2636        if ((this._ProjectId != value))
2637        {
2638          if (this._Project.HasLoadedOrAssignedValue)
2639          {
2640            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2641          }
2642          this.OnProjectIdChanging(value);
2643          this.SendPropertyChanging();
2644          this._ProjectId = value;
2645          this.SendPropertyChanged("ProjectId");
2646          this.OnProjectIdChanged();
2647        }
2648      }
2649    }
2650   
2651    [global::System.Data.Linq.Mapping.ColumnAttribute(Name="JobState", Storage="_State", DbType="VarChar(30)", CanBeNull=false)]
2652    public global::HeuristicLab.Services.Hive.DataAccess.JobState State
2653    {
2654      get
2655      {
2656        return this._State;
2657      }
2658      set
2659      {
2660        if ((this._State != value))
2661        {
2662          this.OnStateChanging(value);
2663          this.SendPropertyChanging();
2664          this._State = value;
2665          this.SendPropertyChanged("State");
2666          this.OnStateChanged();
2667        }
2668      }
2669    }
2670   
2671    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_Task", Storage="_Jobs", ThisKey="JobId", OtherKey="JobId", DeleteRule="CASCADE")]
2672    public EntitySet<Task> Tasks
2673    {
2674      get
2675      {
2676        return this._Jobs;
2677      }
2678      set
2679      {
2680        this._Jobs.Assign(value);
2681      }
2682    }
2683   
2684    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_JobPermission", Storage="_HiveExperimentPermissions", ThisKey="JobId", OtherKey="JobId", DeleteRule="CASCADE")]
2685    public EntitySet<JobPermission> JobPermissions
2686    {
2687      get
2688      {
2689        return this._HiveExperimentPermissions;
2690      }
2691      set
2692      {
2693        this._HiveExperimentPermissions.Assign(value);
2694      }
2695    }
2696   
2697    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_AssignedJobResource", Storage="_AssignedJobResources", ThisKey="JobId", OtherKey="JobId", DeleteRule="CASCADE")]
2698    public EntitySet<AssignedJobResource> AssignedJobResources
2699    {
2700      get
2701      {
2702        return this._AssignedJobResources;
2703      }
2704      set
2705      {
2706        this._AssignedJobResources.Assign(value);
2707      }
2708    }
2709   
2710    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Project_Job", Storage="_Project", ThisKey="ProjectId", OtherKey="ProjectId", IsForeignKey=true)]
2711    public Project Project
2712    {
2713      get
2714      {
2715        return this._Project.Entity;
2716      }
2717      set
2718      {
2719        Project previousValue = this._Project.Entity;
2720        if (((previousValue != value)
2721              || (this._Project.HasLoadedOrAssignedValue == false)))
2722        {
2723          this.SendPropertyChanging();
2724          if ((previousValue != null))
2725          {
2726            this._Project.Entity = null;
2727            previousValue.Jobs.Remove(this);
2728          }
2729          this._Project.Entity = value;
2730          if ((value != null))
2731          {
2732            value.Jobs.Add(this);
2733            this._ProjectId = value.ProjectId;
2734          }
2735          else
2736          {
2737            this._ProjectId = default(System.Guid);
2738          }
2739          this.SendPropertyChanged("Project");
2740        }
2741      }
2742    }
2743   
2744    public event PropertyChangingEventHandler PropertyChanging;
2745   
2746    public event PropertyChangedEventHandler PropertyChanged;
2747   
2748    protected virtual void SendPropertyChanging()
2749    {
2750      if ((this.PropertyChanging != null))
2751      {
2752        this.PropertyChanging(this, emptyChangingEventArgs);
2753      }
2754    }
2755   
2756    protected virtual void SendPropertyChanged(String propertyName)
2757    {
2758      if ((this.PropertyChanged != null))
2759      {
2760        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2761      }
2762    }
2763   
2764    private void attach_Jobs(Task entity)
2765    {
2766      this.SendPropertyChanging();
2767      entity.Job = this;
2768    }
2769   
2770    private void detach_Jobs(Task entity)
2771    {
2772      this.SendPropertyChanging();
2773      entity.Job = null;
2774    }
2775   
2776    private void attach_HiveExperimentPermissions(JobPermission entity)
2777    {
2778      this.SendPropertyChanging();
2779      entity.Job = this;
2780    }
2781   
2782    private void detach_HiveExperimentPermissions(JobPermission entity)
2783    {
2784      this.SendPropertyChanging();
2785      entity.Job = null;
2786    }
2787   
2788    private void attach_AssignedJobResources(AssignedJobResource entity)
2789    {
2790      this.SendPropertyChanging();
2791      entity.Job = this;
2792    }
2793   
2794    private void detach_AssignedJobResources(AssignedJobResource entity)
2795    {
2796      this.SendPropertyChanging();
2797      entity.Job = null;
2798    }
2799  }
2800 
2801  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.TaskData")]
2802  public partial class TaskData : INotifyPropertyChanging, INotifyPropertyChanged
2803  {
2804   
2805    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2806   
2807    private System.Guid _JobId;
2808   
2809    private System.Data.Linq.Link<byte[]> _Data;
2810   
2811    private System.DateTime _LastUpdate;
2812   
2813    private EntityRef<Task> _Job;
2814   
2815    #region Extensibility Method Definitions
2816    partial void OnLoaded();
2817    partial void OnValidate(System.Data.Linq.ChangeAction action);
2818    partial void OnCreated();
2819    partial void OnTaskIdChanging(System.Guid value);
2820    partial void OnTaskIdChanged();
2821    partial void OnDataChanging(byte[] value);
2822    partial void OnDataChanged();
2823    partial void OnLastUpdateChanging(System.DateTime value);
2824    partial void OnLastUpdateChanged();
2825    #endregion
2826   
2827    public TaskData()
2828    {
2829      this._Job = default(EntityRef<Task>);
2830      OnCreated();
2831    }
2832   
2833    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
2834    public System.Guid TaskId
2835    {
2836      get
2837      {
2838        return this._JobId;
2839      }
2840      set
2841      {
2842        if ((this._JobId != value))
2843        {
2844          if (this._Job.HasLoadedOrAssignedValue)
2845          {
2846            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2847          }
2848          this.OnTaskIdChanging(value);
2849          this.SendPropertyChanging();
2850          this._JobId = value;
2851          this.SendPropertyChanged("TaskId");
2852          this.OnTaskIdChanged();
2853        }
2854      }
2855    }
2856   
2857    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Data", DbType="VarBinary(MAX)", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
2858    public byte[] Data
2859    {
2860      get
2861      {
2862        return this._Data.Value;
2863      }
2864      set
2865      {
2866        if ((this._Data.Value != value))
2867        {
2868          this.OnDataChanging(value);
2869          this.SendPropertyChanging();
2870          this._Data.Value = value;
2871          this.SendPropertyChanged("Data");
2872          this.OnDataChanged();
2873        }
2874      }
2875    }
2876   
2877    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastUpdate", DbType="DateTime")]
2878    public System.DateTime LastUpdate
2879    {
2880      get
2881      {
2882        return this._LastUpdate;
2883      }
2884      set
2885      {
2886        if ((this._LastUpdate != value))
2887        {
2888          this.OnLastUpdateChanging(value);
2889          this.SendPropertyChanging();
2890          this._LastUpdate = value;
2891          this.SendPropertyChanged("LastUpdate");
2892          this.OnLastUpdateChanged();
2893        }
2894      }
2895    }
2896   
2897    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_TaskData", Storage="_Job", ThisKey="TaskId", OtherKey="TaskId", IsForeignKey=true)]
2898    public Task Task
2899    {
2900      get
2901      {
2902        return this._Job.Entity;
2903      }
2904      set
2905      {
2906        Task previousValue = this._Job.Entity;
2907        if (((previousValue != value)
2908              || (this._Job.HasLoadedOrAssignedValue == false)))
2909        {
2910          this.SendPropertyChanging();
2911          if ((previousValue != null))
2912          {
2913            this._Job.Entity = null;
2914            previousValue.JobData = null;
2915          }
2916          this._Job.Entity = value;
2917          if ((value != null))
2918          {
2919            value.JobData = this;
2920            this._JobId = value.TaskId;
2921          }
2922          else
2923          {
2924            this._JobId = default(System.Guid);
2925          }
2926          this.SendPropertyChanged("Task");
2927        }
2928      }
2929    }
2930   
2931    public event PropertyChangingEventHandler PropertyChanging;
2932   
2933    public event PropertyChangedEventHandler PropertyChanged;
2934   
2935    protected virtual void SendPropertyChanging()
2936    {
2937      if ((this.PropertyChanging != null))
2938      {
2939        this.PropertyChanging(this, emptyChangingEventArgs);
2940      }
2941    }
2942   
2943    protected virtual void SendPropertyChanged(String propertyName)
2944    {
2945      if ((this.PropertyChanged != null))
2946      {
2947        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2948      }
2949    }
2950  }
2951 
2952  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.PluginData")]
2953  public partial class PluginData : INotifyPropertyChanging, INotifyPropertyChanged
2954  {
2955   
2956    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2957   
2958    private System.Guid _PluginDataId;
2959   
2960    private System.Guid _PluginId;
2961   
2962    private System.Data.Linq.Link<byte[]> _Data;
2963   
2964    private string _FileName;
2965   
2966    private EntityRef<Plugin> _Plugin;
2967   
2968    #region Extensibility Method Definitions
2969    partial void OnLoaded();
2970    partial void OnValidate(System.Data.Linq.ChangeAction action);
2971    partial void OnCreated();
2972    partial void OnPluginDataIdChanging(System.Guid value);
2973    partial void OnPluginDataIdChanged();
2974    partial void OnPluginIdChanging(System.Guid value);
2975    partial void OnPluginIdChanged();
2976    partial void OnDataChanging(byte[] value);
2977    partial void OnDataChanged();
2978    partial void OnFileNameChanging(string value);
2979    partial void OnFileNameChanged();
2980    #endregion
2981   
2982    public PluginData()
2983    {
2984      this._Plugin = default(EntityRef<Plugin>);
2985      OnCreated();
2986    }
2987   
2988    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginDataId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
2989    public System.Guid PluginDataId
2990    {
2991      get
2992      {
2993        return this._PluginDataId;
2994      }
2995      set
2996      {
2997        if ((this._PluginDataId != value))
2998        {
2999          this.OnPluginDataIdChanging(value);
3000          this.SendPropertyChanging();
3001          this._PluginDataId = value;
3002          this.SendPropertyChanged("PluginDataId");
3003          this.OnPluginDataIdChanged();
3004        }
3005      }
3006    }
3007   
3008    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginId", DbType="UniqueIdentifier NOT NULL")]
3009    public System.Guid PluginId
3010    {
3011      get
3012      {
3013        return this._PluginId;
3014      }
3015      set
3016      {
3017        if ((this._PluginId != value))
3018        {
3019          if (this._Plugin.HasLoadedOrAssignedValue)
3020          {
3021            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3022          }
3023          this.OnPluginIdChanging(value);
3024          this.SendPropertyChanging();
3025          this._PluginId = value;
3026          this.SendPropertyChanged("PluginId");
3027          this.OnPluginIdChanged();
3028        }
3029      }
3030    }
3031   
3032    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Data", DbType="VarBinary(MAX) NOT NULL", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
3033    public byte[] Data
3034    {
3035      get
3036      {
3037        return this._Data.Value;
3038      }
3039      set
3040      {
3041        if ((this._Data.Value != value))
3042        {
3043          this.OnDataChanging(value);
3044          this.SendPropertyChanging();
3045          this._Data.Value = value;
3046          this.SendPropertyChanged("Data");
3047          this.OnDataChanged();
3048        }
3049      }
3050    }
3051   
3052    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_FileName", DbType="VarChar(MAX)", CanBeNull=false)]
3053    public string FileName
3054    {
3055      get
3056      {
3057        return this._FileName;
3058      }
3059      set
3060      {
3061        if ((this._FileName != value))
3062        {
3063          this.OnFileNameChanging(value);
3064          this.SendPropertyChanging();
3065          this._FileName = value;
3066          this.SendPropertyChanged("FileName");
3067          this.OnFileNameChanged();
3068        }
3069      }
3070    }
3071   
3072    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Plugin_PluginData", Storage="_Plugin", ThisKey="PluginId", OtherKey="PluginId", IsForeignKey=true)]
3073    public Plugin Plugin
3074    {
3075      get
3076      {
3077        return this._Plugin.Entity;
3078      }
3079      set
3080      {
3081        Plugin previousValue = this._Plugin.Entity;
3082        if (((previousValue != value)
3083              || (this._Plugin.HasLoadedOrAssignedValue == false)))
3084        {
3085          this.SendPropertyChanging();
3086          if ((previousValue != null))
3087          {
3088            this._Plugin.Entity = null;
3089            previousValue.PluginData.Remove(this);
3090          }
3091          this._Plugin.Entity = value;
3092          if ((value != null))
3093          {
3094            value.PluginData.Add(this);
3095            this._PluginId = value.PluginId;
3096          }
3097          else
3098          {
3099            this._PluginId = default(System.Guid);
3100          }
3101          this.SendPropertyChanged("Plugin");
3102        }
3103      }
3104    }
3105   
3106    public event PropertyChangingEventHandler PropertyChanging;
3107   
3108    public event PropertyChangedEventHandler PropertyChanged;
3109   
3110    protected virtual void SendPropertyChanging()
3111    {
3112      if ((this.PropertyChanging != null))
3113      {
3114        this.PropertyChanging(this, emptyChangingEventArgs);
3115      }
3116    }
3117   
3118    protected virtual void SendPropertyChanged(String propertyName)
3119    {
3120      if ((this.PropertyChanged != null))
3121      {
3122        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3123      }
3124    }
3125  }
3126 
3127  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.StateLog")]
3128  public partial class StateLog : INotifyPropertyChanging, INotifyPropertyChanged
3129  {
3130   
3131    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3132   
3133    private System.Guid _StateLogId;
3134   
3135    private global::HeuristicLab.Services.Hive.DataAccess.TaskState _State;
3136   
3137    private System.DateTime _DateTime;
3138   
3139    private System.Guid _JobId;
3140   
3141    private System.Nullable<System.Guid> _UserId;
3142   
3143    private System.Nullable<System.Guid> _SlaveId;
3144   
3145    private string _Exception;
3146   
3147    private EntityRef<Task> _Job;
3148   
3149    private EntityRef<Resource> _Resource;
3150   
3151    #region Extensibility Method Definitions
3152    partial void OnLoaded();
3153    partial void OnValidate(System.Data.Linq.ChangeAction action);
3154    partial void OnCreated();
3155    partial void OnStateLogIdChanging(System.Guid value);
3156    partial void OnStateLogIdChanged();
3157    partial void OnStateChanging(global::HeuristicLab.Services.Hive.DataAccess.TaskState value);
3158    partial void OnStateChanged();
3159    partial void OnDateTimeChanging(System.DateTime value);
3160    partial void OnDateTimeChanged();
3161    partial void OnTaskIdChanging(System.Guid value);
3162    partial void OnTaskIdChanged();
3163    partial void OnUserIdChanging(System.Nullable<System.Guid> value);
3164    partial void OnUserIdChanged();
3165    partial void OnSlaveIdChanging(System.Nullable<System.Guid> value);
3166    partial void OnSlaveIdChanged();
3167    partial void OnExceptionChanging(string value);
3168    partial void OnExceptionChanged();
3169    #endregion
3170   
3171    public StateLog()
3172    {
3173      this._Job = default(EntityRef<Task>);
3174      this._Resource = default(EntityRef<Resource>);
3175      OnCreated();
3176    }
3177   
3178    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StateLogId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
3179    public System.Guid StateLogId
3180    {
3181      get
3182      {
3183        return this._StateLogId;
3184      }
3185      set
3186      {
3187        if ((this._StateLogId != value))
3188        {
3189          this.OnStateLogIdChanging(value);
3190          this.SendPropertyChanging();
3191          this._StateLogId = value;
3192          this.SendPropertyChanged("StateLogId");
3193          this.OnStateLogIdChanged();
3194        }
3195      }
3196    }
3197   
3198    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_State", DbType="VarChar(30) NOT NULL", CanBeNull=false)]
3199    public global::HeuristicLab.Services.Hive.DataAccess.TaskState State
3200    {
3201      get
3202      {
3203        return this._State;
3204      }
3205      set
3206      {
3207        if ((this._State != value))
3208        {
3209          this.OnStateChanging(value);
3210          this.SendPropertyChanging();
3211          this._State = value;
3212          this.SendPropertyChanged("State");
3213          this.OnStateChanged();
3214        }
3215      }
3216    }
3217   
3218    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateTime", DbType="DateTime NOT NULL")]
3219    public System.DateTime DateTime
3220    {
3221      get
3222      {
3223        return this._DateTime;
3224      }
3225      set
3226      {
3227        if ((this._DateTime != value))
3228        {
3229          this.OnDateTimeChanging(value);
3230          this.SendPropertyChanging();
3231          this._DateTime = value;
3232          this.SendPropertyChanged("DateTime");
3233          this.OnDateTimeChanged();
3234        }
3235      }
3236    }
3237   
3238    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL")]
3239    public System.Guid TaskId
3240    {
3241      get
3242      {
3243        return this._JobId;
3244      }
3245      set
3246      {
3247        if ((this._JobId != value))
3248        {
3249          if (this._Job.HasLoadedOrAssignedValue)
3250          {
3251            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3252          }
3253          this.OnTaskIdChanging(value);
3254          this.SendPropertyChanging();
3255          this._JobId = value;
3256          this.SendPropertyChanged("TaskId");
3257          this.OnTaskIdChanged();
3258        }
3259      }
3260    }
3261   
3262    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier")]
3263    public System.Nullable<System.Guid> UserId
3264    {
3265      get
3266      {
3267        return this._UserId;
3268      }
3269      set
3270      {
3271        if ((this._UserId != value))
3272        {
3273          this.OnUserIdChanging(value);
3274          this.SendPropertyChanging();
3275          this._UserId = value;
3276          this.SendPropertyChanged("UserId");
3277          this.OnUserIdChanged();
3278        }
3279      }
3280    }
3281   
3282    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_SlaveId", DbType="UniqueIdentifier")]
3283    public System.Nullable<System.Guid> SlaveId
3284    {
3285      get
3286      {
3287        return this._SlaveId;
3288      }
3289      set
3290      {
3291        if ((this._SlaveId != value))
3292        {
3293          if (this._Resource.HasLoadedOrAssignedValue)
3294          {
3295            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3296          }
3297          this.OnSlaveIdChanging(value);
3298          this.SendPropertyChanging();
3299          this._SlaveId = value;
3300          this.SendPropertyChanged("SlaveId");
3301          this.OnSlaveIdChanged();
3302        }
3303      }
3304    }
3305   
3306    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Exception", DbType="VarChar(MAX)", CanBeNull=false)]
3307    public string Exception
3308    {
3309      get
3310      {
3311        return this._Exception;
3312      }
3313      set
3314      {
3315        if ((this._Exception != value))
3316        {
3317          this.OnExceptionChanging(value);
3318          this.SendPropertyChanging();
3319          this._Exception = value;
3320          this.SendPropertyChanged("Exception");
3321          this.OnExceptionChanged();
3322        }
3323      }
3324    }
3325   
3326    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_StateLog", Storage="_Job", ThisKey="TaskId", OtherKey="TaskId", IsForeignKey=true)]
3327    public Task Task
3328    {
3329      get
3330      {
3331        return this._Job.Entity;
3332      }
3333      set
3334      {
3335        Task previousValue = this._Job.Entity;
3336        if (((previousValue != value)
3337              || (this._Job.HasLoadedOrAssignedValue == false)))
3338        {
3339          this.SendPropertyChanging();
3340          if ((previousValue != null))
3341          {
3342            this._Job.Entity = null;
3343            previousValue.StateLogs.Remove(this);
3344          }
3345          this._Job.Entity = value;
3346          if ((value != null))
3347          {
3348            value.StateLogs.Add(this);
3349            this._JobId = value.TaskId;
3350          }
3351          else
3352          {
3353            this._JobId = default(System.Guid);
3354          }
3355          this.SendPropertyChanged("Task");
3356        }
3357      }
3358    }
3359   
3360    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_StateLog", Storage="_Resource", ThisKey="SlaveId", OtherKey="ResourceId", IsForeignKey=true)]
3361    public Resource Resource
3362    {
3363      get
3364      {
3365        return this._Resource.Entity;
3366      }
3367      set
3368      {
3369        Resource previousValue = this._Resource.Entity;
3370        if (((previousValue != value)
3371              || (this._Resource.HasLoadedOrAssignedValue == false)))
3372        {
3373          this.SendPropertyChanging();
3374          if ((previousValue != null))
3375          {
3376            this._Resource.Entity = null;
3377            previousValue.StateLogs.Remove(this);
3378          }
3379          this._Resource.Entity = value;
3380          if ((value != null))
3381          {
3382            value.StateLogs.Add(this);
3383            this._SlaveId = value.ResourceId;
3384          }
3385          else
3386          {
3387            this._SlaveId = default(Nullable<System.Guid>);
3388          }
3389          this.SendPropertyChanged("Resource");
3390        }
3391      }
3392    }
3393   
3394    public event PropertyChangingEventHandler PropertyChanging;
3395   
3396    public event PropertyChangedEventHandler PropertyChanged;
3397   
3398    protected virtual void SendPropertyChanging()
3399    {
3400      if ((this.PropertyChanging != null))
3401      {
3402        this.PropertyChanging(this, emptyChangingEventArgs);
3403      }
3404    }
3405   
3406    protected virtual void SendPropertyChanged(String propertyName)
3407    {
3408      if ((this.PropertyChanged != null))
3409      {
3410        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3411      }
3412    }
3413  }
3414 
3415  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.JobPermission")]
3416  public partial class JobPermission : INotifyPropertyChanging, INotifyPropertyChanged
3417  {
3418   
3419    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3420   
3421    private System.Guid _HiveExperimentId;
3422   
3423    private System.Guid _GrantedUserId;
3424   
3425    private System.Guid _GrantedByUserId;
3426   
3427    private global::HeuristicLab.Services.Hive.DataAccess.Permission _Permission;
3428   
3429    private EntityRef<Job> _HiveExperiment;
3430   
3431    #region Extensibility Method Definitions
3432    partial void OnLoaded();
3433    partial void OnValidate(System.Data.Linq.ChangeAction action);
3434    partial void OnCreated();
3435    partial void OnJobIdChanging(System.Guid value);
3436    partial void OnJobIdChanged();
3437    partial void OnGrantedUserIdChanging(System.Guid value);
3438    partial void OnGrantedUserIdChanged();
3439    partial void OnGrantedByUserIdChanging(System.Guid value);
3440    partial void OnGrantedByUserIdChanged();
3441    partial void OnPermissionChanging(global::HeuristicLab.Services.Hive.DataAccess.Permission value);
3442    partial void OnPermissionChanged();
3443    #endregion
3444   
3445    public JobPermission()
3446    {
3447      this._HiveExperiment = default(EntityRef<Job>);
3448      OnCreated();
3449    }
3450   
3451    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_HiveExperimentId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
3452    public System.Guid JobId
3453    {
3454      get
3455      {
3456        return this._HiveExperimentId;
3457      }
3458      set
3459      {
3460        if ((this._HiveExperimentId != value))
3461        {
3462          if (this._HiveExperiment.HasLoadedOrAssignedValue)
3463          {
3464            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3465          }
3466          this.OnJobIdChanging(value);
3467          this.SendPropertyChanging();
3468          this._HiveExperimentId = value;
3469          this.SendPropertyChanged("JobId");
3470          this.OnJobIdChanged();
3471        }
3472      }
3473    }
3474   
3475    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GrantedUserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
3476    public System.Guid GrantedUserId
3477    {
3478      get
3479      {
3480        return this._GrantedUserId;
3481      }
3482      set
3483      {
3484        if ((this._GrantedUserId != value))
3485        {
3486          this.OnGrantedUserIdChanging(value);
3487          this.SendPropertyChanging();
3488          this._GrantedUserId = value;
3489          this.SendPropertyChanged("GrantedUserId");
3490          this.OnGrantedUserIdChanged();
3491        }
3492      }
3493    }
3494   
3495    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GrantedByUserId", DbType="UniqueIdentifier NOT NULL")]
3496    public System.Guid GrantedByUserId
3497    {
3498      get
3499      {
3500        return this._GrantedByUserId;
3501      }
3502      set
3503      {
3504        if ((this._GrantedByUserId != value))
3505        {
3506          this.OnGrantedByUserIdChanging(value);
3507          this.SendPropertyChanging();
3508          this._GrantedByUserId = value;
3509          this.SendPropertyChanged("GrantedByUserId");
3510          this.OnGrantedByUserIdChanged();
3511        }
3512      }
3513    }
3514   
3515    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Permission", DbType="VarChar(15) NOT NULL", CanBeNull=false)]
3516    public global::HeuristicLab.Services.Hive.DataAccess.Permission Permission
3517    {
3518      get
3519      {
3520        return this._Permission;
3521      }
3522      set
3523      {
3524        if ((this._Permission != value))
3525        {
3526          this.OnPermissionChanging(value);
3527          this.SendPropertyChanging();
3528          this._Permission = value;
3529          this.SendPropertyChanged("Permission");
3530          this.OnPermissionChanged();
3531        }
3532      }
3533    }
3534   
3535    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_JobPermission", Storage="_HiveExperiment", ThisKey="JobId", OtherKey="JobId", IsForeignKey=true, DeleteRule="CASCADE", DeleteOnNull=true)]
3536    public Job Job
3537    {
3538      get
3539      {
3540        return this._HiveExperiment.Entity;
3541      }
3542      set
3543      {
3544        Job previousValue = this._HiveExperiment.Entity;
3545        if (((previousValue != value)
3546              || (this._HiveExperiment.HasLoadedOrAssignedValue == false)))
3547        {
3548          this.SendPropertyChanging();
3549          if ((previousValue != null))
3550          {
3551            this._HiveExperiment.Entity = null;
3552            previousValue.JobPermissions.Remove(this);
3553          }
3554          this._HiveExperiment.Entity = value;
3555          if ((value != null))
3556          {
3557            value.JobPermissions.Add(this);
3558            this._HiveExperimentId = value.JobId;
3559          }
3560          else
3561          {
3562            this._HiveExperimentId = default(System.Guid);
3563          }
3564          this.SendPropertyChanged("Job");
3565        }
3566      }
3567    }
3568   
3569    public event PropertyChangingEventHandler PropertyChanging;
3570   
3571    public event PropertyChangedEventHandler PropertyChanged;
3572   
3573    protected virtual void SendPropertyChanging()
3574    {
3575      if ((this.PropertyChanging != null))
3576      {
3577        this.PropertyChanging(this, emptyChangingEventArgs);
3578      }
3579    }
3580   
3581    protected virtual void SendPropertyChanged(String propertyName)
3582    {
3583      if ((this.PropertyChanged != null))
3584      {
3585        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3586      }
3587    }
3588  }
3589 
3590  [global::System.Data.Linq.Mapping.TableAttribute(Name="")]
3591  public partial class Lifecycle : INotifyPropertyChanging, INotifyPropertyChanged
3592  {
3593   
3594    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3595   
3596    private int _LifecycleId;
3597   
3598    private System.DateTime _LastCleanup;
3599   
3600    #region Extensibility Method Definitions
3601    partial void OnLoaded();
3602    partial void OnValidate(System.Data.Linq.ChangeAction action);
3603    partial void OnCreated();
3604    partial void OnLifecycleIdChanging(int value);
3605    partial void OnLifecycleIdChanged();
3606    partial void OnLastCleanupChanging(System.DateTime value);
3607    partial void OnLastCleanupChanged();
3608    #endregion
3609   
3610    public Lifecycle()
3611    {
3612      OnCreated();
3613    }
3614   
3615    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LifecycleId", DbType="Int", IsPrimaryKey=true)]
3616    public int LifecycleId
3617    {
3618      get
3619      {
3620        return this._LifecycleId;
3621      }
3622      set
3623      {
3624        if ((this._LifecycleId != value))
3625        {
3626          this.OnLifecycleIdChanging(value);
3627          this.SendPropertyChanging();
3628          this._LifecycleId = value;
3629          this.SendPropertyChanged("LifecycleId");
3630          this.OnLifecycleIdChanged();
3631        }
3632      }
3633    }
3634   
3635    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastCleanup", DbType="DateTime")]
3636    public System.DateTime LastCleanup
3637    {
3638      get
3639      {
3640        return this._LastCleanup;
3641      }
3642      set
3643      {
3644        if ((this._LastCleanup != value))
3645        {
3646          this.OnLastCleanupChanging(value);
3647          this.SendPropertyChanging();
3648          this._LastCleanup = value;
3649          this.SendPropertyChanged("LastCleanup");
3650          this.OnLastCleanupChanged();
3651        }
3652      }
3653    }
3654   
3655    public event PropertyChangingEventHandler PropertyChanging;
3656   
3657    public event PropertyChangedEventHandler PropertyChanged;
3658   
3659    protected virtual void SendPropertyChanging()
3660    {
3661      if ((this.PropertyChanging != null))
3662      {
3663        this.PropertyChanging(this, emptyChangingEventArgs);
3664      }
3665    }
3666   
3667    protected virtual void SendPropertyChanged(String propertyName)
3668    {
3669      if ((this.PropertyChanged != null))
3670      {
3671        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3672      }
3673    }
3674  }
3675 
3676  [global::System.Data.Linq.Mapping.TableAttribute(Name="")]
3677  public partial class UserPriority : INotifyPropertyChanging, INotifyPropertyChanged
3678  {
3679   
3680    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3681   
3682    private System.Guid _UserId;
3683   
3684    private System.DateTime _DateEnqueued;
3685   
3686    #region Extensibility Method Definitions
3687    partial void OnLoaded();
3688    partial void OnValidate(System.Data.Linq.ChangeAction action);
3689    partial void OnCreated();
3690    partial void OnUserIdChanging(System.Guid value);
3691    partial void OnUserIdChanged();
3692    partial void OnDateEnqueuedChanging(System.DateTime value);
3693    partial void OnDateEnqueuedChanged();
3694    #endregion
3695   
3696    public UserPriority()
3697    {
3698      OnCreated();
3699    }
3700   
3701    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
3702    public System.Guid UserId
3703    {
3704      get
3705      {
3706        return this._UserId;
3707      }
3708      set
3709      {
3710        if ((this._UserId != value))
3711        {
3712          this.OnUserIdChanging(value);
3713          this.SendPropertyChanging();
3714          this._UserId = value;
3715          this.SendPropertyChanged("UserId");
3716          this.OnUserIdChanged();
3717        }
3718      }
3719    }
3720   
3721    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateEnqueued", DbType="DateTime NOT NULL")]
3722    public System.DateTime DateEnqueued
3723    {
3724      get
3725      {
3726        return this._DateEnqueued;
3727      }
3728      set
3729      {
3730        if ((this._DateEnqueued != value))
3731        {
3732          this.OnDateEnqueuedChanging(value);
3733          this.SendPropertyChanging();
3734          this._DateEnqueued = value;
3735          this.SendPropertyChanged("DateEnqueued");
3736          this.OnDateEnqueuedChanged();
3737        }
3738      }
3739    }
3740   
3741    public event PropertyChangingEventHandler PropertyChanging;
3742   
3743    public event PropertyChangedEventHandler PropertyChanged;
3744   
3745    protected virtual void SendPropertyChanging()
3746    {
3747      if ((this.PropertyChanging != null))
3748      {
3749        this.PropertyChanging(this, emptyChangingEventArgs);
3750      }
3751    }
3752   
3753    protected virtual void SendPropertyChanged(String propertyName)
3754    {
3755      if ((this.PropertyChanged != null))
3756      {
3757        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3758      }
3759    }
3760  }
3761 
3762  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimClient")]
3763  public partial class DimClient : INotifyPropertyChanging, INotifyPropertyChanged
3764  {
3765   
3766    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3767   
3768    private System.Guid _Id;
3769   
3770    private string _Name;
3771   
3772    private System.Guid _ResourceId;
3773   
3774    private System.Nullable<System.DateTime> _ExpirationTime;
3775   
3776    private System.Nullable<System.Guid> _ResourceGroupId;
3777   
3778    private System.Nullable<System.Guid> _ResourceGroup2Id;
3779   
3780    private string _GroupName;
3781   
3782    private string _GroupName2;
3783   
3784    private EntitySet<FactTask> _FactTasks;
3785   
3786    private EntitySet<FactClientInfo> _FactClientInfos;
3787   
3788    #region Extensibility Method Definitions
3789    partial void OnLoaded();
3790    partial void OnValidate(System.Data.Linq.ChangeAction action);
3791    partial void OnCreated();
3792    partial void OnIdChanging(System.Guid value);
3793    partial void OnIdChanged();
3794    partial void OnNameChanging(string value);
3795    partial void OnNameChanged();
3796    partial void OnResourceIdChanging(System.Guid value);
3797    partial void OnResourceIdChanged();
3798    partial void OnExpirationTimeChanging(System.Nullable<System.DateTime> value);
3799    partial void OnExpirationTimeChanged();
3800    partial void OnResourceGroupIdChanging(System.Nullable<System.Guid> value);
3801    partial void OnResourceGroupIdChanged();
3802    partial void OnResourceGroup2IdChanging(System.Nullable<System.Guid> value);
3803    partial void OnResourceGroup2IdChanged();
3804    partial void OnGroupNameChanging(string value);
3805    partial void OnGroupNameChanged();
3806    partial void OnGroupName2Changing(string value);
3807    partial void OnGroupName2Changed();
3808    #endregion
3809   
3810    public DimClient()
3811    {
3812      this._FactTasks = new EntitySet<FactTask>(new Action<FactTask>(this.attach_FactTasks), new Action<FactTask>(this.detach_FactTasks));
3813      this._FactClientInfos = new EntitySet<FactClientInfo>(new Action<FactClientInfo>(this.attach_FactClientInfos), new Action<FactClientInfo>(this.detach_FactClientInfos));
3814      OnCreated();
3815    }
3816   
3817    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
3818    public System.Guid Id
3819    {
3820      get
3821      {
3822        return this._Id;
3823      }
3824      set
3825      {
3826        if ((this._Id != value))
3827        {
3828          this.OnIdChanging(value);
3829          this.SendPropertyChanging();
3830          this._Id = value;
3831          this.SendPropertyChanged("Id");
3832          this.OnIdChanged();
3833        }
3834      }
3835    }
3836   
3837    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
3838    public string Name
3839    {
3840      get
3841      {
3842        return this._Name;
3843      }
3844      set
3845      {
3846        if ((this._Name != value))
3847        {
3848          this.OnNameChanging(value);
3849          this.SendPropertyChanging();
3850          this._Name = value;
3851          this.SendPropertyChanged("Name");
3852          this.OnNameChanged();
3853        }
3854      }
3855    }
3856   
3857    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier NOT NULL")]
3858    public System.Guid ResourceId
3859    {
3860      get
3861      {
3862        return this._ResourceId;
3863      }
3864      set
3865      {
3866        if ((this._ResourceId != value))
3867        {
3868          this.OnResourceIdChanging(value);
3869          this.SendPropertyChanging();
3870          this._ResourceId = value;
3871          this.SendPropertyChanged("ResourceId");
3872          this.OnResourceIdChanged();
3873        }
3874      }
3875    }
3876   
3877    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ExpirationTime", DbType="DateTime")]
3878    public System.Nullable<System.DateTime> ExpirationTime
3879    {
3880      get
3881      {
3882        return this._ExpirationTime;
3883      }
3884      set
3885      {
3886        if ((this._ExpirationTime != value))
3887        {
3888          this.OnExpirationTimeChanging(value);
3889          this.SendPropertyChanging();
3890          this._ExpirationTime = value;
3891          this.SendPropertyChanged("ExpirationTime");
3892          this.OnExpirationTimeChanged();
3893        }
3894      }
3895    }
3896   
3897    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceGroupId", DbType="UniqueIdentifier")]
3898    public System.Nullable<System.Guid> ResourceGroupId
3899    {
3900      get
3901      {
3902        return this._ResourceGroupId;
3903      }
3904      set
3905      {
3906        if ((this._ResourceGroupId != value))
3907        {
3908          this.OnResourceGroupIdChanging(value);
3909          this.SendPropertyChanging();
3910          this._ResourceGroupId = value;
3911          this.SendPropertyChanged("ResourceGroupId");
3912          this.OnResourceGroupIdChanged();
3913        }
3914      }
3915    }
3916   
3917    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceGroup2Id", DbType="UniqueIdentifier")]
3918    public System.Nullable<System.Guid> ResourceGroup2Id
3919    {
3920      get
3921      {
3922        return this._ResourceGroup2Id;
3923      }
3924      set
3925      {
3926        if ((this._ResourceGroup2Id != value))
3927        {
3928          this.OnResourceGroup2IdChanging(value);
3929          this.SendPropertyChanging();
3930          this._ResourceGroup2Id = value;
3931          this.SendPropertyChanged("ResourceGroup2Id");
3932          this.OnResourceGroup2IdChanged();
3933        }
3934      }
3935    }
3936   
3937    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GroupName")]
3938    public string GroupName
3939    {
3940      get
3941      {
3942        return this._GroupName;
3943      }
3944      set
3945      {
3946        if ((this._GroupName != value))
3947        {
3948          this.OnGroupNameChanging(value);
3949          this.SendPropertyChanging();
3950          this._GroupName = value;
3951          this.SendPropertyChanged("GroupName");
3952          this.OnGroupNameChanged();
3953        }
3954      }
3955    }
3956   
3957    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GroupName2")]
3958    public string GroupName2
3959    {
3960      get
3961      {
3962        return this._GroupName2;
3963      }
3964      set
3965      {
3966        if ((this._GroupName2 != value))
3967        {
3968          this.OnGroupName2Changing(value);
3969          this.SendPropertyChanging();
3970          this._GroupName2 = value;
3971          this.SendPropertyChanged("GroupName2");
3972          this.OnGroupName2Changed();
3973        }
3974      }
3975    }
3976   
3977    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactTask", Storage="_FactTasks", ThisKey="Id", OtherKey="LastClientId")]
3978    public EntitySet<FactTask> FactTasks
3979    {
3980      get
3981      {
3982        return this._FactTasks;
3983      }
3984      set
3985      {
3986        this._FactTasks.Assign(value);
3987      }
3988    }
3989   
3990    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactClientInfo", Storage="_FactClientInfos", ThisKey="Id", OtherKey="ClientId")]
3991    public EntitySet<FactClientInfo> FactClientInfos
3992    {
3993      get
3994      {
3995        return this._FactClientInfos;
3996      }
3997      set
3998      {
3999        this._FactClientInfos.Assign(value);
4000      }
4001    }
4002   
4003    public event PropertyChangingEventHandler PropertyChanging;
4004   
4005    public event PropertyChangedEventHandler PropertyChanged;
4006   
4007    protected virtual void SendPropertyChanging()
4008    {
4009      if ((this.PropertyChanging != null))
4010      {
4011        this.PropertyChanging(this, emptyChangingEventArgs);
4012      }
4013    }
4014   
4015    protected virtual void SendPropertyChanged(String propertyName)
4016    {
4017      if ((this.PropertyChanged != null))
4018      {
4019        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
4020      }
4021    }
4022   
4023    private void attach_FactTasks(FactTask entity)
4024    {
4025      this.SendPropertyChanging();
4026      entity.DimClient = this;
4027    }
4028   
4029    private void detach_FactTasks(FactTask entity)
4030    {
4031      this.SendPropertyChanging();
4032      entity.DimClient = null;
4033    }
4034   
4035    private void attach_FactClientInfos(FactClientInfo entity)
4036    {
4037      this.SendPropertyChanging();
4038      entity.DimClient = this;
4039    }
4040   
4041    private void detach_FactClientInfos(FactClientInfo entity)
4042    {
4043      this.SendPropertyChanging();
4044      entity.DimClient = null;
4045    }
4046  }
4047 
4048  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].FactTask")]
4049  public partial class FactTask : INotifyPropertyChanging, INotifyPropertyChanged
4050  {
4051   
4052    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
4053   
4054    private System.Guid _TaskId;
4055   
4056    private long _TotalRuntime;
4057   
4058    private long _TotalWaitingTime;
4059   
4060    private long _TotalTransferTime;
4061   
4062    private int _NumCalculationRuns;
4063   
4064    private int _NumFails;
4065   
4066    private int _CoresRequired;
4067   
4068    private int _MemoryRequired;
4069   
4070    private int _Priority;
4071   
4072    private System.Nullable<System.Guid> _LastClientId;
4073   
4074    private System.Guid _JobId;
4075   
4076    private System.Nullable<System.DateTime> _EndTime;
4077   
4078    private global::HeuristicLab.Services.Hive.DataAccess.TaskState _TaskState;
4079   
4080    private string _Exception;
4081   
4082    private long _InitialWaitingTimeMs;
4083   
4084    private System.Nullable<System.DateTime> _StartTime;
4085   
4086    private EntityRef<DimClient> _DimClient;
4087   
4088    private EntityRef<DimJob> _DimJob;
4089   
4090    #region Extensibility Method Definitions
4091    partial void OnLoaded();
4092    partial void OnValidate(System.Data.Linq.ChangeAction action);
4093    partial void OnCreated();
4094    partial void OnTaskIdChanging(System.Guid value);
4095    partial void OnTaskIdChanged();
4096    partial void OnCalculatingTimeChanging(long value);
4097    partial void OnCalculatingTimeChanged();
4098    partial void OnWaitingTimeChanging(long value);
4099    partial void OnWaitingTimeChanged();
4100    partial void OnTransferTimeChanging(long value);
4101    partial void OnTransferTimeChanged();
4102    partial void OnNumCalculationRunsChanging(int value);
4103    partial void OnNumCalculationRunsChanged();
4104    partial void OnNumRetriesChanging(int value);
4105    partial void OnNumRetriesChanged();
4106    partial void OnCoresRequiredChanging(int value);
4107    partial void OnCoresRequiredChanged();
4108    partial void OnMemoryRequiredChanging(int value);
4109    partial void OnMemoryRequiredChanged();
4110    partial void OnPriorityChanging(int value);
4111    partial void OnPriorityChanged();
4112    partial void OnLastClientIdChanging(System.Nullable<System.Guid> value);
4113    partial void OnLastClientIdChanged();
4114    partial void OnJobIdChanging(System.Guid value);
4115    partial void OnJobIdChanged();
4116    partial void OnEndTimeChanging(System.Nullable<System.DateTime> value);
4117    partial void OnEndTimeChanged();
4118    partial void OnTaskStateChanging(global::HeuristicLab.Services.Hive.DataAccess.TaskState value);
4119    partial void OnTaskStateChanged();
4120    partial void OnExceptionChanging(string value);
4121    partial void OnExceptionChanged();
4122    partial void OnInitialWaitingTimeChanging(long value);
4123    partial void OnInitialWaitingTimeChanged();
4124    partial void OnStartTimeChanging(System.Nullable<System.DateTime> value);
4125    partial void OnStartTimeChanged();
4126    #endregion
4127   
4128    public FactTask()
4129    {
4130      this._DimClient = default(EntityRef<DimClient>);
4131      this._DimJob = default(EntityRef<DimJob>);
4132      OnCreated();
4133    }
4134   
4135    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TaskId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
4136    public System.Guid TaskId
4137    {
4138      get
4139      {
4140        return this._TaskId;
4141      }
4142      set
4143      {
4144        if ((this._TaskId != value))
4145        {
4146          this.OnTaskIdChanging(value);
4147          this.SendPropertyChanging();
4148          this._TaskId = value;
4149          this.SendPropertyChanged("TaskId");
4150          this.OnTaskIdChanged();
4151        }
4152      }
4153    }
4154   
4155    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalRuntime", DbType="INT NOT NULL")]
4156    public long CalculatingTime
4157    {
4158      get
4159      {
4160        return this._TotalRuntime;
4161      }
4162      set
4163      {
4164        if ((this._TotalRuntime != value))
4165        {
4166          this.OnCalculatingTimeChanging(value);
4167          this.SendPropertyChanging();
4168          this._TotalRuntime = value;
4169          this.SendPropertyChanged("CalculatingTime");
4170          this.OnCalculatingTimeChanged();
4171        }
4172      }
4173    }
4174   
4175    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalWaitingTime", DbType="INT NOT NULL")]
4176    public long WaitingTime
4177    {
4178      get
4179      {
4180        return this._TotalWaitingTime;
4181      }
4182      set
4183      {
4184        if ((this._TotalWaitingTime != value))
4185        {
4186          this.OnWaitingTimeChanging(value);
4187          this.SendPropertyChanging();
4188          this._TotalWaitingTime = value;
4189          this.SendPropertyChanged("WaitingTime");
4190          this.OnWaitingTimeChanged();
4191        }
4192      }
4193    }
4194   
4195    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTransferTime", DbType="INT NOT NULL")]
4196    public long TransferTime
4197    {
4198      get
4199      {
4200        return this._TotalTransferTime;
4201      }
4202      set
4203      {
4204        if ((this._TotalTransferTime != value))
4205        {
4206          this.OnTransferTimeChanging(value);
4207          this.SendPropertyChanging();
4208          this._TotalTransferTime = value;
4209          this.SendPropertyChanged("TransferTime");
4210          this.OnTransferTimeChanged();
4211        }
4212      }
4213    }
4214   
4215    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumCalculationRuns", DbType="Int NOT NULL")]
4216    public int NumCalculationRuns
4217    {
4218      get
4219      {
4220        return this._NumCalculationRuns;
4221      }
4222      set
4223      {
4224        if ((this._NumCalculationRuns != value))
4225        {
4226          this.OnNumCalculationRunsChanging(value);
4227          this.SendPropertyChanging();
4228          this._NumCalculationRuns = value;
4229          this.SendPropertyChanged("NumCalculationRuns");
4230          this.OnNumCalculationRunsChanged();
4231        }
4232      }
4233    }
4234   
4235    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumFails", DbType="Int NOT NULL")]
4236    public int NumRetries
4237    {
4238      get
4239      {
4240        return this._NumFails;
4241      }
4242      set
4243      {
4244        if ((this._NumFails != value))
4245        {
4246          this.OnNumRetriesChanging(value);
4247          this.SendPropertyChanging();
4248          this._NumFails = value;
4249          this.SendPropertyChanged("NumRetries");
4250          this.OnNumRetriesChanged();
4251        }
4252      }
4253    }
4254   
4255    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CoresRequired", DbType="Int NOT NULL")]
4256    public int CoresRequired
4257    {
4258      get
4259      {
4260        return this._CoresRequired;
4261      }
4262      set
4263      {
4264        if ((this._CoresRequired != value))
4265        {
4266          this.OnCoresRequiredChanging(value);
4267          this.SendPropertyChanging();
4268          this._CoresRequired = value;
4269          this.SendPropertyChanged("CoresRequired");
4270          this.OnCoresRequiredChanged();
4271        }
4272      }
4273    }
4274   
4275    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_MemoryRequired", DbType="Int NOT NULL")]
4276    public int MemoryRequired
4277    {
4278      get
4279      {
4280        return this._MemoryRequired;
4281      }
4282      set
4283      {
4284        if ((this._MemoryRequired != value))
4285        {
4286          this.OnMemoryRequiredChanging(value);
4287          this.SendPropertyChanging();
4288          this._MemoryRequired = value;
4289          this.SendPropertyChanged("MemoryRequired");
4290          this.OnMemoryRequiredChanged();
4291        }
4292      }
4293    }
4294   
4295    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Priority", DbType="Int NOT NULL")]
4296    public int Priority
4297    {
4298      get
4299      {
4300        return this._Priority;
4301      }
4302      set
4303      {
4304        if ((this._Priority != value))
4305        {
4306          this.OnPriorityChanging(value);
4307          this.SendPropertyChanging();
4308          this._Priority = value;
4309          this.SendPropertyChanged("Priority");
4310          this.OnPriorityChanged();
4311        }
4312      }
4313    }
4314   
4315    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastClientId", DbType="UniqueIdentifier NOT NULL")]
4316    public System.Nullable<System.Guid> LastClientId
4317    {
4318      get
4319      {
4320        return this._LastClientId;
4321      }
4322      set
4323      {
4324        if ((this._LastClientId != value))
4325        {
4326          if (this._DimClient.HasLoadedOrAssignedValue)
4327          {
4328            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
4329          }
4330          this.OnLastClientIdChanging(value);
4331          this.SendPropertyChanging();
4332          this._LastClientId = value;
4333          this.SendPropertyChanged("LastClientId");
4334          this.OnLastClientIdChanged();
4335        }
4336      }
4337    }
4338   
4339    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL")]
4340    public System.Guid JobId
4341    {
4342      get
4343      {
4344        return this._JobId;
4345      }
4346      set
4347      {
4348        if ((this._JobId != value))
4349        {
4350          if (this._DimJob.HasLoadedOrAssignedValue)
4351          {
4352            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
4353          }
4354          this.OnJobIdChanging(value);
4355          this.SendPropertyChanging();
4356          this._JobId = value;
4357          this.SendPropertyChanged("JobId");
4358          this.OnJobIdChanged();
4359        }
4360      }
4361    }
4362   
4363    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_EndTime", DbType="DateTime NOT NULL")]
4364    public System.Nullable<System.DateTime> EndTime
4365    {
4366      get
4367      {
4368        return this._EndTime;
4369      }
4370      set
4371      {
4372        if ((this._EndTime != value))
4373        {
4374          this.OnEndTimeChanging(value);
4375          this.SendPropertyChanging();
4376          this._EndTime = value;
4377          this.SendPropertyChanged("EndTime");
4378          this.OnEndTimeChanged();
4379        }
4380      }
4381    }
4382   
4383    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TaskState", DbType="varchar(30)", CanBeNull=false)]
4384    public global::HeuristicLab.Services.Hive.DataAccess.TaskState TaskState
4385    {
4386      get
4387      {
4388        return this._TaskState;
4389      }
4390      set
4391      {
4392        if ((this._TaskState != value))
4393        {
4394          this.OnTaskStateChanging(value);
4395          this.SendPropertyChanging();
4396          this._TaskState = value;
4397          this.SendPropertyChanged("TaskState");
4398          this.OnTaskStateChanged();
4399        }
4400      }
4401    }
4402   
4403    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Exception", DbType="varchar(MAX)")]
4404    public string Exception
4405    {
4406      get
4407      {
4408        return this._Exception;
4409      }
4410      set
4411      {
4412        if ((this._Exception != value))
4413        {
4414          this.OnExceptionChanging(value);
4415          this.SendPropertyChanging();
4416          this._Exception = value;
4417          this.SendPropertyChanged("Exception");
4418          this.OnExceptionChanged();
4419        }
4420      }
4421    }
4422   
4423    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_InitialWaitingTimeMs", DbType="INT")]
4424    public long InitialWaitingTime
4425    {
4426      get
4427      {
4428        return this._InitialWaitingTimeMs;
4429      }
4430      set
4431      {
4432        if ((this._InitialWaitingTimeMs != value))
4433        {
4434          this.OnInitialWaitingTimeChanging(value);
4435          this.SendPropertyChanging();
4436          this._InitialWaitingTimeMs = value;
4437          this.SendPropertyChanged("InitialWaitingTime");
4438          this.OnInitialWaitingTimeChanged();
4439        }
4440      }
4441    }
4442   
4443    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StartTime")]
4444    public System.Nullable<System.DateTime> StartTime
4445    {
4446      get
4447      {
4448        return this._StartTime;
4449      }
4450      set
4451      {
4452        if ((this._StartTime != value))
4453        {
4454          this.OnStartTimeChanging(value);
4455          this.SendPropertyChanging();
4456          this._StartTime = value;
4457          this.SendPropertyChanged("StartTime");
4458          this.OnStartTimeChanged();
4459        }
4460      }
4461    }
4462   
4463    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactTask", Storage="_DimClient", ThisKey="LastClientId", OtherKey="Id", IsForeignKey=true)]
4464    public DimClient DimClient
4465    {
4466      get
4467      {
4468        return this._DimClient.Entity;
4469      }
4470      set
4471      {
4472        DimClient previousValue = this._DimClient.Entity;
4473        if (((previousValue != value)
4474              || (this._DimClient.HasLoadedOrAssignedValue == false)))
4475        {
4476          this.SendPropertyChanging();
4477          if ((previousValue != null))
4478          {
4479            this._DimClient.Entity = null;
4480            previousValue.FactTasks.Remove(this);
4481          }
4482          this._DimClient.Entity = value;
4483          if ((value != null))
4484          {
4485            value.FactTasks.Add(this);
4486            this._LastClientId = value.Id;
4487          }
4488          else
4489          {
4490            this._LastClientId = default(Nullable<System.Guid>);
4491          }
4492          this.SendPropertyChanged("DimClient");
4493        }
4494      }
4495    }
4496   
4497    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimJob_FactTask", Storage="_DimJob", ThisKey="JobId", OtherKey="JobId", IsForeignKey=true)]
4498    public DimJob DimJob
4499    {
4500      get
4501      {
4502        return this._DimJob.Entity;
4503      }
4504      set
4505      {
4506        DimJob previousValue = this._DimJob.Entity;
4507        if (((previousValue != value)
4508              || (this._DimJob.HasLoadedOrAssignedValue == false)))
4509        {
4510          this.SendPropertyChanging();
4511          if ((previousValue != null))
4512          {
4513            this._DimJob.Entity = null;
4514            previousValue.FactTasks.Remove(this);
4515          }
4516          this._DimJob.Entity = value;
4517          if ((value != null))
4518          {
4519            value.FactTasks.Add(this);
4520            this._JobId = value.JobId;
4521          }
4522          else
4523          {
4524            this._JobId = default(System.Guid);
4525          }
4526          this.SendPropertyChanged("DimJob");
4527        }
4528      }
4529    }
4530   
4531    public event PropertyChangingEventHandler PropertyChanging;
4532   
4533    public event PropertyChangedEventHandler PropertyChanged;
4534   
4535    protected virtual void SendPropertyChanging()
4536    {
4537      if ((this.PropertyChanging != null))
4538      {
4539        this.PropertyChanging(this, emptyChangingEventArgs);
4540      }
4541    }
4542   
4543    protected virtual void SendPropertyChanged(String propertyName)
4544    {
4545      if ((this.PropertyChanged != null))
4546      {
4547        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
4548      }
4549    }
4550  }
4551 
4552  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimJob")]
4553  public partial class DimJob : INotifyPropertyChanging, INotifyPropertyChanged
4554  {
4555   
4556    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
4557   
4558    private System.Guid _JobId;
4559   
4560    private System.Guid _UserId;
4561   
4562    private string _JobName;
4563   
4564    private string _UserName;
4565   
4566    private System.DateTime _DateCreated;
4567   
4568    private int _TotalTasks;
4569   
4570    private int _CompletedTasks;
4571   
4572    private System.Nullable<System.DateTime> _DateCompleted;
4573   
4574    private EntitySet<FactTask> _FactTasks;
4575   
4576    #region Extensibility Method Definitions
4577    partial void OnLoaded();
4578    partial void OnValidate(System.Data.Linq.ChangeAction action);
4579    partial void OnCreated();
4580    partial void OnJobIdChanging(System.Guid value);
4581    partial void OnJobIdChanged();
4582    partial void OnUserIdChanging(System.Guid value);
4583    partial void OnUserIdChanged();
4584    partial void OnJobNameChanging(string value);
4585    partial void OnJobNameChanged();
4586    partial void OnUserNameChanging(string value);
4587    partial void OnUserNameChanged();
4588    partial void OnDateCreatedChanging(System.DateTime value);
4589    partial void OnDateCreatedChanged();
4590    partial void OnTotalTasksChanging(int value);
4591    partial void OnTotalTasksChanged();
4592    partial void OnCompletedTasksChanging(int value);
4593    partial void OnCompletedTasksChanged();
4594    partial void OnDateCompletedChanging(System.Nullable<System.DateTime> value);
4595    partial void OnDateCompletedChanged();
4596    #endregion
4597   
4598    public DimJob()
4599    {
4600      this._FactTasks = new EntitySet<FactTask>(new Action<FactTask>(this.attach_FactTasks), new Action<FactTask>(this.detach_FactTasks));
4601      OnCreated();
4602    }
4603   
4604    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
4605    public System.Guid JobId
4606    {
4607      get
4608      {
4609        return this._JobId;
4610      }
4611      set
4612      {
4613        if ((this._JobId != value))
4614        {
4615          this.OnJobIdChanging(value);
4616          this.SendPropertyChanging();
4617          this._JobId = value;
4618          this.SendPropertyChanged("JobId");
4619          this.OnJobIdChanged();
4620        }
4621      }
4622    }
4623   
4624    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL")]
4625    public System.Guid UserId
4626    {
4627      get
4628      {
4629        return this._UserId;
4630      }
4631      set
4632      {
4633        if ((this._UserId != value))
4634        {
4635          this.OnUserIdChanging(value);
4636          this.SendPropertyChanging();
4637          this._UserId = value;
4638          this.SendPropertyChanged("UserId");
4639          this.OnUserIdChanged();
4640        }
4641      }
4642    }
4643   
4644    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobName", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
4645    public string JobName
4646    {
4647      get
4648      {
4649        return this._JobName;
4650      }
4651      set
4652      {
4653        if ((this._JobName != value))
4654        {
4655          this.OnJobNameChanging(value);
4656          this.SendPropertyChanging();
4657          this._JobName = value;
4658          this.SendPropertyChanged("JobName");
4659          this.OnJobNameChanged();
4660        }
4661      }
4662    }
4663   
4664    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserName", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
4665    public string UserName
4666    {
4667      get
4668      {
4669        return this._UserName;
4670      }
4671      set
4672      {
4673        if ((this._UserName != value))
4674        {
4675          this.OnUserNameChanging(value);
4676          this.SendPropertyChanging();
4677          this._UserName = value;
4678          this.SendPropertyChanged("UserName");
4679          this.OnUserNameChanged();
4680        }
4681      }
4682    }
4683   
4684    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateCreated", DbType="DateTime NOT NULL")]
4685    public System.DateTime DateCreated
4686    {
4687      get
4688      {
4689        return this._DateCreated;
4690      }
4691      set
4692      {
4693        if ((this._DateCreated != value))
4694        {
4695          this.OnDateCreatedChanging(value);
4696          this.SendPropertyChanging();
4697          this._DateCreated = value;
4698          this.SendPropertyChanged("DateCreated");
4699          this.OnDateCreatedChanged();
4700        }
4701      }
4702    }
4703   
4704    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTasks", DbType="INT NOT NULL")]
4705    public int TotalTasks
4706    {
4707      get
4708      {
4709        return this._TotalTasks;
4710      }
4711      set
4712      {
4713        if ((this._TotalTasks != value))
4714        {
4715          this.OnTotalTasksChanging(value);
4716          this.SendPropertyChanging();
4717          this._TotalTasks = value;
4718          this.SendPropertyChanged("TotalTasks");
4719          this.OnTotalTasksChanged();
4720        }
4721      }
4722    }
4723   
4724    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CompletedTasks", DbType="INT NOT NULL")]
4725    public int CompletedTasks
4726    {
4727      get
4728      {
4729        return this._CompletedTasks;
4730      }
4731      set
4732      {
4733        if ((this._CompletedTasks != value))
4734        {
4735          this.OnCompletedTasksChanging(value);
4736          this.SendPropertyChanging();
4737          this._CompletedTasks = value;
4738          this.SendPropertyChanged("CompletedTasks");
4739          this.OnCompletedTasksChanged();
4740        }
4741      }
4742    }
4743   
4744    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateCompleted", DbType="DateTime NULL")]
4745    public System.Nullable<System.DateTime> DateCompleted
4746    {
4747      get
4748      {
4749        return this._DateCompleted;
4750      }
4751      set
4752      {
4753        if ((this._DateCompleted != value))
4754        {
4755          this.OnDateCompletedChanging(value);
4756          this.SendPropertyChanging();
4757          this._DateCompleted = value;
4758          this.SendPropertyChanged("DateCompleted");
4759          this.OnDateCompletedChanged();
4760        }
4761      }
4762    }
4763   
4764    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimJob_FactTask", Storage="_FactTasks", ThisKey="JobId", OtherKey="JobId")]
4765    public EntitySet<FactTask> FactTasks
4766    {
4767      get
4768      {
4769        return this._FactTasks;
4770      }
4771      set
4772      {
4773        this._FactTasks.Assign(value);
4774      }
4775    }
4776   
4777    public event PropertyChangingEventHandler PropertyChanging;
4778   
4779    public event PropertyChangedEventHandler PropertyChanged;
4780   
4781    protected virtual void SendPropertyChanging()
4782    {
4783      if ((this.PropertyChanging != null))
4784      {
4785        this.PropertyChanging(this, emptyChangingEventArgs);
4786      }
4787    }
4788   
4789    protected virtual void SendPropertyChanged(String propertyName)
4790    {
4791      if ((this.PropertyChanged != null))
4792      {
4793        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
4794      }
4795    }
4796   
4797    private void attach_FactTasks(FactTask entity)
4798    {
4799      this.SendPropertyChanging();
4800      entity.DimJob = this;
4801    }
4802   
4803    private void detach_FactTasks(FactTask entity)
4804    {
4805      this.SendPropertyChanging();
4806      entity.DimJob = null;
4807    }
4808  }
4809 
4810  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimTime")]
4811  public partial class DimTime : INotifyPropertyChanging, INotifyPropertyChanged
4812  {
4813   
4814    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
4815   
4816    private System.DateTime _Time;
4817   
4818    private System.DateTime _Hour;
4819   
4820    private System.DateTime _Day;
4821   
4822    private System.DateTime _Month;
4823   
4824    private System.DateTime _Year;
4825   
4826    private System.DateTime _Minute;
4827   
4828    private EntitySet<FactClientInfo> _FactClientInfos;
4829   
4830    #region Extensibility Method Definitions
4831    partial void OnLoaded();
4832    partial void OnValidate(System.Data.Linq.ChangeAction action);
4833    partial void OnCreated();
4834    partial void OnTimeChanging(System.DateTime value);
4835    partial void OnTimeChanged();
4836    partial void OnHourChanging(System.DateTime value);
4837    partial void OnHourChanged();
4838    partial void OnDayChanging(System.DateTime value);
4839    partial void OnDayChanged();
4840    partial void OnMonthChanging(System.DateTime value);
4841    partial void OnMonthChanged();
4842    partial void OnYearChanging(System.DateTime value);
4843    partial void OnYearChanged();
4844    partial void OnMinuteChanging(System.DateTime value);
4845    partial void OnMinuteChanged();
4846    #endregion
4847   
4848    public DimTime()
4849    {
4850      this._FactClientInfos = new EntitySet<FactClientInfo>(new Action<FactClientInfo>(this.attach_FactClientInfos), new Action<FactClientInfo>(this.detach_FactClientInfos));
4851      OnCreated();
4852    }
4853   
4854    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Time", DbType="DateTime NOT NULL", IsPrimaryKey=true)]
4855    public System.DateTime Time
4856    {
4857      get
4858      {
4859        return this._Time;
4860      }
4861      set
4862      {
4863        if ((this._Time != value))
4864        {
4865          this.OnTimeChanging(value);
4866          this.SendPropertyChanging();
4867          this._Time = value;
4868          this.SendPropertyChanged("Time");
4869          this.OnTimeChanged();
4870        }
4871      }
4872    }
4873   
4874    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Hour", DbType="DateTime NOT NULL")]
4875    public System.DateTime Hour
4876    {
4877      get
4878      {
4879        return this._Hour;
4880      }
4881      set
4882      {
4883        if ((this._Hour != value))
4884        {
4885          this.OnHourChanging(value);
4886          this.SendPropertyChanging();
4887          this._Hour = value;
4888          this.SendPropertyChanged("Hour");
4889          this.OnHourChanged();
4890        }
4891      }
4892    }
4893   
4894    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Day", DbType="Date NOT NULL")]
4895    public System.DateTime Day
4896    {
4897      get
4898      {
4899        return this._Day;
4900      }
4901      set
4902      {
4903        if ((this._Day != value))
4904        {
4905          this.OnDayChanging(value);
4906          this.SendPropertyChanging();
4907          this._Day = value;
4908          this.SendPropertyChanged("Day");
4909          this.OnDayChanged();
4910        }
4911      }
4912    }
4913   
4914    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Month", DbType="Date NOT NULL")]
4915    public System.DateTime Month
4916    {
4917      get
4918      {
4919        return this._Month;
4920      }
4921      set
4922      {
4923        if ((this._Month != value))
4924        {
4925          this.OnMonthChanging(value);
4926          this.SendPropertyChanging();
4927          this._Month = value;
4928          this.SendPropertyChanged("Month");
4929          this.OnMonthChanged();
4930        }
4931      }
4932    }
4933   
4934    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Year", DbType="Date NOT NULL")]
4935    public System.DateTime Year
4936    {
4937      get
4938      {
4939        return this._Year;
4940      }
4941      set
4942      {
4943        if ((this._Year != value))
4944        {
4945          this.OnYearChanging(value);
4946          this.SendPropertyChanging();
4947          this._Year = value;
4948          this.SendPropertyChanged("Year");
4949          this.OnYearChanged();
4950        }
4951      }
4952    }
4953   
4954    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Minute")]
4955    public System.DateTime Minute
4956    {
4957      get
4958      {
4959        return this._Minute;
4960      }
4961      set
4962      {
4963        if ((this._Minute != value))
4964        {
4965          this.OnMinuteChanging(value);
4966          this.SendPropertyChanging();
4967          this._Minute = value;
4968          this.SendPropertyChanged("Minute");
4969          this.OnMinuteChanged();
4970        }
4971      }
4972    }
4973   
4974    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimTime_FactClientInfo", Storage="_FactClientInfos", ThisKey="Time", OtherKey="Time")]
4975    public EntitySet<FactClientInfo> FactClientInfos
4976    {
4977      get
4978      {
4979        return this._FactClientInfos;
4980      }
4981      set
4982      {
4983        this._FactClientInfos.Assign(value);
4984      }
4985    }
4986   
4987    public event PropertyChangingEventHandler PropertyChanging;
4988   
4989    public event PropertyChangedEventHandler PropertyChanged;
4990   
4991    protected virtual void SendPropertyChanging()
4992    {
4993      if ((this.PropertyChanging != null))
4994      {
4995        this.PropertyChanging(this, emptyChangingEventArgs);
4996      }
4997    }
4998   
4999    protected virtual void SendPropertyChanged(String propertyName)
5000    {
5001      if ((this.PropertyChanged != null))
5002      {
5003        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
5004      }
5005    }
5006   
5007    private void attach_FactClientInfos(FactClientInfo entity)
5008    {
5009      this.SendPropertyChanging();
5010      entity.DimTime = this;
5011    }
5012   
5013    private void detach_FactClientInfos(FactClientInfo entity)
5014    {
5015      this.SendPropertyChanging();
5016      entity.DimTime = null;
5017    }
5018  }
5019 
5020  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimUser")]
5021  public partial class DimUser : INotifyPropertyChanging, INotifyPropertyChanged
5022  {
5023   
5024    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
5025   
5026    private System.Guid _UserId;
5027   
5028    private string _Name;
5029   
5030    private EntitySet<FactClientInfo> _FactClientInfos;
5031   
5032    #region Extensibility Method Definitions
5033    partial void OnLoaded();
5034    partial void OnValidate(System.Data.Linq.ChangeAction action);
5035    partial void OnCreated();
5036    partial void OnUserIdChanging(System.Guid value);
5037    partial void OnUserIdChanged();
5038    partial void OnNameChanging(string value);
5039    partial void OnNameChanged();
5040    #endregion
5041   
5042    public DimUser()
5043    {
5044      this._FactClientInfos = new EntitySet<FactClientInfo>(new Action<FactClientInfo>(this.attach_FactClientInfos), new Action<FactClientInfo>(this.detach_FactClientInfos));
5045      OnCreated();
5046    }
5047   
5048    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
5049    public System.Guid UserId
5050    {
5051      get
5052      {
5053        return this._UserId;
5054      }
5055      set
5056      {
5057        if ((this._UserId != value))
5058        {
5059          this.OnUserIdChanging(value);
5060          this.SendPropertyChanging();
5061          this._UserId = value;
5062          this.SendPropertyChanged("UserId");
5063          this.OnUserIdChanged();
5064        }
5065      }
5066    }
5067   
5068    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
5069    public string Name
5070    {
5071      get
5072      {
5073        return this._Name;
5074      }
5075      set
5076      {
5077        if ((this._Name != value))
5078        {
5079          this.OnNameChanging(value);
5080          this.SendPropertyChanging();
5081          this._Name = value;
5082          this.SendPropertyChanged("Name");
5083          this.OnNameChanged();
5084        }
5085      }
5086    }
5087   
5088    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimUser_FactClientInfo", Storage="_FactClientInfos", ThisKey="UserId", OtherKey="UserId")]
5089    public EntitySet<FactClientInfo> FactClientInfos
5090    {
5091      get
5092      {
5093        return this._FactClientInfos;
5094      }
5095      set
5096      {
5097        this._FactClientInfos.Assign(value);
5098      }
5099    }
5100   
5101    public event PropertyChangingEventHandler PropertyChanging;
5102   
5103    public event PropertyChangedEventHandler PropertyChanged;
5104   
5105    protected virtual void SendPropertyChanging()
5106    {
5107      if ((this.PropertyChanging != null))
5108      {
5109        this.PropertyChanging(this, emptyChangingEventArgs);
5110      }
5111    }
5112   
5113    protected virtual void SendPropertyChanged(String propertyName)
5114    {
5115      if ((this.PropertyChanged != null))
5116      {
5117        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
5118      }
5119    }
5120   
5121    private void attach_FactClientInfos(FactClientInfo entity)
5122    {
5123      this.SendPropertyChanging();
5124      entity.DimUser = this;
5125    }
5126   
5127    private void detach_FactClientInfos(FactClientInfo entity)
5128    {
5129      this.SendPropertyChanging();
5130      entity.DimUser = null;
5131    }
5132  }
5133 
5134  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].FactClientInfo")]
5135  public partial class FactClientInfo : INotifyPropertyChanging, INotifyPropertyChanged
5136  {
5137   
5138    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
5139   
5140    private System.Guid _ClientId;
5141   
5142    private System.DateTime _Time;
5143   
5144    private System.Guid _UserId;
5145   
5146    private int _NumUsedCores;
5147   
5148    private int _NumTotalCores;
5149   
5150    private int _UsedMemory;
5151   
5152    private int _TotalMemory;
5153   
5154    private double _CpuUtilization;
5155   
5156    private long _TotalTimeIdle;
5157   
5158    private long _TotalTimeOffline;
5159   
5160    private long _TotalTimeUnavailable;
5161   
5162    private global::HeuristicLab.Services.Hive.DataAccess.SlaveState _SlaveState;
5163   
5164    private bool _IsAllowedToCalculate;
5165   
5166    private EntityRef<DimClient> _DimClient;
5167   
5168    private EntityRef<DimTime> _DimTime;
5169   
5170    private EntityRef<DimUser> _DimUser;
5171   
5172    #region Extensibility Method Definitions
5173    partial void OnLoaded();
5174    partial void OnValidate(System.Data.Linq.ChangeAction action);
5175    partial void OnCreated();
5176    partial void OnClientIdChanging(System.Guid value);
5177    partial void OnClientIdChanged();
5178    partial void OnTimeChanging(System.DateTime value);
5179    partial void OnTimeChanged();
5180    partial void OnUserIdChanging(System.Guid value);
5181    partial void OnUserIdChanged();
5182    partial void OnNumUsedCoresChanging(int value);
5183    partial void OnNumUsedCoresChanged();
5184    partial void OnNumTotalCoresChanging(int value);
5185    partial void OnNumTotalCoresChanged();
5186    partial void OnUsedMemoryChanging(int value);
5187    partial void OnUsedMemoryChanged();
5188    partial void OnTotalMemoryChanging(int value);
5189    partial void OnTotalMemoryChanged();
5190    partial void OnCpuUtilizationChanging(double value);
5191    partial void OnCpuUtilizationChanged();
5192    partial void OnIdleTimeChanging(long value);
5193    partial void OnIdleTimeChanged();
5194    partial void OnOfflineTimeChanging(long value);
5195    partial void OnOfflineTimeChanged();
5196    partial void OnUnavailableTimeChanging(long value);
5197    partial void OnUnavailableTimeChanged();
5198    partial void OnSlaveStateChanging(global::HeuristicLab.Services.Hive.DataAccess.SlaveState value);
5199    partial void OnSlaveStateChanged();
5200    partial void OnIsAllowedToCalculateChanging(bool value);
5201    partial void OnIsAllowedToCalculateChanged();
5202    #endregion
5203   
5204    public FactClientInfo()
5205    {
5206      this._DimClient = default(EntityRef<DimClient>);
5207      this._DimTime = default(EntityRef<DimTime>);
5208      this._DimUser = default(EntityRef<DimUser>);
5209      OnCreated();
5210    }
5211   
5212    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ClientId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
5213    public System.Guid ClientId
5214    {
5215      get
5216      {
5217        return this._ClientId;
5218      }
5219      set
5220      {
5221        if ((this._ClientId != value))
5222        {
5223          if (this._DimClient.HasLoadedOrAssignedValue)
5224          {
5225            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
5226          }
5227          this.OnClientIdChanging(value);
5228          this.SendPropertyChanging();
5229          this._ClientId = value;
5230          this.SendPropertyChanged("ClientId");
5231          this.OnClientIdChanged();
5232        }
5233      }
5234    }
5235   
5236    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Time", DbType="DateTime NOT NULL", IsPrimaryKey=true)]
5237    public System.DateTime Time
5238    {
5239      get
5240      {
5241        return this._Time;
5242      }
5243      set
5244      {
5245        if ((this._Time != value))
5246        {
5247          if (this._DimTime.HasLoadedOrAssignedValue)
5248          {
5249            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
5250          }
5251          this.OnTimeChanging(value);
5252          this.SendPropertyChanging();
5253          this._Time = value;
5254          this.SendPropertyChanged("Time");
5255          this.OnTimeChanged();
5256        }
5257      }
5258    }
5259   
5260    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
5261    public System.Guid UserId
5262    {
5263      get
5264      {
5265        return this._UserId;
5266      }
5267      set
5268      {
5269        if ((this._UserId != value))
5270        {
5271          if (this._DimUser.HasLoadedOrAssignedValue)
5272          {
5273            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
5274          }
5275          this.OnUserIdChanging(value);
5276          this.SendPropertyChanging();
5277          this._UserId = value;
5278          this.SendPropertyChanged("UserId");
5279          this.OnUserIdChanged();
5280        }
5281      }
5282    }
5283   
5284    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumUsedCores", DbType="Int NOT NULL")]
5285    public int NumUsedCores
5286    {
5287      get
5288      {
5289        return this._NumUsedCores;
5290      }
5291      set
5292      {
5293        if ((this._NumUsedCores != value))
5294        {
5295          this.OnNumUsedCoresChanging(value);
5296          this.SendPropertyChanging();
5297          this._NumUsedCores = value;
5298          this.SendPropertyChanged("NumUsedCores");
5299          this.OnNumUsedCoresChanged();
5300        }
5301      }
5302    }
5303   
5304    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumTotalCores", DbType="Int NOT NULL")]
5305    public int NumTotalCores
5306    {
5307      get
5308      {
5309        return this._NumTotalCores;
5310      }
5311      set
5312      {
5313        if ((this._NumTotalCores != value))
5314        {
5315          this.OnNumTotalCoresChanging(value);
5316          this.SendPropertyChanging();
5317          this._NumTotalCores = value;
5318          this.SendPropertyChanged("NumTotalCores");
5319          this.OnNumTotalCoresChanged();
5320        }
5321      }
5322    }
5323   
5324    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UsedMemory", DbType="Int NOT NULL")]
5325    public int UsedMemory
5326    {
5327      get
5328      {
5329        return this._UsedMemory;
5330      }
5331      set
5332      {
5333        if ((this._UsedMemory != value))
5334        {
5335          this.OnUsedMemoryChanging(value);
5336          this.SendPropertyChanging();
5337          this._UsedMemory = value;
5338          this.SendPropertyChanged("UsedMemory");
5339          this.OnUsedMemoryChanged();
5340        }
5341      }
5342    }
5343   
5344    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalMemory", DbType="Int NOT NULL")]
5345    public int TotalMemory
5346    {
5347      get
5348      {
5349        return this._TotalMemory;
5350      }
5351      set
5352      {
5353        if ((this._TotalMemory != value))
5354        {
5355          this.OnTotalMemoryChanging(value);
5356          this.SendPropertyChanging();
5357          this._TotalMemory = value;
5358          this.SendPropertyChanged("TotalMemory");
5359          this.OnTotalMemoryChanged();
5360        }
5361      }
5362    }
5363   
5364    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CpuUtilization", DbType="Float NOT NULL")]
5365    public double CpuUtilization
5366    {
5367      get
5368      {
5369        return this._CpuUtilization;
5370      }
5371      set
5372      {
5373        if ((this._CpuUtilization != value))
5374        {
5375          this.OnCpuUtilizationChanging(value);
5376          this.SendPropertyChanging();
5377          this._CpuUtilization = value;
5378          this.SendPropertyChanged("CpuUtilization");
5379          this.OnCpuUtilizationChanged();
5380        }
5381      }
5382    }
5383   
5384    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTimeIdle", DbType="INT NOT NULL")]
5385    public long IdleTime
5386    {
5387      get
5388      {
5389        return this._TotalTimeIdle;
5390      }
5391      set
5392      {
5393        if ((this._TotalTimeIdle != value))
5394        {
5395          this.OnIdleTimeChanging(value);
5396          this.SendPropertyChanging();
5397          this._TotalTimeIdle = value;
5398          this.SendPropertyChanged("IdleTime");
5399          this.OnIdleTimeChanged();
5400        }
5401      }
5402    }
5403   
5404    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTimeOffline", DbType="INT NOT NULL")]
5405    public long OfflineTime
5406    {
5407      get
5408      {
5409        return this._TotalTimeOffline;
5410      }
5411      set
5412      {
5413        if ((this._TotalTimeOffline != value))
5414        {
5415          this.OnOfflineTimeChanging(value);
5416          this.SendPropertyChanging();
5417          this._TotalTimeOffline = value;
5418          this.SendPropertyChanged("OfflineTime");
5419          this.OnOfflineTimeChanged();
5420        }
5421      }
5422    }
5423   
5424    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTimeUnavailable", DbType="INT NOT NULL")]
5425    public long UnavailableTime
5426    {
5427      get
5428      {
5429        return this._TotalTimeUnavailable;
5430      }
5431      set
5432      {
5433        if ((this._TotalTimeUnavailable != value))
5434        {
5435          this.OnUnavailableTimeChanging(value);
5436          this.SendPropertyChanging();
5437          this._TotalTimeUnavailable = value;
5438          this.SendPropertyChanged("UnavailableTime");
5439          this.OnUnavailableTimeChanged();
5440        }
5441      }
5442    }
5443   
5444    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_SlaveState", DbType="VarChar(15)", CanBeNull=false)]
5445    public global::HeuristicLab.Services.Hive.DataAccess.SlaveState SlaveState
5446    {
5447      get
5448      {
5449        return this._SlaveState;
5450      }
5451      set
5452      {
5453        if ((this._SlaveState != value))
5454        {
5455          this.OnSlaveStateChanging(value);
5456          this.SendPropertyChanging();
5457          this._SlaveState = value;
5458          this.SendPropertyChanged("SlaveState");
5459          this.OnSlaveStateChanged();
5460        }
5461      }
5462    }
5463   
5464    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsAllowedToCalculate", DbType="BIT")]
5465    public bool IsAllowedToCalculate
5466    {
5467      get
5468      {
5469        return this._IsAllowedToCalculate;
5470      }
5471      set
5472      {
5473        if ((this._IsAllowedToCalculate != value))
5474        {
5475          this.OnIsAllowedToCalculateChanging(value);
5476          this.SendPropertyChanging();
5477          this._IsAllowedToCalculate = value;
5478          this.SendPropertyChanged("IsAllowedToCalculate");
5479          this.OnIsAllowedToCalculateChanged();
5480        }
5481      }
5482    }
5483   
5484    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactClientInfo", Storage="_DimClient", ThisKey="ClientId", OtherKey="Id", IsForeignKey=true)]
5485    public DimClient DimClient
5486    {
5487      get
5488      {
5489        return this._DimClient.Entity;
5490      }
5491      set
5492      {
5493        DimClient previousValue = this._DimClient.Entity;
5494        if (((previousValue != value)
5495              || (this._DimClient.HasLoadedOrAssignedValue == false)))
5496        {
5497          this.SendPropertyChanging();
5498          if ((previousValue != null))
5499          {
5500            this._DimClient.Entity = null;
5501            previousValue.FactClientInfos.Remove(this);
5502          }
5503          this._DimClient.Entity = value;
5504          if ((value != null))
5505          {
5506            value.FactClientInfos.Add(this);
5507            this._ClientId = value.Id;
5508          }
5509          else
5510          {
5511            this._ClientId = default(System.Guid);
5512          }
5513          this.SendPropertyChanged("DimClient");
5514        }
5515      }
5516    }
5517   
5518    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimTime_FactClientInfo", Storage="_DimTime", ThisKey="Time", OtherKey="Time", IsForeignKey=true)]
5519    public DimTime DimTime
5520    {
5521      get
5522      {
5523        return this._DimTime.Entity;
5524      }
5525      set
5526      {
5527        DimTime previousValue = this._DimTime.Entity;
5528        if (((previousValue != value)
5529              || (this._DimTime.HasLoadedOrAssignedValue == false)))
5530        {
5531          this.SendPropertyChanging();
5532          if ((previousValue != null))
5533          {
5534            this._DimTime.Entity = null;
5535            previousValue.FactClientInfos.Remove(this);
5536          }
5537          this._DimTime.Entity = value;
5538          if ((value != null))
5539          {
5540            value.FactClientInfos.Add(this);
5541            this._Time = value.Time;
5542          }
5543          else
5544          {
5545            this._Time = default(System.DateTime);
5546          }
5547          this.SendPropertyChanged("DimTime");
5548        }
5549      }
5550    }
5551   
5552    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimUser_FactClientInfo", Storage="_DimUser", ThisKey="UserId", OtherKey="UserId", IsForeignKey=true)]
5553    public DimUser DimUser
5554    {
5555      get
5556      {
5557        return this._DimUser.Entity;
5558      }
5559      set
5560      {
5561        DimUser previousValue = this._DimUser.Entity;
5562        if (((previousValue != value)
5563              || (this._DimUser.HasLoadedOrAssignedValue == false)))
5564        {
5565          this.SendPropertyChanging();
5566          if ((previousValue != null))
5567          {
5568            this._DimUser.Entity = null;
5569            previousValue.FactClientInfos.Remove(this);
5570          }
5571          this._DimUser.Entity = value;
5572          if ((value != null))
5573          {
5574            value.FactClientInfos.Add(this);
5575            this._UserId = value.UserId;
5576          }
5577          else
5578          {
5579            this._UserId = default(System.Guid);
5580          }
5581          this.SendPropertyChanged("DimUser");
5582        }
5583      }
5584    }
5585   
5586    public event PropertyChangingEventHandler PropertyChanging;
5587   
5588    public event PropertyChangedEventHandler PropertyChanged;
5589   
5590    protected virtual void SendPropertyChanging()
5591    {
5592      if ((this.PropertyChanging != null))
5593      {
5594        this.PropertyChanging(this, emptyChangingEventArgs);
5595      }
5596    }
5597   
5598    protected virtual void SendPropertyChanged(String propertyName)
5599    {
5600      if ((this.PropertyChanged != null))
5601      {
5602        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
5603      }
5604    }
5605  }
5606 
5607  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Project")]
5608  public partial class Project : INotifyPropertyChanging, INotifyPropertyChanged
5609  {
5610   
5611    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
5612   
5613    private System.Guid _ProjectId;
5614   
5615    private System.Nullable<System.Guid> _ParentProjectId;
5616   
5617    private System.DateTime _DateCreated;
5618   
5619    private string _Name;
5620   
5621    private string _Description;
5622   
5623    private System.Guid _OwnerUserId;
5624   
5625    private System.DateTime _StartDate;
5626   
5627    private System.Nullable<System.DateTime> _EndDate;
5628   
5629    private EntitySet<AssignedProjectResource> _AssignedResources;
5630   
5631    private EntitySet<Job> _Jobs;
5632   
5633    private EntitySet<Project> _Projects;
5634   
5635    private EntitySet<ProjectPermission> _ProjectPermissions;
5636   
5637    private EntityRef<Project> _Project1;
5638   
5639    #region Extensibility Method Definitions
5640    partial void OnLoaded();
5641    partial void OnValidate(System.Data.Linq.ChangeAction action);
5642    partial void OnCreated();
5643    partial void OnProjectIdChanging(System.Guid value);
5644    partial void OnProjectIdChanged();
5645    partial void OnParentProjectIdChanging(System.Nullable<System.Guid> value);
5646    partial void OnParentProjectIdChanged();
5647    partial void OnDateCreatedChanging(System.DateTime value);
5648    partial void OnDateCreatedChanged();
5649    partial void OnNameChanging(string value);
5650    partial void OnNameChanged();
5651    partial void OnDescriptionChanging(string value);
5652    partial void OnDescriptionChanged();
5653    partial void OnOwnerUserIdChanging(System.Guid value);
5654    partial void OnOwnerUserIdChanged();
5655    partial void OnStartDateChanging(System.DateTime value);
5656    partial void OnStartDateChanged();
5657    partial void OnEndDateChanging(System.Nullable<System.DateTime> value);
5658    partial void OnEndDateChanged();
5659    #endregion
5660   
5661    public Project()
5662    {
5663      this._AssignedResources = new EntitySet<AssignedProjectResource>(new Action<AssignedProjectResource>(this.attach_AssignedResources), new Action<AssignedProjectResource>(this.detach_AssignedResources));
5664      this._Jobs = new EntitySet<Job>(new Action<Job>(this.attach_Jobs), new Action<Job>(this.detach_Jobs));
5665      this._Projects = new EntitySet<Project>(new Action<Project>(this.attach_Projects), new Action<Project>(this.detach_Projects));
5666      this._ProjectPermissions = new EntitySet<ProjectPermission>(new Action<ProjectPermission>(this.attach_ProjectPermissions), new Action<ProjectPermission>(this.detach_ProjectPermissions));
5667      this._Project1 = default(EntityRef<Project>);
5668      OnCreated();
5669    }
5670   
5671    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ProjectId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
5672    public System.Guid ProjectId
5673    {
5674      get
5675      {
5676        return this._ProjectId;
5677      }
5678      set
5679      {
5680        if ((this._ProjectId != value))
5681        {
5682          this.OnProjectIdChanging(value);
5683          this.SendPropertyChanging();
5684          this._ProjectId = value;
5685          this.SendPropertyChanged("ProjectId");
5686          this.OnProjectIdChanged();
5687        }
5688      }
5689    }
5690   
5691    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ParentProjectId", DbType="UniqueIdentifier")]
5692    public System.Nullable<System.Guid> ParentProjectId
5693    {
5694      get
5695      {
5696        return this._ParentProjectId;
5697      }
5698      set
5699      {
5700        if ((this._ParentProjectId != value))
5701        {
5702          if (this._Project1.HasLoadedOrAssignedValue)
5703          {
5704            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
5705          }
5706          this.OnParentProjectIdChanging(value);
5707          this.SendPropertyChanging();
5708          this._ParentProjectId = value;
5709          this.SendPropertyChanged("ParentProjectId");
5710          this.OnParentProjectIdChanged();
5711        }
5712      }
5713    }
5714   
5715    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateCreated", DbType="DateTime NOT NULL")]
5716    public System.DateTime DateCreated
5717    {
5718      get
5719      {
5720        return this._DateCreated;
5721      }
5722      set
5723      {
5724        if ((this._DateCreated != value))
5725        {
5726          this.OnDateCreatedChanging(value);
5727          this.SendPropertyChanging();
5728          this._DateCreated = value;
5729          this.SendPropertyChanged("DateCreated");
5730          this.OnDateCreatedChanged();
5731        }
5732      }
5733    }
5734   
5735    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
5736    public string Name
5737    {
5738      get
5739      {
5740        return this._Name;
5741      }
5742      set
5743      {
5744        if ((this._Name != value))
5745        {
5746          this.OnNameChanging(value);
5747          this.SendPropertyChanging();
5748          this._Name = value;
5749          this.SendPropertyChanged("Name");
5750          this.OnNameChanged();
5751        }
5752      }
5753    }
5754   
5755    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Description", DbType="VarChar(MAX)")]
5756    public string Description
5757    {
5758      get
5759      {
5760        return this._Description;
5761      }
5762      set
5763      {
5764        if ((this._Description != value))
5765        {
5766          this.OnDescriptionChanging(value);
5767          this.SendPropertyChanging();
5768          this._Description = value;
5769          this.SendPropertyChanged("Description");
5770          this.OnDescriptionChanged();
5771        }
5772      }
5773    }
5774   
5775    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_OwnerUserId", DbType="UniqueIdentifier NOT NULL")]
5776    public System.Guid OwnerUserId
5777    {
5778      get
5779      {
5780        return this._OwnerUserId;
5781      }
5782      set
5783      {
5784        if ((this._OwnerUserId != value))
5785        {
5786          this.OnOwnerUserIdChanging(value);
5787          this.SendPropertyChanging();
5788          this._OwnerUserId = value;
5789          this.SendPropertyChanged("OwnerUserId");
5790          this.OnOwnerUserIdChanged();
5791        }
5792      }
5793    }
5794   
5795    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StartDate", DbType="DateTime NOT NULL")]
5796    public System.DateTime StartDate
5797    {
5798      get
5799      {
5800        return this._StartDate;
5801      }
5802      set
5803      {
5804        if ((this._StartDate != value))
5805        {
5806          this.OnStartDateChanging(value);
5807          this.SendPropertyChanging();
5808          this._StartDate = value;
5809          this.SendPropertyChanged("StartDate");
5810          this.OnStartDateChanged();
5811        }
5812      }
5813    }
5814   
5815    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_EndDate", DbType="DateTime")]
5816    public System.Nullable<System.DateTime> EndDate
5817    {
5818      get
5819      {
5820        return this._EndDate;
5821      }
5822      set
5823      {
5824        if ((this._EndDate != value))
5825        {
5826          this.OnEndDateChanging(value);
5827          this.SendPropertyChanging();
5828          this._EndDate = value;
5829          this.SendPropertyChanged("EndDate");
5830          this.OnEndDateChanged();
5831        }
5832      }
5833    }
5834   
5835    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Project_AssignedProjectResource", Storage="_AssignedResources", ThisKey="ProjectId", OtherKey="ProjectId", DeleteRule="CASCADE")]
5836    public EntitySet<AssignedProjectResource> AssignedProjectResources
5837    {
5838      get
5839      {
5840        return this._AssignedResources;
5841      }
5842      set
5843      {
5844        this._AssignedResources.Assign(value);
5845      }
5846    }
5847   
5848    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Project_Job", Storage="_Jobs", ThisKey="ProjectId", OtherKey="ProjectId")]
5849    public EntitySet<Job> Jobs
5850    {
5851      get
5852      {
5853        return this._Jobs;
5854      }
5855      set
5856      {
5857        this._Jobs.Assign(value);
5858      }
5859    }
5860   
5861    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Project_Project", Storage="_Projects", ThisKey="ProjectId", OtherKey="ParentProjectId")]
5862    public EntitySet<Project> ChildProjects
5863    {
5864      get
5865      {
5866        return this._Projects;
5867      }
5868      set
5869      {
5870        this._Projects.Assign(value);
5871      }
5872    }
5873   
5874    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Project_ProjectPermission", Storage="_ProjectPermissions", ThisKey="ProjectId", OtherKey="ProjectId", DeleteRule="CASCADE")]
5875    public EntitySet<ProjectPermission> ProjectPermissions
5876    {
5877      get
5878      {
5879        return this._ProjectPermissions;
5880      }
5881      set
5882      {
5883        this._ProjectPermissions.Assign(value);
5884      }
5885    }
5886   
5887    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Project_Project", Storage="_Project1", ThisKey="ParentProjectId", OtherKey="ProjectId", IsForeignKey=true)]
5888    public Project ParentProject
5889    {
5890      get
5891      {
5892        return this._Project1.Entity;
5893      }
5894      set
5895      {
5896        Project previousValue = this._Project1.Entity;
5897        if (((previousValue != value)
5898              || (this._Project1.HasLoadedOrAssignedValue == false)))
5899        {
5900          this.SendPropertyChanging();
5901          if ((previousValue != null))
5902          {
5903            this._Project1.Entity = null;
5904            previousValue.ChildProjects.Remove(this);
5905          }
5906          this._Project1.Entity = value;
5907          if ((value != null))
5908          {
5909            value.ChildProjects.Add(this);
5910            this._ParentProjectId = value.ProjectId;
5911          }
5912          else
5913          {
5914            this._ParentProjectId = default(Nullable<System.Guid>);
5915          }
5916          this.SendPropertyChanged("ParentProject");
5917        }
5918      }
5919    }
5920   
5921    public event PropertyChangingEventHandler PropertyChanging;
5922   
5923    public event PropertyChangedEventHandler PropertyChanged;
5924   
5925    protected virtual void SendPropertyChanging()
5926    {
5927      if ((this.PropertyChanging != null))
5928      {
5929        this.PropertyChanging(this, emptyChangingEventArgs);
5930      }
5931    }
5932   
5933    protected virtual void SendPropertyChanged(String propertyName)
5934    {
5935      if ((this.PropertyChanged != null))
5936      {
5937        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
5938      }
5939    }
5940   
5941    private void attach_AssignedResources(AssignedProjectResource entity)
5942    {
5943      this.SendPropertyChanging();
5944      entity.Project = this;
5945    }
5946   
5947    private void detach_AssignedResources(AssignedProjectResource entity)
5948    {
5949      this.SendPropertyChanging();
5950      entity.Project = null;
5951    }
5952   
5953    private void attach_Jobs(Job entity)
5954    {
5955      this.SendPropertyChanging();
5956      entity.Project = this;
5957    }
5958   
5959    private void detach_Jobs(Job entity)
5960    {
5961      this.SendPropertyChanging();
5962      entity.Project = null;
5963    }
5964   
5965    private void attach_Projects(Project entity)
5966    {
5967      this.SendPropertyChanging();
5968      entity.ParentProject = this;
5969    }
5970   
5971    private void detach_Projects(Project entity)
5972    {
5973      this.SendPropertyChanging();
5974      entity.ParentProject = null;
5975    }
5976   
5977    private void attach_ProjectPermissions(ProjectPermission entity)
5978    {
5979      this.SendPropertyChanging();
5980      entity.Project = this;
5981    }
5982   
5983    private void detach_ProjectPermissions(ProjectPermission entity)
5984    {
5985      this.SendPropertyChanging();
5986      entity.Project = null;
5987    }
5988  }
5989 
5990  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.ProjectPermission")]
5991  public partial class ProjectPermission : INotifyPropertyChanging, INotifyPropertyChanged
5992  {
5993   
5994    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
5995   
5996    private System.Guid _ProjectId;
5997   
5998    private System.Guid _GrantedUserId;
5999   
6000    private System.Guid _GrantedByUserId;
6001   
6002    private EntityRef<Project> _Project;
6003   
6004    #region Extensibility Method Definitions
6005    partial void OnLoaded();
6006    partial void OnValidate(System.Data.Linq.ChangeAction action);
6007    partial void OnCreated();
6008    partial void OnProjectIdChanging(System.Guid value);
6009    partial void OnProjectIdChanged();
6010    partial void OnGrantedUserIdChanging(System.Guid value);
6011    partial void OnGrantedUserIdChanged();
6012    partial void OnGrantedByUserIdChanging(System.Guid value);
6013    partial void OnGrantedByUserIdChanged();
6014    #endregion
6015   
6016    public ProjectPermission()
6017    {
6018      this._Project = default(EntityRef<Project>);
6019      OnCreated();
6020    }
6021   
6022    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ProjectId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
6023    public System.Guid ProjectId
6024    {
6025      get
6026      {
6027        return this._ProjectId;
6028      }
6029      set
6030      {
6031        if ((this._ProjectId != value))
6032        {
6033          if (this._Project.HasLoadedOrAssignedValue)
6034          {
6035            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
6036          }
6037          this.OnProjectIdChanging(value);
6038          this.SendPropertyChanging();
6039          this._ProjectId = value;
6040          this.SendPropertyChanged("ProjectId");
6041          this.OnProjectIdChanged();
6042        }
6043      }
6044    }
6045   
6046    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GrantedUserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
6047    public System.Guid GrantedUserId
6048    {
6049      get
6050      {
6051        return this._GrantedUserId;
6052      }
6053      set
6054      {
6055        if ((this._GrantedUserId != value))
6056        {
6057          this.OnGrantedUserIdChanging(value);
6058          this.SendPropertyChanging();
6059          this._GrantedUserId = value;
6060          this.SendPropertyChanged("GrantedUserId");
6061          this.OnGrantedUserIdChanged();
6062        }
6063      }
6064    }
6065   
6066    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GrantedByUserId", DbType="UniqueIdentifier NOT NULL")]
6067    public System.Guid GrantedByUserId
6068    {
6069      get
6070      {
6071        return this._GrantedByUserId;
6072      }
6073      set
6074      {
6075        if ((this._GrantedByUserId != value))
6076        {
6077          this.OnGrantedByUserIdChanging(value);
6078          this.SendPropertyChanging();
6079          this._GrantedByUserId = value;
6080          this.SendPropertyChanged("GrantedByUserId");
6081          this.OnGrantedByUserIdChanged();
6082        }
6083      }
6084    }
6085   
6086    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Project_ProjectPermission", Storage="_Project", ThisKey="ProjectId", OtherKey="ProjectId", IsForeignKey=true, DeleteRule="CASCADE", DeleteOnNull=true)]
6087    public Project Project
6088    {
6089      get
6090      {
6091        return this._Project.Entity;
6092      }
6093      set
6094      {
6095        Project previousValue = this._Project.Entity;
6096        if (((previousValue != value)
6097              || (this._Project.HasLoadedOrAssignedValue == false)))
6098        {
6099          this.SendPropertyChanging();
6100          if ((previousValue != null))
6101          {
6102            this._Project.Entity = null;
6103            previousValue.ProjectPermissions.Remove(this);
6104          }
6105          this._Project.Entity = value;
6106          if ((value != null))
6107          {
6108            value.ProjectPermissions.Add(this);
6109            this._ProjectId = value.ProjectId;
6110          }
6111          else
6112          {
6113            this._ProjectId = default(System.Guid);
6114          }
6115          this.SendPropertyChanged("Project");
6116        }
6117      }
6118    }
6119   
6120    public event PropertyChangingEventHandler PropertyChanging;
6121   
6122    public event PropertyChangedEventHandler PropertyChanged;
6123   
6124    protected virtual void SendPropertyChanging()
6125    {
6126      if ((this.PropertyChanging != null))
6127      {
6128        this.PropertyChanging(this, emptyChangingEventArgs);
6129      }
6130    }
6131   
6132    protected virtual void SendPropertyChanged(String propertyName)
6133    {
6134      if ((this.PropertyChanged != null))
6135      {
6136        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
6137      }
6138    }
6139  }
6140 
6141  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.AssignedTaskResource")]
6142  public partial class AssignedTaskResource : INotifyPropertyChanging, INotifyPropertyChanged
6143  {
6144   
6145    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
6146   
6147    private System.Guid _ResourceId;
6148   
6149    private System.Guid _TaskId;
6150   
6151    private EntityRef<Task> _Task;
6152   
6153    private EntityRef<Resource> _Resource;
6154   
6155    #region Extensibility Method Definitions
6156    partial void OnLoaded();
6157    partial void OnValidate(System.Data.Linq.ChangeAction action);
6158    partial void OnCreated();
6159    partial void OnResourceIdChanging(System.Guid value);
6160    partial void OnResourceIdChanged();
6161    partial void OnTaskIdChanging(System.Guid value);
6162    partial void OnTaskIdChanged();
6163    #endregion
6164   
6165    public AssignedTaskResource()
6166    {
6167      this._Task = default(EntityRef<Task>);
6168      this._Resource = default(EntityRef<Resource>);
6169      OnCreated();
6170    }
6171   
6172    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
6173    public System.Guid ResourceId
6174    {
6175      get
6176      {
6177        return this._ResourceId;
6178      }
6179      set
6180      {
6181        if ((this._ResourceId != value))
6182        {
6183          if (this._Resource.HasLoadedOrAssignedValue)
6184          {
6185            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
6186          }
6187          this.OnResourceIdChanging(value);
6188          this.SendPropertyChanging();
6189          this._ResourceId = value;
6190          this.SendPropertyChanged("ResourceId");
6191          this.OnResourceIdChanged();
6192        }
6193      }
6194    }
6195   
6196    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TaskId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
6197    public System.Guid TaskId
6198    {
6199      get
6200      {
6201        return this._TaskId;
6202      }
6203      set
6204      {
6205        if ((this._TaskId != value))
6206        {
6207          if (this._Task.HasLoadedOrAssignedValue)
6208          {
6209            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
6210          }
6211          this.OnTaskIdChanging(value);
6212          this.SendPropertyChanging();
6213          this._TaskId = value;
6214          this.SendPropertyChanged("TaskId");
6215          this.OnTaskIdChanged();
6216        }
6217      }
6218    }
6219   
6220    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_AssignedTaskResource", Storage="_Task", ThisKey="TaskId", OtherKey="TaskId", IsForeignKey=true)]
6221    public Task Task
6222    {
6223      get
6224      {
6225        return this._Task.Entity;
6226      }
6227      set
6228      {
6229        Task previousValue = this._Task.Entity;
6230        if (((previousValue != value)
6231              || (this._Task.HasLoadedOrAssignedValue == false)))
6232        {
6233          this.SendPropertyChanging();
6234          if ((previousValue != null))
6235          {
6236            this._Task.Entity = null;
6237            previousValue.AssignedTaskResources.Remove(this);
6238          }
6239          this._Task.Entity = value;
6240          if ((value != null))
6241          {
6242            value.AssignedTaskResources.Add(this);
6243            this._TaskId = value.TaskId;
6244          }
6245          else
6246          {
6247            this._TaskId = default(System.Guid);
6248          }
6249          this.SendPropertyChanged("Task");
6250        }
6251      }
6252    }
6253   
6254    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_AssignedTaskResource", Storage="_Resource", ThisKey="ResourceId", OtherKey="ResourceId", IsForeignKey=true)]
6255    public Resource Resource
6256    {
6257      get
6258      {
6259        return this._Resource.Entity;
6260      }
6261      set
6262      {
6263        Resource previousValue = this._Resource.Entity;
6264        if (((previousValue != value)
6265              || (this._Resource.HasLoadedOrAssignedValue == false)))
6266        {
6267          this.SendPropertyChanging();
6268          if ((previousValue != null))
6269          {
6270            this._Resource.Entity = null;
6271            previousValue.AssignedTaskResources.Remove(this);
6272          }
6273          this._Resource.Entity = value;
6274          if ((value != null))
6275          {
6276            value.AssignedTaskResources.Add(this);
6277            this._ResourceId = value.ResourceId;
6278          }
6279          else
6280          {
6281            this._ResourceId = default(System.Guid);
6282          }
6283          this.SendPropertyChanged("Resource");
6284        }
6285      }
6286    }
6287   
6288    public event PropertyChangingEventHandler PropertyChanging;
6289   
6290    public event PropertyChangedEventHandler PropertyChanged;
6291   
6292    protected virtual void SendPropertyChanging()
6293    {
6294      if ((this.PropertyChanging != null))
6295      {
6296        this.PropertyChanging(this, emptyChangingEventArgs);
6297      }
6298    }
6299   
6300    protected virtual void SendPropertyChanged(String propertyName)
6301    {
6302      if ((this.PropertyChanged != null))
6303      {
6304        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
6305      }
6306    }
6307  }
6308 
6309  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.AssignedJobResource")]
6310  public partial class AssignedJobResource : INotifyPropertyChanging, INotifyPropertyChanged
6311  {
6312   
6313    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
6314   
6315    private System.Guid _ResourceId;
6316   
6317    private System.Guid _JobId;
6318   
6319    private EntityRef<Resource> _Resource;
6320   
6321    private EntityRef<Job> _Job;
6322   
6323    #region Extensibility Method Definitions
6324    partial void OnLoaded();
6325    partial void OnValidate(System.Data.Linq.ChangeAction action);
6326    partial void OnCreated();
6327    partial void OnResourceIdChanging(System.Guid value);
6328    partial void OnResourceIdChanged();
6329    partial void OnJobIdChanging(System.Guid value);
6330    partial void OnJobIdChanged();
6331    #endregion
6332   
6333    public AssignedJobResource()
6334    {
6335      this._Resource = default(EntityRef<Resource>);
6336      this._Job = default(EntityRef<Job>);
6337      OnCreated();
6338    }
6339   
6340    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
6341    public System.Guid ResourceId
6342    {
6343      get
6344      {
6345        return this._ResourceId;
6346      }
6347      set
6348      {
6349        if ((this._ResourceId != value))
6350        {
6351          if (this._Resource.HasLoadedOrAssignedValue)
6352          {
6353            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
6354          }
6355          this.OnResourceIdChanging(value);
6356          this.SendPropertyChanging();
6357          this._ResourceId = value;
6358          this.SendPropertyChanged("ResourceId");
6359          this.OnResourceIdChanged();
6360        }
6361      }
6362    }
6363   
6364    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
6365    public System.Guid JobId
6366    {
6367      get
6368      {
6369        return this._JobId;
6370      }
6371      set
6372      {
6373        if ((this._JobId != value))
6374        {
6375          if (this._Job.HasLoadedOrAssignedValue)
6376          {
6377            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
6378          }
6379          this.OnJobIdChanging(value);
6380          this.SendPropertyChanging();
6381          this._JobId = value;
6382          this.SendPropertyChanged("JobId");
6383          this.OnJobIdChanged();
6384        }
6385      }
6386    }
6387   
6388    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_AssignedJobResource", Storage="_Resource", ThisKey="ResourceId", OtherKey="ResourceId", IsForeignKey=true, DeleteRule="CASCADE", DeleteOnNull=true)]
6389    public Resource Resource
6390    {
6391      get
6392      {
6393        return this._Resource.Entity;
6394      }
6395      set
6396      {
6397        Resource previousValue = this._Resource.Entity;
6398        if (((previousValue != value)
6399              || (this._Resource.HasLoadedOrAssignedValue == false)))
6400        {
6401          this.SendPropertyChanging();
6402          if ((previousValue != null))
6403          {
6404            this._Resource.Entity = null;
6405            previousValue.AssignedJobResources.Remove(this);
6406          }
6407          this._Resource.Entity = value;
6408          if ((value != null))
6409          {
6410            value.AssignedJobResources.Add(this);
6411            this._ResourceId = value.ResourceId;
6412          }
6413          else
6414          {
6415            this._ResourceId = default(System.Guid);
6416          }
6417          this.SendPropertyChanged("Resource");
6418        }
6419      }
6420    }
6421   
6422    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_AssignedJobResource", Storage="_Job", ThisKey="JobId", OtherKey="JobId", IsForeignKey=true, DeleteRule="CASCADE", DeleteOnNull=true)]
6423    public Job Job
6424    {
6425      get
6426      {
6427        return this._Job.Entity;
6428      }
6429      set
6430      {
6431        Job previousValue = this._Job.Entity;
6432        if (((previousValue != value)
6433              || (this._Job.HasLoadedOrAssignedValue == false)))
6434        {
6435          this.SendPropertyChanging();
6436          if ((previousValue != null))
6437          {
6438            this._Job.Entity = null;
6439            previousValue.AssignedJobResources.Remove(this);
6440          }
6441          this._Job.Entity = value;
6442          if ((value != null))
6443          {
6444            value.AssignedJobResources.Add(this);
6445            this._JobId = value.JobId;
6446          }
6447          else
6448          {
6449            this._JobId = default(System.Guid);
6450          }
6451          this.SendPropertyChanged("Job");
6452        }
6453      }
6454    }
6455   
6456    public event PropertyChangingEventHandler PropertyChanging;
6457   
6458    public event PropertyChangedEventHandler PropertyChanged;
6459   
6460    protected virtual void SendPropertyChanging()
6461    {
6462      if ((this.PropertyChanging != null))
6463      {
6464        this.PropertyChanging(this, emptyChangingEventArgs);
6465      }
6466    }
6467   
6468    protected virtual void SendPropertyChanged(String propertyName)
6469    {
6470      if ((this.PropertyChanged != null))
6471      {
6472        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
6473      }
6474    }
6475  }
6476}
6477#pragma warning restore 1591
Note: See TracBrowser for help on using the repository browser.