public void CannotStartPartBeforeSplitTaskPrecedentStart()
{
IProjectManager <Task, object> manager = new ProjectManager <Task, object>();
var split = new Task();
var part1 = new Task();
var part2 = new Task();
var precedent = new Task();
manager.Add(split);
manager.Add(precedent);
// setup: create a split task with precendent
manager.SetStart(precedent, 5);
manager.SetDuration(precedent, 5);
manager.SetStart(split, 15);
manager.SetDuration(split, 5);
manager.Relate(precedent, split);
manager.Split(split, part1, part2, 2);
Assert.IsTrue(manager.PrecedentsOf(split).Contains(precedent));
Assert.IsTrue(manager.PartsOf(split).Contains(part1));
Assert.IsTrue(manager.PartsOf(split).Contains(part2));
Assert.IsTrue(precedent.End == 10);
Assert.IsTrue(split.Start == 15);
Assert.IsTrue(part1.Start == 15);
// test: move part1 start before precendent start
manager.SetStart(part1, 8);
Assert.IsTrue(manager.PrecedentsOf(split).Contains(precedent));
Assert.IsTrue(manager.PartsOf(split).Contains(part1));
Assert.IsTrue(manager.PartsOf(split).Contains(part2));
Assert.IsTrue(part1.Start == 11);
Assert.IsTrue(split.Start == 11);
}
public void AdjustGroupDurationOnUngroup()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var split = new Task();
var part1 = new Task();
var part2 = new Task();
var group = new Task();
var task = new Task();
manager.Add(group);
manager.Add(split);
manager.Add(task);
// setup: create a group and split under it
manager.Split(split, part1, part2, 1);
manager.Group(group, part1); // intentionall group using part
manager.Group(group, task);
manager.SetDuration(part1, 30);
manager.SetDuration(part2, 15);
manager.SetDuration(task, 20);
manager.SetStart(task, 50);
Assert.IsTrue(group.Duration == 70);
// test: ungroup part should ungroup split task
manager.Ungroup(group, part1);
Assert.IsTrue(group.Duration == 20);
}
public void AdjustDependantScheduleOnRelate()
{
IProjectManager <Task, object> manager = new ProjectManager <Task, object>();
var one = new Task()
{
Name = "one"
};
var two = new Task()
{
Name = "two"
};
manager.Add(one);
manager.Add(two);
// setup: make 2 independant tasks
manager.SetStart(one, 10);
manager.SetDuration(one, 6);
manager.SetStart(two, 10);
manager.SetDuration(two, 10);
Assert.IsTrue(one.Start == 10);
Assert.IsTrue(one.End == 16);
Assert.IsTrue(two.Start == 10);
Assert.IsTrue(two.End == 20);
// test: relate one and two; one before two
manager.Relate(one, two);
Assert.IsTrue(one.Start == 10);
Assert.IsTrue(one.End == 16);
Assert.IsTrue(two.Start == 17);
Assert.IsTrue(two.End == 27);
}
public Form1()
{
InitializeComponent();
// create a project manager
var manager = new ProjectManager();
// create built-in task or use your own derived task
var task = new Braincase.GanttChart.Task() { Name = "Hello "};
var task1 = new Braincase.GanttChart.Task() { Name = " World" };
var task2 = new Braincase.GanttChart.Task() { Name = "Helly" };
var task3 = new Braincase.GanttChart.Task() { Name = "Hel7875" };
var task5 = new Braincase.GanttChart.Task() { Name = "gmmail" };
// add the task to the manager
manager.Add(task2);
manager.Add(task);
manager.Add(task1);
manager.Add(task3);
manager.Split(task2,task1,2);
//manager.SetDuration(task, 3);
// create a chart control
var chart = new Chart();
// initialise the chart with the manager
chart.Init(manager);
// add chart to the form controls collection.
this.Controls.Add(chart);
// throughout your own code, call chart.Invalidate()
// where you expect updates to the drawn chart,
// to tell the chart to Paint() itself.
}
public void MovePartLaterThanDependantStart()
{
IProjectManager <Task, object> manager = new ProjectManager <Task, object>();
var split = new Task();
var part1 = new Task();
var part2 = new Task();
var dependant = new Task();
manager.Add(split);
manager.Add(dependant);
// setup: create a dependant on the split task
manager.SetDuration(split, 20);
manager.SetDuration(dependant, 7);
manager.Split(split, part1, part2, 15);
manager.Relate(split, dependant);
Assert.IsTrue(dependant.Start == 22);
Assert.IsTrue(part2.End == 21);
Assert.IsTrue(split.End == 21);
// test: adjust part2 duration beyond dependant start
manager.SetEnd(part2, 25);
Assert.IsTrue(dependant.Start == 26);
Assert.IsTrue(part2.End == 25);
Assert.IsTrue(split.End == 25);
// test: adjust part2 start such that end beyond dependant start
manager.SetStart(part2, 30);
Assert.IsTrue(dependant.Start == 40);
Assert.IsTrue(part2.End == 39);
Assert.IsTrue(split.End == 39);
}
public void AdjustDependantScheduleOnRelate()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var one = new Task() { Name = "one" };
var two = new Task() { Name = "two" };
manager.Add(one);
manager.Add(two);
// setup: make 2 independant tasks
manager.SetStart(one, 10);
manager.SetDuration(one, 6);
manager.SetStart(two, 10);
manager.SetDuration(two, 10);
Assert.IsTrue(one.Start == 10);
Assert.IsTrue(one.End == 16);
Assert.IsTrue(two.Start == 10);
Assert.IsTrue(two.End == 20);
// test: relate one and two; one before two
manager.Relate(one, two);
Assert.IsTrue(one.Start == 10);
Assert.IsTrue(one.End == 16);
Assert.IsTrue(two.Start == 17);
Assert.IsTrue(two.End == 27);
}
public void AdjustGroupDuringJoin()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var group = new Task();
var split = new Task();
var part1 = new Task();
var part2 = new Task();
var part3 = new Task();
manager.Add(split);
manager.Add(group);
// setup: create a split under a group
manager.Group(group, split);
manager.Split(split, part1, part2, 1);
manager.Split(part2, part3, 1);
Assert.IsTrue(group.Duration == 5);
Assert.IsTrue(group.Duration == split.Duration);
Assert.IsTrue(group.End == part3.End);
// test: join and make sure group duration is shortened
manager.Join(part1, part3);
Assert.IsTrue(!manager.IsPart(part3));
Assert.IsTrue(group.Duration == 4);
Assert.IsTrue(group.Duration == split.Duration);
Assert.IsTrue(group.End == part2.End);
}
public void DeleteResourceOnDeleteTask()
{
IProjectManager <Task, object> manager = new ProjectManager <Task, object>();
var task1 = new Task();
var task2 = new Task();
var r1 = new Task();
manager.Add(task1);
manager.Add(task2);
// setup: assign resource
manager.Assign(task1, r1);
manager.Assign(task2, r1);
Assert.IsTrue(manager.ResourcesOf(task1).Contains(r1));
Assert.IsTrue(manager.ResourcesOf(task2).Contains(r1));
Assert.IsTrue(manager.TasksOf(r1).Count() == 2);
// test: delete task1
manager.Delete(task1);
Assert.IsTrue(!manager.ResourcesOf(task1).Contains(r1));
Assert.IsTrue(manager.ResourcesOf(task2).Contains(r1));
Assert.IsTrue(manager.TasksOf(r1).Count() == 1);
Assert.IsTrue(manager.Resources.Count() == 1);
Assert.IsTrue(manager.Resources.Contains(r1));
// test: delete task2
manager.Delete(task2);
Assert.IsTrue(!manager.ResourcesOf(task1).Contains(r1));
Assert.IsTrue(!manager.ResourcesOf(task2).Contains(r1));
Assert.IsTrue(manager.TasksOf(r1).Count() == 0);
Assert.IsTrue(manager.Resources.Count() == 0);
Assert.IsTrue(!manager.Resources.Contains(r1));
}
public void AdjustGroupScheduleOnGroup()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var group = new Task();
var one = new Task();
manager.Add(group);
manager.Add(one);
// setup: set initial task parameters
manager.SetStart(group, 6);
manager.SetDuration(group, 5);
manager.SetStart(one, 9);
manager.SetEnd(one, 15);
Assert.IsTrue(group.Start == 6);
Assert.IsTrue(group.End == 11);
Assert.IsTrue(one.Start == 9);
Assert.IsTrue(one.Duration == 6);
// test: make a group and group make have same parameters as one
manager.Group(group, one);
Assert.IsTrue(group.Start == one.Start);
Assert.IsTrue(group.End == one.End);
Assert.IsTrue(group.Duration == one.Duration);
Assert.IsTrue(group.Complete == one.Complete);
}
public void DrawPeople(IEnumerable <string> names, RallyData data)
{
_data = data;
Boxes.Clear();
foreach (string name in names)
{
var task = new Braincase.GanttChart.Task {
ID = name, Name = name
};
Boxes.Add(name, task);
_manager.Add(task);
DrawNewLine();
}
List <Story> orderedStories = data.Stories.Values.OrderBy(o => o.StartDate).ToList();
foreach (Story story in orderedStories)
{
var storyTask = new Braincase.GanttChart.Task();
storyTask.ID = story.FormattedID;
storyTask.Name = GetStoryName(story);
Boxes.Add(story.FormattedID, storyTask);
_manager.Add(storyTask);
_manager.Group(Boxes[story.Owner], storyTask);
DrawStory(story, storyTask);
}
DrawIterations(data.Iterations.Values);
_chart.Invalidate();
}
public void RelateBeforePrecedentEndsLate()
{
IProjectManager <Task, object> manager = new ProjectManager <Task, object>();
var one = new Task()
{
Name = "one"
};
var two = new Task()
{
Name = "two"
};
manager.Add(one);
manager.Add(two);
// setup: set task parameters and set relation
manager.Relate(one, two);
manager.SetStart(one, 10);
manager.SetDuration(one, 5);
manager.SetStart(two, 18);
manager.SetDuration(two, 12);
Assert.IsTrue(one.Start == 10);
Assert.IsTrue(one.End == 15);
Assert.IsTrue(one.Slack == 2, string.Format("Expected {0} != {1}", 2, one.Slack));
Assert.IsTrue(two.Start == 18);
Assert.IsTrue(two.End == 30);
Assert.IsTrue(two.Slack == 0);
}
public void DependantRescheduledStartEarlierThanPrecedentEnd()
{
IProjectManager <Task, object> manager = new ProjectManager <Task, object>();
var one = new Task();
var two = new Task();
manager.Add(one);
manager.Add(two);
// setup: one before two
manager.Relate(one, two);
manager.SetStart(one, 5);
manager.SetEnd(one, 10);
manager.SetStart(two, 15);
manager.SetDuration(two, 25);
Assert.IsTrue(one.Start == 5);
Assert.IsTrue(one.Duration == 5);
Assert.IsTrue(two.Start == 15);
Assert.IsTrue(two.End == 40);
// test: reschedule two to start before end of one
manager.SetStart(two, 8);
Assert.IsTrue(one.Start == 5);
Assert.IsTrue(one.Duration == 5);
Assert.IsTrue(two.Start == 11);
Assert.IsTrue(two.Duration == 25);
Assert.IsTrue(two.End == 36);
}
public void AdjustGroupScheduleOnGroup()
{
IProjectManager <Task, object> manager = new ProjectManager <Task, object>();
var group = new Task();
var one = new Task();
manager.Add(group);
manager.Add(one);
// setup: set initial task parameters
manager.SetStart(group, 6);
manager.SetDuration(group, 5);
manager.SetStart(one, 9);
manager.SetEnd(one, 15);
Assert.IsTrue(group.Start == 6);
Assert.IsTrue(group.End == 11);
Assert.IsTrue(one.Start == 9);
Assert.IsTrue(one.Duration == 6);
// test: make a group and group make have same parameters as one
manager.Group(group, one);
Assert.IsTrue(group.Start == one.Start);
Assert.IsTrue(group.End == one.End);
Assert.IsTrue(group.Duration == one.Duration);
Assert.IsTrue(group.Complete == one.Complete);
}
public void AdjustGroupCompleteOnMemberCompleteChange()
{
IProjectManager <Task, object> manager = new ProjectManager <Task, object>();
var group = new Task()
{
Name = "group"
};
var member = new Task()
{
Name = "member"
};
manager.Add(group);
manager.Add(member);
// setup: create a group
manager.Group(group, member);
Assert.IsTrue(member.Complete == 0);
Assert.IsTrue(group.Complete == 0, string.Format("Expected {0} != {1}", 0, group.Complete));
// test: set the complete on the member and
manager.SetComplete(member, 0.5f);
Assert.IsTrue(member.Complete == 0.5f);
Assert.IsTrue(group.Complete == 0.5f, string.Format("Expected {0} != {1}", 0.5f, group.Complete));
}
public void CannotSetCompleteOnGroup()
{
IProjectManager <Task, object> manager = new ProjectManager <Task, object>();
var group = new Task()
{
Name = "group"
};
var member = new Task()
{
Name = "member"
};
manager.Add(group);
manager.Add(member);
// setup: set an initial complete on group
manager.SetComplete(group, 0.345f);
Assert.IsTrue(group.Complete == 0.345f);
Assert.IsTrue(member.Complete == 0);
// test: make a group and reset its complete status
manager.Group(group, member);
Assert.IsTrue(manager.IsGroup(group));
Assert.IsTrue(group.Complete == 0);
Assert.IsTrue(member.Complete == 0);
// test: set complete on a group (no effect);
manager.SetComplete(group, 0.123f);
Assert.IsTrue(manager.IsGroup(group));
Assert.IsTrue(group.Complete == 0);
Assert.IsTrue(member.Complete == 0);
}
/// <summary>
/// This will perform the drop action and add the file to the projects if possible
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void LV_Projects_DragDrop(object sender, DragEventArgs e)
{
string[] files = (string[])e.Data.GetData(DataFormats.FileDrop, false);
foreach (string currentFile in files)
{
manager.Add(currentFile);
}
manager.Save();
LoadProjects();
}
public void SetPartCompleteUpdatesSplitTaskAndGroup()
{
IProjectManager <Task, object> manager = new ProjectManager <Task, object>();
var split = new Task()
{
Name = "split"
};
var part1 = new Task()
{
Name = "part1"
};
var part2 = new Task()
{
Name = "part2"
};
var group = new Task()
{
Name = "group"
};
var member = new Task()
{
Name = "member"
};
manager.Add(split);
manager.Add(member);
manager.Add(group);
// setup: create split task under a group
manager.SetDuration(split, 6);
manager.SetDuration(member, 14);
manager.Group(group, split);
manager.Group(group, member);
manager.Split(split, part1, part2, 2);
Assert.IsTrue(manager.IsGroup(group));
Assert.IsTrue(manager.IsMember(member));
Assert.IsTrue(manager.IsMember(split));
Assert.IsTrue(group.Complete == 0);
Assert.IsTrue(split.Complete == 0);
Assert.IsTrue(part1.Complete == 0);
Assert.IsTrue(part2.Complete == 0);
Assert.IsTrue(group.Duration == 14);
Assert.IsTrue(member.Duration == 14);
Assert.IsTrue(split.Duration == 7);
Assert.IsTrue(part1.Duration == 2);
Assert.IsTrue(part2.Duration == 4);
// test: set complete for part1 and see group and split complete increase
manager.SetComplete(part1, 0.3f);
Assert.IsTrue(Math.Abs(split.Complete - (0.3f * 2) / 6.0f) < 0.01f);
Assert.IsTrue(Math.Abs(group.Complete - (split.Complete * 7) / 20.0f) < 0.01f);
}
public Form1()
{
InitializeComponent();
// create a project manager
var manager = new ProjectManager();
// create built-in task or use your own derived task
var task = new Braincase.GanttChart.Task()
{
Name = "Hello "
};
var task1 = new Braincase.GanttChart.Task()
{
Name = " World"
};
var task2 = new Braincase.GanttChart.Task()
{
Name = "Helly"
};
var task3 = new Braincase.GanttChart.Task()
{
Name = "Hel7875"
};
var task5 = new Braincase.GanttChart.Task()
{
Name = "gmmail"
};
// add the task to the manager
manager.Add(task2);
manager.Add(task);
manager.Add(task1);
manager.Add(task3);
manager.Split(task2, task1, 2);
//manager.SetDuration(task, 3);
// create a chart control
var chart = new Chart();
// initialise the chart with the manager
chart.Init(manager);
// add chart to the form controls collection.
this.Controls.Add(chart);
// throughout your own code, call chart.Invalidate()
// where you expect updates to the drawn chart,
// to tell the chart to Paint() itself.
}
public void TransferResourceToSplitTaskOnMerge_ByDeleteInThisCase()
{
IProjectManager <Task, object> manager = new ProjectManager <Task, object>();
var split = new Task();
var part1 = new Task();
var part2 = new Task();
var r1 = new Task();
manager.Add(split);
// setup: create a split task with resources on parts
manager.Split(split, part1, part2, 1);
manager.Assign(part1, r1);
manager.Assign(part2, r1);
Assert.IsTrue(!manager.TasksOf(r1).Contains(split));
Assert.IsTrue(manager.TasksOf(r1).Contains(part1));
Assert.IsTrue(manager.TasksOf(r1).Contains(part2));
Assert.IsTrue(!manager.ResourcesOf(split).Contains(r1));
Assert.IsTrue(manager.ResourcesOf(part1).Contains(r1));
Assert.IsTrue(manager.ResourcesOf(part2).Contains(r1));
Assert.IsTrue(manager.Resources.Count() == 1);
// test: delete a part, expect a merge and resources transferred to split task
manager.Delete(part1);
Assert.IsTrue(manager.TasksOf(r1).Contains(split));
Assert.IsTrue(!manager.TasksOf(r1).Contains(part1));
Assert.IsTrue(!manager.TasksOf(r1).Contains(part2));
Assert.IsTrue(manager.ResourcesOf(split).Contains(r1));
Assert.IsTrue(!manager.ResourcesOf(part1).Contains(r1));
Assert.IsTrue(!manager.ResourcesOf(part2).Contains(r1));
Assert.IsTrue(manager.Resources.Count() == 1);
}
public void SetTaskParameters()
{
IProjectManager <Task, object> manager = new ProjectManager <Task, object>();
var one = new Task();
manager.Add(one);
// setup: set some initial values
manager.SetStart(one, 22);
manager.SetEnd(one, 24);
manager.SetComplete(one, 0.3f);
manager.SetCollapse(one, false);
Assert.IsTrue(one.Start == 22);
Assert.IsTrue(one.End == 24);
Assert.IsTrue(one.Complete == 0.3f);
Assert.IsTrue(one.IsCollapsed == false);
Assert.IsTrue(one.Slack == 0);
Assert.IsTrue(one.Duration == 2);
// test: change the values and check again
manager.SetStart(one, 34);
manager.SetDuration(one, 56);
manager.SetComplete(one, 0.9f);
manager.SetCollapse(one, true); // should have no effect unless on group
Assert.IsTrue(one.Start == 34);
Assert.IsTrue(one.End == 90);
Assert.IsTrue(one.Complete == 0.9f);
Assert.IsTrue(one.IsCollapsed == false);
Assert.IsTrue(one.Slack == 0);
Assert.IsTrue(one.Duration == 56);
}
public NewProject()
{
InitializeComponent();
ProjectManager projects = null;
Loaded += (o, e) => {
projects = (ProjectManager)FindResource("ProjectData");
project.DataContext = new Project();
};
create.Click += (o, e) => {
var p = project.DataContext as Project;
if (useTemplate.IsChecked.Value)
{
p.ApplyTemplate((Project)template.SelectedItem);
}
if (p != null && p.Error == null)
{
projects.Add(p);
}
else if (p != null)
{
MessageBox.Show(p.Error, "Fehler", MessageBoxButton.OK, MessageBoxImage.Error);
}
project.DataContext = new Project();
MainWindow.ActiveTask = 7;
};
}
public void AdjustGroupScheduleOnMemberScheduleChange()
{
IProjectManager <Task, object> manager = new ProjectManager <Task, object>();
var group = new Task()
{
Name = "group"
};
var one = new Task()
{
Name = "one"
};
var two = new Task()
{
Name = "two"
};
manager.Add(group);
manager.Add(one);
manager.Add(two);
// setup: create a group with 2 members and some initial schedule
manager.Group(group, one);
manager.Group(group, two);
manager.SetStart(one, 10);
manager.SetDuration(one, 6);
manager.SetStart(two, 12);
manager.SetEnd(two, 20);
Assert.IsTrue(one.Start == 10);
Assert.IsTrue(one.End == 16);
Assert.IsTrue(two.Start == 12);
Assert.IsTrue(two.Duration == 8);
Assert.IsTrue(group.Start == 10);
Assert.IsTrue(group.End == 20);
Assert.IsTrue(group.Duration == 10, string.Format("Expected {0} != {1}", 10, group.Duration));
// test: change the member schedule and confirm if the group schedule updates approperiately
manager.SetStart(one, 26);
Assert.IsTrue(group.Start == 12);
Assert.IsTrue(group.End == 32);
// test: change the member schedule back
manager.SetStart(one, 10);
Assert.IsTrue(group.Start == 10);
Assert.IsTrue(group.End == 20);
Assert.IsTrue(group.Duration == 10);
}
public ExampleSimple()
{
InitializeComponent();
_mProject = new ProjectManager();
_mProject.Add(new Task() { Name = "New Task" });
_mChart.Init(_mProject);
}
public void AdjustGroupCompleteOnMemberCompleteChange()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var group = new Task() { Name = "group" };
var member = new Task() { Name = "member" };
manager.Add(group);
manager.Add(member);
// setup: create a group
manager.Group(group, member);
Assert.IsTrue(member.Complete == 0);
Assert.IsTrue(group.Complete == 0, string.Format("Expected {0} != {1}", 0, group.Complete));
// test: set the complete on the member and
manager.SetComplete(member, 0.5f);
Assert.IsTrue(member.Complete == 0.5f);
Assert.IsTrue(group.Complete == 0.5f, string.Format("Expected {0} != {1}", 0.5f, group.Complete));
}
public void SetSplitTaskEndLastTaskMinimun1UnitTime()
{
IProjectManager <Task, object> manager = new ProjectManager <Task, object>();
var split = new Task();
var part1 = new Task();
var part2 = new Task();
var part3 = new Task();
manager.Add(split);
// setup: create a split task
manager.Split(split, part1, part2, 1);
manager.Split(part2, part3, 1);
manager.SetStart(part1, 0);
manager.SetStart(part2, 15);
manager.SetStart(part3, 30);
manager.SetDuration(part1, 3);
manager.SetDuration(part2, 4);
manager.SetDuration(part3, 5);
Assert.IsTrue(manager.IsSplit(split));
Assert.IsTrue(manager.IsPart(part1));
Assert.IsTrue(manager.IsPart(part2));
Assert.IsTrue(manager.IsPart(part3));
Assert.IsTrue(part1.Start == 0);
Assert.IsTrue(part2.Start == 15);
Assert.IsTrue(part3.Start == 30);
Assert.IsTrue(part1.Duration == 3);
Assert.IsTrue(part2.Duration == 4);
Assert.IsTrue(part3.Duration == 5);
Assert.IsTrue(part1.End == 3);
Assert.IsTrue(part2.End == 19);
Assert.IsTrue(part3.End == 35);
// test: set the split task end - last part end to increase or decrease,
// resulting no less than 1 unit duration
manager.SetEnd(split, 1);
Assert.IsTrue(manager.IsSplit(split));
Assert.IsTrue(manager.IsPart(part1));
Assert.IsTrue(manager.IsPart(part2));
Assert.IsTrue(manager.IsPart(part3));
Assert.IsTrue(part1.Start == 0);
Assert.IsTrue(part2.Start == 15);
Assert.IsTrue(part3.Start == 30);
Assert.IsTrue(part1.Duration == 3);
Assert.IsTrue(part2.Duration == 4);
Assert.IsTrue(part3.Duration == 1);
Assert.IsTrue(part1.End == 3);
Assert.IsTrue(part2.End == 19);
Assert.IsTrue(part3.End == 31);
// test: increase split task end and last part adjust accordingly
manager.SetEnd(split, 100);
Assert.IsTrue(part3.End == 100);
Assert.IsTrue(part3.Duration == 70);
Assert.IsTrue(part3.Start == 30);
}
static void Main(string[] args)
{ // Interface, onu implemente eden sınıfın referansını tutabilir.
/*
* IPersonManager customerManager = new CustomerManager();
* customerManager.Add();
* customerManager.Update();
*
* IPersonManager employeeManager = new EmployeeManager();
* employeeManager.Add();
* employeeManager.Update();
*/
// Projeyi tek noktadan yöneteceğiz.
ProjectManager projectManager = new ProjectManager();
projectManager.Add(new CustomerManager());
projectManager.Update(new EmployeeManager());
projectManager.Add(new InternManager());
}
public Example()
{
InitializeComponent();
_mProject = new ProjectManager();
_mProject.Add(new Task()
{
Name = "New Task"
});
_mChart.Init(_mProject);
}
static void Main(string[] args)
{
IPersonManager customerPerson = new CustomerManager();
customerPerson.Add(); // Müsteri eklendi. yazacak.
IPersonManager employeePerson = new EmployeeManager();
employeePerson.Add(); // Employee eklendi. yazacak.
Console.WriteLine("------------------------------------------------");
ProjectManager projectManager = new ProjectManager();
projectManager.Add(customerPerson); //Müsteri eklendi. yazacak.
projectManager.Add(employeePerson); //Müsteri eklendi. yazacak.
projectManager.Update(customerPerson); //Müsteri güncellendi. yazacak.
projectManager.Add(new InternManager()); // Stajyer eklendi. yazacak.
}
static void Main(string[] args)
{
int sayi1 = 10;
int sayi2 = 30;
sayi1 = sayi2;
sayi2 = 65;
//sayi1? 30 olur çünkü değer tipidir.
Console.WriteLine("sayi1: " + sayi1 + " " + sayi2);
int[] sayilar1 = new int[] { 10, 20, 30 };
int[] sayilar2 = new int[] { 100, 200, 300 };
sayilar1 = sayilar2; //sayilar1'in referansı da sayilar2'nin referansı ile aynıdır. 101 102 sayilar1= 102
sayilar2[0] = 999;
//sayilar1[0] ? 999 dur çünkü değer tipidir.
//değer tiplerde değer atanır referans tiplerde adres atanır.
//int,decimal,float,double,bool=değer tip
//array,class,interface=referans tip
//int, decimal, float, enum, boolean -->value types
Console.WriteLine("Sayılar1[0]" + sayilar1[0]);
Person person1 = new Person();
Person person2 = new Person();
person1.FirstName = "Ali";
person2 = person1; // person1 refe no person2'e aktarılır. Değer eşitlemesi değil, adres eşitlemesi yapılır
person1.FirstName = "Mert";
Console.WriteLine(person2.FirstName);
Customer customer = new Customer();
customer.FirstName = "Ahmet";
customer.CreditCardNumber = "1111111111111";
Person person3 = customer;
//Console.WriteLine(person3.FirstName);
Console.WriteLine(((Customer)person3).CreditCardNumber);
Employee employee = new Employee();
ProjectManager projectManager = new ProjectManager();
projectManager.Add(customer);
}
private void mnuFileNew_Click(object sender, EventArgs e)
{
// start a new Project and init the chart with the project
_mManager = new ProjectManager();
_mManager.Add(new Task()
{
Name = "New Task"
});
_mChart.Init(_mManager);
_mChart.Invalidate();
}
public void DeleteResourcesOnDeleteSplitTask()
{
IProjectManager <Task, object> manager = new ProjectManager <Task, object>();
var split = new Task();
var part1 = new Task();
var part2 = new Task();
var r1 = new Task();
manager.Add(split);
// setup: create a split task with resources on parts
manager.Split(split, part1, part2, 1);
manager.Assign(part1, r1);
manager.Assign(part2, r1);
Assert.IsTrue(!manager.TasksOf(r1).Contains(split));
Assert.IsTrue(manager.TasksOf(r1).Contains(part1));
Assert.IsTrue(manager.TasksOf(r1).Contains(part2));
Assert.IsTrue(!manager.ResourcesOf(split).Contains(r1));
Assert.IsTrue(manager.ResourcesOf(part1).Contains(r1));
Assert.IsTrue(manager.ResourcesOf(part2).Contains(r1));
Assert.IsTrue(manager.Resources.Count() == 1);
Assert.IsTrue(manager.Tasks.Count() == 1);
// test: delete the split task, everything should go
manager.Delete(split);
Assert.IsTrue(manager.Resources.Count() == 0);
Assert.IsTrue(manager.Tasks.Count() == 0);
Assert.IsTrue(!manager.TasksOf(r1).Contains(split));
Assert.IsTrue(!manager.TasksOf(r1).Contains(part1));
Assert.IsTrue(!manager.TasksOf(r1).Contains(part2));
Assert.IsTrue(!manager.ResourcesOf(split).Contains(r1));
Assert.IsTrue(!manager.ResourcesOf(part1).Contains(r1));
Assert.IsTrue(!manager.ResourcesOf(part2).Contains(r1));
// test: check that they are really deleted by adding them back again
manager.Add(split);
manager.Add(part1);
manager.Add(part2);
Assert.IsTrue(manager.Tasks.Count() == 3);
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
IPersonManager customerManager = new CustomerManager();
customerManager.Add();
IPersonManager employeeManager = new EmployeeManager();
employeeManager.Add();
ProjectManager projectManager = new ProjectManager();
projectManager.Add(customerManager);
}
public void AdjustGroupDurationOnSplit()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var group = new Task();
var split = new Task();
var part1 = new Task();
var part2 = new Task();
var part3 = new Task();
manager.Add(split);
manager.Add(group);
// setup: create a split under a group
manager.Group(group, split);
manager.Split(split, part1, part2, 1);
Assert.IsTrue(group.Duration == split.Duration);
Assert.IsTrue(group.End == part2.End);
// test: split somemore and ensure group duration and end adjust correctly
manager.Split(part2, part3, 1);
Assert.IsTrue(group.Duration == split.Duration);
Assert.IsTrue(group.End == part3.End);
}
public void MovePartEarlierStart()
{
IProjectManager <Task, object> manager = new ProjectManager <Task, object>();
var split = new Task();
var part1 = new Task();
var part2 = new Task();
var part3 = new Task();
manager.Add(split);
// setup: create a 3 part split with extra interrupt in between
manager.SetStart(split, 0);
manager.SetDuration(split, 30);
manager.Split(split, part1, part2, 10);
manager.Split(part2, part3, 10);
manager.SetStart(part2, 16);
manager.SetStart(part3, 32);
Assert.IsTrue(part1.Duration == 10);
Assert.IsTrue(part1.Start == 0);
Assert.IsTrue(part1.End == 10);
Assert.IsTrue(part2.Duration == 10);
Assert.IsTrue(part2.Start == 16);
Assert.IsTrue(part2.End == 26);
Assert.IsTrue(part3.Duration == 10);
Assert.IsTrue(part3.Start == 32);
Assert.IsTrue(part3.End == 42);
Assert.IsTrue(split.Start == 0);
Assert.IsTrue(split.Duration == 42);
Assert.IsTrue(split.End == 42);
// test: start part3 slight earlier
manager.SetStart(part3, 28);
Assert.IsTrue(part1.Duration == 10);
Assert.IsTrue(part1.Start == 0);
Assert.IsTrue(part1.End == 10);
Assert.IsTrue(part2.Duration == 10);
Assert.IsTrue(part2.Start == 16);
Assert.IsTrue(part2.End == 26);
Assert.IsTrue(part3.Duration == 10);
Assert.IsTrue(part3.Start == 28);
Assert.IsTrue(part3.End == 38);
Assert.IsTrue(split.Start == 0);
Assert.IsTrue(split.Duration == 38);
Assert.IsTrue(split.End == 38);
}
public void SetSplitTaskStartMaintainPartsRelativeSchedule()
{
IProjectManager <Task, object> manager = new ProjectManager <Task, object>();
var split = new Task();
var part1 = new Task();
var part2 = new Task();
var part3 = new Task();
manager.Add(split);
// setup: create a split task
manager.Split(split, part1, part2, 1);
manager.Split(part2, part3, 1);
manager.SetStart(part1, 0);
manager.SetStart(part2, 15);
manager.SetStart(part3, 30);
manager.SetDuration(part1, 3);
manager.SetDuration(part2, 4);
manager.SetDuration(part3, 5);
Assert.IsTrue(manager.IsSplit(split));
Assert.IsTrue(manager.IsPart(part1));
Assert.IsTrue(manager.IsPart(part2));
Assert.IsTrue(manager.IsPart(part3));
Assert.IsTrue(part1.Start == 0);
Assert.IsTrue(part2.Start == 15);
Assert.IsTrue(part3.Start == 30);
Assert.IsTrue(part1.Duration == 3);
Assert.IsTrue(part2.Duration == 4);
Assert.IsTrue(part3.Duration == 5);
Assert.IsTrue(part1.End == 3);
Assert.IsTrue(part2.End == 19);
Assert.IsTrue(part3.End == 35);
// test: move the split task itself - maintain interrupts
var offset = 10 - split.Start;
manager.SetStart(split, 10);
Assert.IsTrue(manager.IsSplit(split));
Assert.IsTrue(manager.IsPart(part1));
Assert.IsTrue(manager.IsPart(part2));
Assert.IsTrue(manager.IsPart(part3));
Assert.IsTrue(part1.Start == 0 + offset);
Assert.IsTrue(part2.Start == 15 + offset);
Assert.IsTrue(part3.Start == 30 + offset);
Assert.IsTrue(part1.Duration == 3);
Assert.IsTrue(part2.Duration == 4);
Assert.IsTrue(part3.Duration == 5);
Assert.IsTrue(part1.End == 3 + offset);
Assert.IsTrue(part2.End == 19 + offset);
Assert.IsTrue(part3.End == 35 + offset);
}
static void Main(string[] args)
{
//int, decimal, float, enum, boolean -->value types
int sayi1 = 10;
int sayi2 = 20;
sayi1 = sayi2;
sayi2 = 100;
Console.WriteLine("sayi1: " + sayi1 + " " + sayi2);
//arrays, class, interface... --> reference types
int[] sayilar1 = new int[] { 1, 2, 3 };
int[] sayilar2 = new int[] { 10, 20, 30 };
sayilar1 = sayilar2; // 101 102 sayilar1= 102
sayilar2[0] = 1000;
Console.WriteLine("Sayılar1[0]" + sayilar1[0]);
Person person1 = new Person();
Person person2 = new Person();
person1.FirstName = "Ali";
person2 = person1; // person1 refe no person2'e aktarılır. Değer eşitlemesi değil, adres eşitlemesi yapılır
person1.FirstName = "Mert";
Console.WriteLine(person2.FirstName);
Customer customer = new Customer();
customer.FirstName = "Burcu";
customer.CreditCardNumber = "3534546557567";
Person person3 = customer;
//Console.WriteLine(person3.FirstName);
Console.WriteLine(((Customer)person3).CreditCardNumber);
Employee employee = new Employee();
ProjectManager projectManager = new ProjectManager();
projectManager.Add(customer);
}
//interfaceler new'lenemez.
static void Main(string[] args)
{
IPersonManager customerManager = new CustomerManager2();
customerManager.Add();
IPersonManager employeeManager = new EmployeeManager();
employeeManager.Add();
IPersonManager personManager = new ProjectManager();
personManager.Add();
}
private void btnAddNewTask_Click(object sender, EventArgs e)
{
try
{
MyTask newTask = new MyTask(_mManager)
{
Name = "New Task"
};
newTask.TaskNotes = new List <TaskNote>();
_mManager.Add(newTask);
_mChart.Init(_mManager);
_mChart.Invalidate();
}
catch (Exception ex)
{
string errMessage = ex.Message;
if (ex.InnerException != null)
{
errMessage += string.Format("\n{0}", ex.InnerException.Message);
}
MessageBox.Show(errMessage, "ControlGanttChart::btnAddNewTask_Click", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public void TestSerialise() {
var id = new IdTable();
var props = new PropertyManager();
var lessees = new LesseeManager();
Xml.Write(props, "Properties.xml", id);
Xml.Write(lessees, "Lessees.xml", id);
var projects = new ProjectManager();
projects.Add(new Project());
projects.Current.Property = props[0];
projects.Current.CreateCost();
var fac = projects.Current.Assignments.First(a => a.Flat == props[0].Flats[0]);
var assignment = new FlatAssignment(projects.Current);
assignment.Start = DateTime.Now;
assignment.End = DateTime.Now.AddMonths(3);
assignment.Lessee = lessees[0];
fac.Add(assignment);
Xml.Write(projects, "", id);
}
public void GroupNullTaskIntoGroup()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var group1 = new Task();
manager.Add(group1);
// test: put task into null group (no effect)
manager.Group(group1, null);
Assert.IsTrue(manager.Tasks.Count() == 1);
}
public void GroupPartsBecomeGroupSplitTask()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var split = new Task() { Name = "split" };
var part1 = new Task() { Name = "part1" };
var part2 = new Task() { Name = "part2" };
var group = new Task() { Name = "group" };
var task = new Task() { Name = "task" };
manager.Add(split);
manager.Add(group);
manager.Add(task);
// setup: create a split task and a group
manager.Split(split, part1, part2, 2);
manager.Group(group, task);
Assert.IsTrue(manager.IsSplit(split));
Assert.IsTrue(manager.IsPart(part1));
Assert.IsTrue(manager.IsPart(part2));
Assert.IsTrue(manager.IsGroup(group));
Assert.IsTrue(manager.IsMember(task));
// test: group part into task;
manager.Group(group, part1);
Assert.IsTrue(manager.IsSplit(split));
Assert.IsTrue(manager.IsPart(part1));
Assert.IsTrue(manager.IsPart(part2));
Assert.IsTrue(manager.IsGroup(group));
Assert.IsTrue(manager.IsMember(task));
Assert.IsTrue(!manager.IsMember(part1));
Assert.IsTrue(manager.IsMember(split));
Assert.IsTrue(manager.ChildrenOf(group).Count() == 2);
Assert.IsTrue(manager.ChildrenOf(group).Contains(task));
Assert.IsTrue(manager.ChildrenOf(group).Contains(split));
// test: group task into part (no effect)
manager.Group(part1, task);
Assert.IsTrue(manager.IsSplit(split));
Assert.IsTrue(manager.IsPart(part1));
Assert.IsTrue(manager.IsPart(part2));
Assert.IsTrue(manager.IsGroup(group));
Assert.IsTrue(manager.IsMember(task));
Assert.IsTrue(!manager.IsMember(part1));
Assert.IsTrue(!manager.IsGroup(part1));
Assert.IsTrue(manager.ChildrenOf(group).Count() == 2);
Assert.IsTrue(manager.ChildrenOf(group).Contains(task));
Assert.IsTrue(manager.ChildrenOf(group).Contains(split));
}
public void GroupIntoParent()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var group1 = new Task();
var one = new Task();
manager.Add(group1);
manager.Add(one);
// setup: group1 contains one
manager.Group(group1, one);
// test: grouping into parent (no effect, since already grouped)
manager.Group(one, group1);
Assert.IsTrue(manager.IsGroup(group1));
Assert.IsTrue(!manager.IsGroup(one));
Assert.IsTrue(manager.ParentOf(one).Equals(group1));
}
public void GroupKnownTasksAndGroups()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var one = new Task();
var two = new Task();
var three = new Task();
var four = new Task();
var five = new Task();
var six = new Task();
manager.Add(one);
manager.Add(two);
manager.Add(three);
manager.Add(four);
manager.Add(five);
manager.Add(six);
// test: groupings
manager.Group(one, two);
manager.Group(two, three);
manager.Group(two, six);
manager.Group(four, five);
Assert.IsTrue(manager.IsGroup(one));
Assert.IsTrue(manager.IsGroup(two));
Assert.IsTrue(!manager.IsGroup(three));
Assert.IsTrue(manager.IsGroup(four));
Assert.IsTrue(!manager.IsGroup(five));
Assert.IsTrue(!manager.IsGroup(six));
// test: check task
Assert.IsTrue(manager.Tasks.Contains(one));
Assert.IsTrue(manager.Tasks.Contains(two));
Assert.IsTrue(manager.Tasks.Contains(three));
Assert.IsTrue(manager.Tasks.Contains(four));
Assert.IsTrue(manager.Tasks.Contains(five));
Assert.IsTrue(manager.Tasks.Contains(six));
// test: check decendants
Assert.IsTrue(manager.DecendantsOf(four).Contains(five));
Assert.IsTrue(manager.DecendantsOf(one).Contains(two));
Assert.IsTrue(manager.DecendantsOf(one).Contains(three));
Assert.IsTrue(manager.DecendantsOf(one).Contains(six));
Assert.IsTrue(manager.DecendantsOf(one).Count() == 3);
// test: check ancestors
Assert.IsTrue(manager.AncestorsOf(six).Contains(two));
Assert.IsTrue(manager.AncestorsOf(six).Contains(one));
Assert.IsTrue(manager.AncestorsOf(six).Count() == 2);
}
public void CreateRelation()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var one = new Task();
var two = new Task();
manager.Add(one);
manager.Add(two);
// setup: confirms no relations
Assert.IsTrue(manager.DependantsOf(one).Count() == 0);
Assert.IsTrue(manager.PrecedentsOf(two).Count() == 0);
// test: create a relationship
manager.Relate(one, two);
Assert.IsTrue(manager.DependantsOf(one).Contains(two));
Assert.IsTrue(manager.PrecedentsOf(two).Contains(one));
Assert.IsTrue(manager.HasRelations(one));
Assert.IsTrue(manager.HasRelations(two));
}
public void CreateRelationWithUnknownTasks()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var one = new Task();
var two = new Task();
manager.Add(one);
// test: non-added dependant (no effect)
manager.Relate(one, two);
Assert.IsTrue(manager.HasRelations(one) == false);
Assert.IsTrue(manager.HasRelations(two) == false);
// test: non-added precedent (no effect)
manager.Relate(two, one);
Assert.IsTrue(manager.HasRelations(one) == false);
Assert.IsTrue(manager.HasRelations(two) == false);
}
public void GroupIntoAnotherGroupWhenAlreadyHaveGroup()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var group1 = new Task();
var group2 = new Task();
var one = new Task();
manager.Add(group1);
manager.Add(group2);
manager.Add(one);
// setup: group1 contains one
manager.Group(group1, one);
// test: group one into group2, leaving group1
manager.Group(group2, one);
Assert.IsTrue(!manager.IsGroup(group1), string.Format("{0} != {1}", true, manager.IsGroup(group1)));
Assert.IsTrue(manager.IsGroup(group2));
Assert.IsTrue(!manager.IsGroup(one));
Assert.IsTrue(manager.ParentOf(one).Equals(group2));
Assert.IsTrue(manager.ChildrenOf(group1).Count() == 0);
Assert.IsTrue(manager.ChildrenOf(group2).Count() == 1);
}
public void GroupTaskIntoUnknownGroups()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var group = new Task();
var one = new Task();
// setup: make only one added
manager.Add(one);
Assert.IsTrue(manager.Tasks.Count() == 1);
Assert.IsTrue(manager.Tasks.Contains(one));
// test: check that we cannot add tasks to unknown group
manager.Group(group, one);
Assert.IsTrue(manager.Tasks.Count() == 1);
Assert.IsTrue(manager.Tasks.Contains(one));
}
public void CreateRelationThatAlreadyExist()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var one = new Task();
var two = new Task();
manager.Add(one);
manager.Add(two);
// setup: create a relationship
manager.Relate(one, two);
Assert.IsTrue(manager.DependantsOf(one).Contains(two));
Assert.IsTrue(manager.PrecedentsOf(two).Contains(one));
// test: re-create the relationship (no effect)
manager.Relate(one, two);
Assert.IsTrue(manager.DependantsOf(one).Contains(two));
Assert.IsTrue(manager.PrecedentsOf(two).Contains(one));
}
public void GroupChildIntoSelf()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var group1 = new Task();
var one = new Task();
manager.Add(group1);
manager.Add(one);
// setup: group1 contain group2 contain one
manager.Group(group1, one);
// test: group into self (no effect)
manager.Group(one, one);
Assert.IsTrue(!manager.IsGroup(one));
Assert.IsTrue(manager.ParentOf(one) == group1);
}
public void GroupCannotBeRelated()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var group = new Task();
var member = new Task();
var one = new Task();
manager.Add(group);
manager.Add(member);
manager.Add(one);
// setup: make a group
manager.Group(group, member);
Assert.IsTrue(manager.IsGroup(group));
Assert.IsTrue(manager.IsMember(member));
Assert.IsTrue(!manager.HasRelations(one));
// test: relate a task and a group (not allowed)
manager.Relate(group, one);
Assert.IsTrue(manager.IsGroup(group));
Assert.IsTrue(manager.IsMember(member));
Assert.IsTrue(!manager.HasRelations(group));
Assert.IsTrue(!manager.HasRelations(one));
// test: relate a task and a group, now in another order (not allowed)
manager.Relate(one, group);
Assert.IsTrue(manager.IsGroup(group));
Assert.IsTrue(manager.IsMember(member));
Assert.IsTrue(!manager.HasRelations(group));
Assert.IsTrue(!manager.HasRelations(one));
}
public void DoNotRelatePartsOfTheSameSplitTask()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var split = new Task();
var part1a = new Task();
var part1b = new Task();
manager.Add(split);
// setup: create a split task
manager.Split(split, part1a, part1b, 1);
Assert.IsTrue(manager.IsSplit(split));
Assert.IsTrue(!manager.IsSplit(part1a));
Assert.IsTrue(!manager.IsSplit(part1b));
Assert.IsTrue(!manager.IsPart(split));
Assert.IsTrue(manager.IsPart(part1a));
Assert.IsTrue(manager.IsPart(part1b));
Assert.IsTrue(!manager.HasRelations(split));
Assert.IsTrue(!manager.HasRelations(part1a));
Assert.IsTrue(!manager.HasRelations(part1b));
// test: relate the two parts
manager.Relate(part1a, part1b);
Assert.IsTrue(manager.IsSplit(split));
Assert.IsTrue(!manager.IsSplit(part1a));
Assert.IsTrue(!manager.IsSplit(part1b));
Assert.IsTrue(!manager.IsPart(split));
Assert.IsTrue(manager.IsPart(part1a));
Assert.IsTrue(manager.IsPart(part1b));
Assert.IsTrue(!manager.HasRelations(split));
Assert.IsTrue(!manager.HasRelations(part1a));
Assert.IsTrue(!manager.HasRelations(part1b));
}
public void DeleteMiddlePart()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var split = new Task();
var part1 = new Task();
var part2 = new Task();
var part3 = new Task();
manager.Add(split);
// setup: create a 3 part split task
manager.SetDuration(split, 30);
manager.Split(split, part1, part2, 4);
manager.Split(part2, part3, 5);
Assert.IsTrue(manager.IsSplit(split));
Assert.IsTrue(manager.IsPart(part1));
Assert.IsTrue(manager.IsPart(part2));
Assert.IsTrue(manager.IsPart(part3));
Assert.IsTrue(part1.Start == 0);
Assert.IsTrue(part2.Start == 5);
Assert.IsTrue(part3.Start == 11);
Assert.IsTrue(part1.Duration == 4);
Assert.IsTrue(part2.Duration == 5);
Assert.IsTrue(part3.Duration == 21);
Assert.IsTrue(split.Start == 0);
Assert.IsTrue(split.End == 32);
// test: delete part2, part1 and part3 should not be affected
manager.Delete(part2);
Assert.IsTrue(manager.IsSplit(split));
Assert.IsTrue(manager.IsPart(part1));
Assert.IsTrue(!manager.IsPart(part2));
Assert.IsTrue(manager.IsPart(part3));
Assert.IsTrue(part1.Duration == 4);
Assert.IsTrue(part3.Duration == 21);
Assert.IsTrue(part1.Start == 0);
Assert.IsTrue(part3.Start == 11);
Assert.IsTrue(part3.End == 32);
Assert.IsTrue(split.Start == 0);
Assert.IsTrue(split.End == 32);
}
public void GroupTaskIntoNullGroup()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var one = new Task();
manager.Add(one);
// test: put task into null group (no effect)
manager.Group(null, one);
Assert.IsTrue(manager.Tasks.Count() == 1);
}
public void GroupIntoChild()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var group1 = new Task();
var one = new Task();
manager.Add(group1);
manager.Add(one);
// setup: group1 contains one
manager.Group(group1, one);
// test: group into child (no effect)
manager.Group(one, group1);
Assert.IsTrue(manager.DecendantsOf(group1).Contains(one));
Assert.IsTrue(manager.ParentOf(one).Equals(group1));
Assert.IsTrue(manager.ParentOf(group1) == null);
}
public void AllowRelateSplitTaskToTask()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var split = new Task();
var part1a = new Task();
var part1b = new Task();
var task = new Task();
manager.Add(split);
manager.Add(task);
// setup: create a split task
manager.Split(split, part1a, part1b, 1);
Assert.IsTrue(manager.IsSplit(split));
Assert.IsTrue(!manager.IsSplit(part1a));
Assert.IsTrue(!manager.IsSplit(part1b));
Assert.IsTrue(!manager.IsPart(split));
Assert.IsTrue(manager.IsPart(part1a));
Assert.IsTrue(manager.IsPart(part1b));
Assert.IsTrue(!manager.HasRelations(split));
Assert.IsTrue(!manager.HasRelations(part1a));
Assert.IsTrue(!manager.HasRelations(part1b));
Assert.IsTrue(!manager.HasRelations(task));
// test: relate task and split task
manager.Relate(task, split);
Assert.IsTrue(manager.IsSplit(split));
Assert.IsTrue(!manager.IsSplit(part1a));
Assert.IsTrue(!manager.IsSplit(part1b));
Assert.IsTrue(!manager.IsPart(split));
Assert.IsTrue(manager.IsPart(part1a));
Assert.IsTrue(manager.IsPart(part1b));
Assert.IsTrue(manager.HasRelations(split));
Assert.IsTrue(!manager.HasRelations(part1a));
Assert.IsTrue(!manager.HasRelations(part1b));
Assert.IsTrue(manager.HasRelations(task));
Assert.IsTrue(manager.PrecedentsOf(split).Contains(task));
}
public void GroupIntoGrandChild()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var group1 = new Task();
var group2 = new Task();
var one = new Task();
manager.Add(group1);
manager.Add(group2);
manager.Add(one);
// setup: group1 contain group2 contain one
manager.Group(group1, group2);
manager.Group(group2, one);
// group into grandchild (no effect)
manager.Group(one, group1);
Assert.IsTrue(manager.ChildrenOf(group1).Contains(group2));
Assert.IsTrue(manager.ChildrenOf(group2).Contains(one));
Assert.IsTrue(manager.ChildrenOf(one).Count() == 0);
}
public void GroupTaskLevelAndOrdering()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var zero = new Task() { Name = "zero" };
var one = new Task() { Name = "one" };
var two = new Task() { Name = "two" };
var three = new Task() { Name = "three" };
var four = new Task() { Name = "four" };
var five = new Task() { Name = "five" };
manager.Add(zero);
manager.Add(one);
manager.Add(two);
manager.Add(three);
manager.Add(four);
manager.Add(five);
// single level ordering
Assert.IsTrue(manager.IndexOf(zero) == 0);
Assert.IsTrue(manager.IndexOf(one) == 1);
Assert.IsTrue(manager.IndexOf(two) == 2);
Assert.IsTrue(manager.IndexOf(three) == 3);
Assert.IsTrue(manager.IndexOf(four) == 4);
Assert.IsTrue(manager.IndexOf(five) == 5);
Assert.IsTrue(manager.Tasks.Count() == 6);
// two level ordering
manager.Group(zero, two);
manager.Group(zero, three);
Assert.IsTrue(manager.IndexOf(zero) == 0);
Assert.IsTrue(manager.IndexOf(two) == 1);
Assert.IsTrue(manager.IndexOf(three) == 2);
Assert.IsTrue(manager.IndexOf(one) == 3);
Assert.IsTrue(manager.IndexOf(four) == 4);
Assert.IsTrue(manager.IndexOf(five) == 5);
Assert.IsTrue(manager.Tasks.Count() == 6);
// three level ordering
manager.Group(five, zero);
Assert.IsTrue(manager.IndexOf(one) == 0);
Assert.IsTrue(manager.IndexOf(four) == 1);
Assert.IsTrue(manager.IndexOf(five) == 2, string.Format("Assert index == {0}; but index == {1}", 0, manager.IndexOf(five)));
Assert.IsTrue(manager.IndexOf(zero) == 3);
Assert.IsTrue(manager.IndexOf(two) == 4);
Assert.IsTrue(manager.IndexOf(three) == 5);
Assert.IsTrue(manager.Tasks.Count() == 6);
// twin three level ordering
manager.Group(four, one);
Assert.IsTrue(manager.IndexOf(four) == 0);
Assert.IsTrue(manager.IndexOf(one) == 1);
Assert.IsTrue(manager.IndexOf(five) == 2, string.Format("Assert index == {0}; but index == {1}", 0, manager.IndexOf(five)));
Assert.IsTrue(manager.IndexOf(zero) == 3);
Assert.IsTrue(manager.IndexOf(two) == 4);
Assert.IsTrue(manager.IndexOf(three) == 5);
Assert.IsTrue(manager.Tasks.Count() == 6);
// four level ordering
manager.Group(two, four);
Assert.IsTrue(manager.IndexOf(five) == 0, string.Format("Assert index == {0}; but index == {1}", 0, manager.IndexOf(five)));
Assert.IsTrue(manager.IndexOf(zero) == 1);
Assert.IsTrue(manager.IndexOf(two) == 2);
Assert.IsTrue(manager.IndexOf(four) == 3);
Assert.IsTrue(manager.IndexOf(one) == 4);
Assert.IsTrue(manager.IndexOf(three) == 5);
Assert.IsTrue(manager.Tasks.Count() == 6, string.Format("{0} != {1}", 6, manager.Tasks.Count()));
// check parents
Assert.IsTrue(manager.ParentOf(zero).Equals(five));
Assert.IsTrue(manager.ParentOf(one).Equals(four));
Assert.IsTrue(manager.ParentOf(two).Equals(zero));
Assert.IsTrue(manager.ParentOf(three).Equals(zero));
Assert.IsTrue(manager.ParentOf(four).Equals(two));
Assert.IsTrue(manager.ParentOf(five) == null);
}
public void GroupIntoGrandParent()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var group1 = new Task();
var group2 = new Task();
var one = new Task();
manager.Add(group1);
manager.Add(group2);
manager.Add(one);
// setup: group1 contain group2 contain one
manager.Group(group1, group2);
manager.Group(group2, one);
// test: group into grandparent (allowed)
manager.Group(group1, one);
Assert.IsTrue(manager.IsGroup(group1));
Assert.IsTrue(!manager.IsGroup(group2));
Assert.IsTrue(!manager.IsGroup(one));
Assert.IsTrue(manager.ParentOf(one).Equals(group1));
Assert.IsTrue(manager.ParentOf(group2).Equals(group1));
Assert.IsTrue(manager.ParentOf(group1) == null);
}
public static void Read(string filepath, ProjectManager projects, ReferenceTable references, IdTable ids) {
var xml = new XPathDocument(filepath).CreateNavigator();
var project = new Project();
var pnode = xml.SelectSingleNode("/Project");
ids[project] = new Guid(pnode.GetAttribute("id", ""));
AssignProperties(pnode, project, references);
references.Update(ids);// force Project.Property assignment
var aci = pnode.Select("Assignments/FlatAssignmentCollection");
while ( aci.MoveNext() ) {
var acnode = aci.Current;
var flatid = acnode.SelectSingleNode("Flat").Value;
var collection = project.Assignments.First(ac => ids[ac.Flat].ToString() == flatid);
ids[collection] = new Guid(acnode.GetAttribute("id", ""));
AssignProperties(acnode, collection, references);
var ai = acnode.Select("FlatAssignment");
while ( ai.MoveNext() ) {
var anode = ai.Current;
var a = new FlatAssignment(project);
ids[a] = new Guid(anode.GetAttribute("id", ""));
AssignProperties(anode, a, references);
collection.Add(a);
}
}
references.Update(ids);// force Assignments for CostOptions generation
var ci = pnode.Select("Costs/Cost");
while ( ci.MoveNext() ) {
var cnode = ci.Current;
var c = project.CreateCost();
ids[c] = new Guid(cnode.GetAttribute("id", ""));
AssignProperties(cnode, c, references);
var oi = cnode.Select("Options/CostOptions");
while ( oi.MoveNext() ) {
var onode = oi.Current;
var lesseeid = onode.SelectSingleNode("Lessee").Value;
var option = c.Options.First(o => ids[o.Lessee].ToString() == lesseeid);
ids[option] = new Guid(onode.GetAttribute("id", ""));
AssignProperties(onode, option, references);
}
}
projects.Add(project);
}
public void CreateRelationWithNull()
{
IProjectManager<Task, object> manager = new ProjectManager<Task, object>();
var one = new Task();
manager.Add(one);
// test: null precedent (no effect)
manager.Relate(null, one);
Assert.IsTrue(manager.HasRelations(one) == false);
Assert.IsTrue(manager.HasRelations(null) == false);
// test: null dependant (no effect)
manager.Relate(one, null);
Assert.IsTrue(manager.HasRelations(one) == false);
Assert.IsTrue(manager.HasRelations(null) == false);
}
