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

Last change on this file since 15523 was 15523, checked in by jzenisek, 4 years ago

#2839 worked on db model and updated dbml

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