public void mark_as_last_accessed_when_the_project_is_already_the_most_recent_project()
{
var token = new ProjectToken
{
Filename = "project4.xml",
Name = "project4"
};
var history = new ProjectHistory();
history.Store(token);
history.Store(new ProjectToken
{
Filename = "project1.xml",
Name = "project1"
});
history.Store(new ProjectToken
{
Filename = "project2.xml",
Name = "project2"
});
history.Store(new ProjectToken
{
Filename = "project3.xml",
Name = "project3"
});
history.MarkAsLastAccessed(token);
}
public static void Main()
{
FileInfo fi = new FileInfo("settings.json");
if (fi.Exists)
{
Settings = new AppSettings(fi);
}
else
{
Settings = new AppSettings();
Settings.Save(AppDomain.CurrentDomain.BaseDirectory);
}
ProjectHistory.TriggerAlso("IsHistoryEmpty");
LoadCollections();
LoadHistory();
App app = new App()
{
ShutdownMode = ShutdownMode.OnMainWindowClose
};
app.InitializeComponent();
app.Run();
}
public void persist_and_load()
{
var system = new FileSystem();
var history1 = new ProjectHistory();
history1.Store(new ProjectToken
{
Filename = "project1.xml",
Name = "project1"
});
history1.Store(new ProjectToken
{
Filename = "project2.xml",
Name = "project2"
});
history1.Store(new ProjectToken
{
Filename = "project3.xml",
Name = "project3"
});
history1.Store(new ProjectToken
{
Filename = "project4.xml",
Name = "project4"
});
system.PersistToFile(history1, "history.xml");
var history2 = system.LoadFromFile <ProjectHistory>("history.xml");
history2.Projects.ShouldEqual(new[]
{
new ProjectToken
{
Filename = "project4.xml",
Name = "project4"
},
new ProjectToken
{
Filename = "project3.xml",
Name = "project3"
},
new ProjectToken
{
Filename = "project2.xml",
Name = "project2"
},
new ProjectToken
{
Filename = "project1.xml",
Name = "project1"
}
});
history2.LastAccessed.ShouldEqual(new ProjectToken
{
Filename = "project4.xml",
Name = "project4"
});
}
public void mark_as_last_accessed_when_the_project_is_not_the_most_recent_project()
{
var token = new ProjectToken
{
Filename = "project4.xml",
Name = "project4"
};
var history = new ProjectHistory();
history.Store(new ProjectToken
{
Filename = "project1.xml",
Name = "project1"
});
history.Store(new ProjectToken
{
Filename = "project2.xml",
Name = "project2"
});
history.Store(new ProjectToken
{
Filename = "project3.xml",
Name = "project3"
});
history.Store(token);
history.MarkAsLastAccessed(token);
history.LastAccessed.ShouldBeTheSameAs(token);
history.Projects.Length.ShouldEqual(4);
}
public ReportsController(TimeKeeperContext context) : base(context)
{
monthlyOverview = new MonthlyOverview(Unit);
annualOverview = new AnnualOverview(Unit);
projectHistory = new ProjectHistory(Unit);
timeTracking = new TimeTracking(Unit);
}
private void ProjectUsersChanged(Project oldProject, Project newProject)
{
var addedUsers = newProject.Users.Except(oldProject.Users, new CustomComparer.UserComparer());
var removedUsers = oldProject.Users.Except(newProject.Users, new CustomComparer.UserComparer());
foreach (var user in addedUsers)
{
var NewHistory = new ProjectHistory()
{
ProjectId = newProject.Id,
User = db.Users.Find(HttpContext.Current.User.Identity.GetUserId()),
ChangedOn = DateTime.Now,
Property = $"User added to: {newProject.Name}",
OldValue = "",
NewValue = $"{user.Email}"
};
db.ProjectHistories.Add(NewHistory);
}
foreach (var user in removedUsers)
{
var NewHistory = new ProjectHistory()
{
ProjectId = newProject.Id,
User = db.Users.Find(HttpContext.Current.User.Identity.GetUserId()),
ChangedOn = DateTime.Now,
Property = $"User removed from: {newProject.Name}",
OldValue = "",
NewValue = $"{user.Email}"
};
db.ProjectHistories.Add(NewHistory);
}
}
private void ProjectUsersChanged(Project oldProject, Project newProject)
{
var userId = projectHelper.ListUserOnProjectInRole(newProject.Id, "ProjectManager").FirstOrDefault().Id;
var addedUsers = newProject.Users.Except(oldProject.Users).ToList();
var removedUsers = oldProject.Users.Except(newProject.Users).ToList();
foreach (var user in addedUsers)
{
var NewHistory = new ProjectHistory()
{
ProjectId = newProject.Id,
UserId = userId,
ChangedOn = DateTime.Now,
Property = $"User added to: {newProject.Name}",
OldValue = "",
NewValue = user.Email
};
db.ProjectHistories.Add(NewHistory);
}
foreach (var user in removedUsers)
{
var NewHistory = new ProjectHistory()
{
ProjectId = newProject.Id,
UserId = userId,
ChangedOn = DateTime.Now,
Property = $"User removed from: {newProject.Name}",
OldValue = "",
NewValue = user.Email
};
db.ProjectHistories.Add(NewHistory);
}
}
public void last_test()
{
var history = new ProjectHistory();
history.Store(new ProjectToken
{
Filename = "project1.xml",
Name = "project1"
});
history.Store(new ProjectToken
{
Filename = "project2.xml",
Name = "project2"
});
history.Store(new ProjectToken
{
Filename = "project3.xml",
Name = "project3"
});
history.Store(new ProjectToken
{
Filename = "project4.xml",
Name = "project4"
});
history.LastAccessed.ShouldEqual(new ProjectToken
{
Filename = "project4.xml",
Name = "project4"
});
}
public async Task <IActionResult> ProjectDetails(ProjectDetailsAndAssociatedBugs projectUpdates)
{
var originalProject = _projectRepository.GetProject(projectUpdates.Project.ProjectId);
var userId = userManager.GetUserId(HttpContext.User);
var user = await userManager.FindByIdAsync(userId);
var claims = await userManager.GetClaimsAsync(user);
GlobalVar.globalCurrentUserClaims = claims.ToList();
foreach (var property in originalProject.GetType().GetProperties())
{
var oldValue = "";
var newValue = "";
if (property.GetValue(projectUpdates.Project) != null)
{
newValue = property.GetValue(projectUpdates.Project).ToString();
}
if (property.GetValue(originalProject) != null)
{
oldValue = property.GetValue(originalProject).ToString();
}
if (oldValue != newValue)
{
var changes = new ProjectHistory
{
AssociatedProjectId = originalProject.ProjectId,
Property = property.Name,
OldValue = oldValue,
NewValue = newValue,
DateChanged = DateTime.Now
};
_projectRepository.AddHistoryEntry(changes);
}
}
var projectBugs = _bugRepository.GetAllProjectBugs(projectUpdates.Project.ProjectId);
var project = _projectRepository.Update(projectUpdates.Project);
var projectHistory = _projectRepository.GetProjectHistories(projectUpdates.Project.ProjectId);
var viewModel = new ProjectDetailsAndAssociatedBugs()
{
Project = project,
ProjectBugs = projectBugs,
projectHistories = projectHistory,
ProjectId = GlobalVar.ProjectId
};
return(View(viewModel));
}
public async Task <ProjectHistory> GetProjectHistory()
{
return(await Task.Run(() =>
{
if (_repository == null)
{
return null;
}
var projectHistory = new ProjectHistory {
Changes = new List <ProjectCommitChange>()
};
var baseProjectPath = GetBaseEntityPath("Project");
var baseTaskPath = GetBaseEntityPath("Task");
var projectInRepo = false;
foreach (var commit in _repository.Commits.QueryBy(new CommitFilter {
FirstParentOnly = true
}))
{
try
{
if (!commit.Parents.Any() || !CommitContainsGitTaskFolder(commit))
{
return !projectInRepo ? null : projectHistory;
}
var parentCommit = commit.Parents.First();
var treeChanges = _repository.Diff.Compare <TreeChanges>(parentCommit.Tree, commit.Tree).ToList();
var commitChange = new ProjectCommitChange
{
Author = new ProjectMember(commit.Committer.Name, commit.Committer.Email),
Date = commit.Committer.When.DateTime,
AddedTasks = HistoryResolvingService.GetAddedTasks(treeChanges, baseTaskPath).ToList(),
RemovedTasks = HistoryResolvingService.GetRemovedTasks(treeChanges, baseTaskPath).ToList(),
ProjectMembersChange =
_historyResolvingService.GetProjectMembersChange(parentCommit, commit, treeChanges, baseProjectPath),
TaskStatesChange = _historyResolvingService.GetTaskStatesChange(parentCommit, commit, treeChanges, _projectPathsService.RelativeStoragePath, typeof(TaskState).Name),
};
if (commitChange.AddedTasks.Any() || commitChange.RemovedTasks.Any() ||
commitChange.ProjectMembersChange != null || commitChange.TaskStatesChange != null)
{
projectInRepo = true;
projectHistory.Changes.Add(commitChange);
projectHistory.CreationDate = commit.Committer.When.DateTime;
}
}
catch (Exception)
{
// exception while traversing repo or parsing files. Skip commit
}
}
projectHistory.CreationDate = DateTime.MinValue;
return projectHistory;
}));
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
ParameterEditors.Dispose();
ProjectHistory.Dispose();
ConversationNodeRenderers.Dispose();
}
}
public async Task <ActionResult <Project> > Create([FromBody] Project model, ProjectViewModel viewModel)
{
if (!ModelState.IsValid)
{
var errors = ModelState.Select(x => x.Value.Errors)
.Where(y => y.Count > 0)
.ToList();
return(BadRequest(errors));
}
/*==============================
* Insert table Projects
* ==============================*/
model.CreatedAt = DateTime.Now;
model.UpdatedAt = DateTime.Now;
model.Status = ProjectStatus.Pending;
await _context.Projects.AddAsync(model);
await _context.SaveChangesAsync();
/*==============================
* Insert table ProjectsHistories
* ==============================*/
var history = new ProjectHistory()
{
ProjectId = model.Id,
UserId = model.ManagerId,
Content = "Tạo dự án",
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now
};
await _context.ProjectHistories.AddAsync(history);
await _context.SaveChangesAsync();
var FullName = await _context.Users.Where(u => u.Id == model.ManagerId).Select(u => u.FullName).FirstAsync();
/*==============================
* Get projects and projectHistory
* ==============================*/
viewModel.Id = model.Id;
viewModel.Name = model.Name;
viewModel.Status = model.Status;
viewModel.Thumb = model.Thumb;
viewModel.Note = model.Note;
viewModel.ManagerId = model.ManagerId;
viewModel.FullName = FullName;
viewModel.Content = history.Content;
viewModel.CreatedAt = viewModel.CreatedAt;
return(Ok(viewModel));
}
public void if_storing_a_project_that_is_already_in_the_history_bring_it_to_top()
{
var history = new ProjectHistory();
history.Store(new ProjectToken
{
Filename = "project1.xml",
Name = "project1"
});
history.Store(new ProjectToken
{
Filename = "project2.xml",
Name = "project2"
});
history.Store(new ProjectToken
{
Filename = "project3.xml",
Name = "project3"
});
history.Store(new ProjectToken
{
Filename = "project4.xml",
Name = "project4"
});
history.Store(new ProjectToken
{
Filename = "project2.xml",
Name = "project2"
});
history.Projects.ShouldEqual(new[]
{
new ProjectToken
{
Filename = "project2.xml",
Name = "project2"
},
new ProjectToken
{
Filename = "project4.xml",
Name = "project4"
},
new ProjectToken
{
Filename = "project3.xml",
Name = "project3"
},
new ProjectToken
{
Filename = "project1.xml",
Name = "project1"
}
});
}
public void only_remembers_4_projects()
{
var history = new ProjectHistory();
history.Store(new ProjectToken
{
Filename = "project1.xml",
Name = "project1"
});
history.Store(new ProjectToken
{
Filename = "project2.xml",
Name = "project2"
});
history.Store(new ProjectToken
{
Filename = "project3.xml",
Name = "project3"
});
history.Store(new ProjectToken
{
Filename = "project4.xml",
Name = "project4"
});
history.Store(new ProjectToken
{
Filename = "project5.xml",
Name = "project5"
});
history.Projects.ShouldEqual(new[]
{
new ProjectToken
{
Filename = "project5.xml",
Name = "project5"
},
new ProjectToken
{
Filename = "project4.xml",
Name = "project4"
},
new ProjectToken
{
Filename = "project3.xml",
Name = "project3"
},
new ProjectToken
{
Filename = "project2.xml",
Name = "project2"
},
});
}
public Project ParseProject(string projectJson, bool ignoreRemixes)
{
JObject projectObject = JObject.Parse(projectJson);
JObject remixObject = (JObject)projectObject["remix"];
JToken remixRootToken = remixObject["root"];
JToken remixParentToken = remixObject["parent"];
bool isRemixed = false;
int remixParent = 0;
int remixRoot = 0;
if (!string.IsNullOrEmpty(remixRootToken.ToString())) //Check if this is a remixed project
{
isRemixed = true;
remixRoot = Int32.Parse(remixRoot.ToString());
if (ignoreRemixes)
{
return(null);
}
}
if (!string.IsNullOrEmpty(remixParentToken.ToString()))
{
remixParent = Int32.Parse(remixParentToken.ToString());
if (ignoreRemixes)
{
return(null);
}
;
}
if (projectObject["is_published"].Value <bool>() == false) //Check if the project is published (not private)
{
Console.WriteLine($"P: {projectObject["id"]}");
return(null);
}
ProjectStats projectStats = Newtonsoft.Json.JsonConvert.DeserializeObject <ProjectStats>(projectObject["stats"].ToString());
ProjectHistory projectHistory = Newtonsoft.Json.JsonConvert.DeserializeObject <ProjectHistory>(projectObject["history"].ToString());
Project toAdd = new Project
{
Id = Int32.Parse(projectObject["id"].ToString()),
ProjectName = projectObject["title"].ToString(),
AuthorId = 0,
Author = null,
Created = projectHistory.created,
Modified = projectHistory.modified,
TotalViews = projectStats.views,
TotalFavorites = projectStats.favorites,
TotalLoves = projectStats.loves,
Shared = projectHistory.shared == null ? DateTime.MinValue : (DateTime)projectHistory.shared,
IsRemix = isRemixed,
RemixParent = remixParent,
RemixRoot = remixRoot
};
return(toAdd);
}
public static ProjectHistory HistoryPointingToMathProject()
{
var history = new ProjectHistory();
history.Store(new ProjectToken
{
Name = "Math",
Filename = THE_MATH_FILE
});
return(history);
}
public static ProjectHistory HistoryPointingToMathProject()
{
var history = new ProjectHistory();
history.Store(new ProjectToken
{
Name = "Math",
Filename = StoryTeller.Testing.DataMother.MathProjectFile()
});
return(history);
}
public async Task <IActionResult> Update([FromBody] ListTask model, int id, ListTaskViewModel viewModel)
{
if (!ModelState.IsValid)
{
var errors = ModelState.Select(x => x.Value.Errors)
.Where(y => y.Count > 0)
.ToList();
return(BadRequest(errors));
}
var found = await context.ListTasks.FindAsync(id);
if (found != null)
{
found.Title = model.Title;
found.Desc = model.Desc;
found.UpdatedAt = DateTime.Now;
await context.SaveChangesAsync();
var history = new ProjectHistory()
{
ProjectId = model.ProjectId,
UserId = model.UserId,
Content = "Thay đổi danh sách công việc",
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now
};
await context.ProjectHistories.AddAsync(history);
await context.SaveChangesAsync();
var FullName = await context.Users.Where(u => u.Id == model.UserId).Select(u => u.FullName).FirstAsync();
/*==============================
* Get projects and projectHistory
* ==============================*/
viewModel.Id = id;
viewModel.Title = model.Title;
viewModel.Desc = model.Desc;
viewModel.ProjectId = model.ProjectId;
viewModel.FullName = FullName;
viewModel.Content = history.Content;
viewModel.CreatedAt = viewModel.CreatedAt;
return(Ok(viewModel));
}
return(BadRequest("Không tồn tại list task"));
}
private void ProjectNameChange(Project oldProject, Project newProject)
{
var NewHistory = new ProjectHistory()
{
ProjectId = newProject.Id,
UserId = HttpContext.Current.User.Identity.GetUserId(),
ChangedOn = DateTime.Now,
Property = "Description",
OldValue = oldProject.Name,
NewValue = newProject.Name
};
db.ProjectHistories.Add(NewHistory);
}
public void remembers_project_history_in_most_recent_order()
{
var history = new ProjectHistory();
history.Store(new ProjectToken
{
Filename = "project1.xml",
Name = "project1"
});
history.Store(new ProjectToken
{
Filename = "project2.xml",
Name = "project2"
});
history.Store(new ProjectToken
{
Filename = "project3.xml",
Name = "project3"
});
history.Store(new ProjectToken
{
Filename = "project4.xml",
Name = "project4"
});
history.Projects.ShouldEqual(new[]
{
new ProjectToken
{
Filename = "project4.xml",
Name = "project4"
},
new ProjectToken
{
Filename = "project3.xml",
Name = "project3"
},
new ProjectToken
{
Filename = "project2.xml",
Name = "project2"
},
new ProjectToken
{
Filename = "project1.xml",
Name = "project1"
}
});
}
public void mark_as_last_accessed_from_empty()
{
var token = new ProjectToken
{
Filename = "project4.xml",
Name = "project4"
};
var history = new ProjectHistory();
history.MarkAsLastAccessed(token);
history.Projects.Length.ShouldEqual(1);
history.LastAccessed.ShouldBeTheSameAs(token);
}
private void ProjectNameChange(Project oldProject, Project newProject)
{
var userId = projectHelper.ListUserOnProjectInRole(newProject.Id, "ProjectManager").FirstOrDefault().Id;
var NewHistory = new ProjectHistory()
{
ProjectId = newProject.Id,
UserId = userId,
ChangedOn = DateTime.Now,
Property = "Description",
OldValue = oldProject.Name,
NewValue = newProject.Name
};
db.ProjectHistories.Add(NewHistory);
}
public void save_and_load_history()
{
var history = new ProjectHistory();
var theLastProject = new ProjectToken
{
Filename = "something",
Name = "else"
};
history.Store(theLastProject);
persistor.SaveHistory(history);
IProjectHistory history2 = persistor.LoadHistory();
history2.LastAccessed.ShouldEqual(theLastProject);
}
protected void StudentUpdateProject_Click(object sender, EventArgs e)
{
var button = sender as Button;
if (string.IsNullOrWhiteSpace(button.CommandArgument))
{
return;
}
var projectId = new Guid(button.CommandArgument);
var project = DatabaseContext.Projects.First(p => p.Id == projectId);
var fileName = StudentProjectFile.FileName;
var path = Server.MapPath(".") + "\\ProjectFiles\\" + fileName;
StudentProjectFile.SaveAs(path);
var url = GetBaseUrl() + "ProjectFiles/" + fileName;
project.Url = url;
var oldStatus = project.Status;
project.Status = ProjectStatus.Created;
project.PhisicalPath = path;
DatabaseContext.Entry(project).State = System.Data.Entity.EntityState.Modified;
// add history
var projectHistory = new ProjectHistory();
projectHistory.Id = Guid.NewGuid();
projectHistory.ChangeDate = DateTime.Now;
projectHistory.Comments = StudentComment.Text;
projectHistory.OldStatus = project.Status;
projectHistory.NewStatus = oldStatus;
projectHistory.UserId = LoggedInUserId;
projectHistory.ProjectId = projectId;
DatabaseContext.ProjectHistories.Add(projectHistory);
DatabaseContext.SaveChanges();
LoadProjects();
LoadProject(project);
}
public override PagedData ProcessRequest(HttpContext context, CookDBDataContext db)
{
System.IO.StreamReader reader = new System.IO.StreamReader(context.Request.InputStream, context.Request.ContentEncoding);
var jsonSerializer = new JsonSerializer();
JObject blob = (JObject)jsonSerializer.Deserialize(new JsonTextReader(new StringReader(reader.ReadToEnd())));
if (!(db.ProjectInformations.Count(c => c.project_id == (int)blob["project_id"]) > 0))
{
return(new PagedData("UpdateProjectStatus.ashx requires a valid project ID"));
}
if (db.StatusTypes.Count(a => a.type.Equals((string)blob["type"])) > 0)
{
ProjectStatus status = new ProjectStatus();
status.project_id = (int)blob["project_id"];
status.date = (string)blob["date"];
status.status_type_id = db.StatusTypes.Single(a => a.type.Equals((string)blob["type"])).status_type_id;
db.ProjectStatus.InsertOnSubmit(status);
db.SubmitChanges();
//update project histories
ProjectHistory history = new ProjectHistory();
history.project_id = (int)blob["project_id"];
history.user_name = (string)blob["name"];
history.date = (string)blob["date"];
history.description = "Project status changed to \"" + db.StatusTypes.Single(a => a.type.Equals((string)blob["type"])).type + "\"";
history.status_id = status.project_status_id;
db.ProjectHistories.InsertOnSubmit(history);
db.SubmitChanges();
//update current_project_status
var currProject = db.ProjectInformations.Single(a => a.project_id.Equals((int)blob["project_id"]));
currProject.current_project_status = (string)blob["type"];
db.SubmitChanges();
return(new PagedData("ProjectStatus and ProjectHistory updated", true));
}
else
{
return(new PagedData("Error: Status not found. Please enter status via Status Editor or select an available status.", false));
}
}
public async Task <IActionResult> Create([FromBody] ProjectHistory model)
{
if (!ModelState.IsValid)
{
var errors = ModelState.Select(x => x.Value.Errors)
.Where(y => y.Count > 0)
.ToList();
return(BadRequest(errors));
}
model.CreatedAt = DateTime.Now;
model.UpdatedAt = DateTime.Now;
await context.ProjectHistories.AddAsync(model);
await context.SaveChangesAsync();
return(Ok(model));
}
public async Task <IActionResult> Delete(int id, int UserId, ListTaskViewModel viewModel)
{
var found = await context.ListTasks.FindAsync(id);
if (found != null)
{
context.ListTasks.Remove(found);
await context.SaveChangesAsync();
var history = new ProjectHistory()
{
ProjectId = found.ProjectId,
UserId = found.UserId,
Content = "Xóa danh sách công việc",
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now
};
await context.ProjectHistories.AddAsync(history);
await context.SaveChangesAsync();
var FullName = await context.Users.Where(u => u.Id == UserId).Select(u => u.FullName).FirstAsync();
/*==============================
* Get projects and projectHistory
* ==============================*/
viewModel.Id = id;
viewModel.Title = found.Title;
viewModel.Desc = found.Desc;
viewModel.ProjectId = found.ProjectId;
viewModel.FullName = FullName;
viewModel.Content = history.Content;
viewModel.CreatedAt = viewModel.CreatedAt;
return(Ok(viewModel));
}
return(BadRequest("Không tồn tại list task"));
}
public static void LoadHistory()
{
ProjectHistory.Clear();
if (!Directory.Exists(Settings.ProjectDirectory))
{
Directory.CreateDirectory(Settings.ProjectDirectory);
}
List <ProjectFile> history = new List <ProjectFile>();
foreach (DirectoryInfo di in new DirectoryInfo(Settings.ProjectDirectory).EnumerateDirectories())
{
if (di.EnumerateFiles(di.Name + ".dm").Count() > 0)
{
history.Add(new ProjectFile(di));
}
}
ProjectHistory.Add(history.OrderBy(x => x.LastModifyDate).Reverse().Take(ProjectHistory.Limit));
OnProjectsChanged(EventArgs.Empty);
}
protected void UpdateProjectHistory_Click(object sender, EventArgs e)
{
var button = sender as Button;
if (string.IsNullOrWhiteSpace(button.CommandArgument))
{
return;
}
var newStatusDropdown = CommentNewStatus;
var newStatus = (ProjectStatus)Convert.ToInt16(newStatusDropdown.SelectedValue);
var gradeTextbox = CommentGrade;
var commentTextbox = Comment;
var projectId = new Guid(button.CommandArgument);
var project = DatabaseContext.Projects.First(p => p.Id == projectId);
// add history
var projectHistory = new ProjectHistory();
projectHistory.Id = Guid.NewGuid();
projectHistory.ChangeDate = DateTime.Now;
projectHistory.Comments = commentTextbox.Text;
projectHistory.OldStatus = project.Status;
projectHistory.NewStatus = newStatus;
projectHistory.UserId = LoggedInUserId;
projectHistory.ProjectId = projectId;
DatabaseContext.ProjectHistories.Add(projectHistory);
// update project status and grade
project.Grade = gradeTextbox.Text;
project.Status = newStatus;
DatabaseContext.Entry(project).State = System.Data.Entity.EntityState.Modified;
DatabaseContext.SaveChanges();
LoadProjects();
LoadProject(project);
}
public void SetUp()
{
ProjectHistory history = DataMother.HistoryPointingToMathProject();
new ProjectPersistor().SaveHistory(history);
Bootstrapper.BootstrapShell(false);
shell = (Shell)ObjectFactory.GetInstance <IApplicationShell>();
ObjectFactory.Configure(x =>
{
x.For <Window>().Use(() =>
{
window = new Window();
window.Show();
return(window);
});
});
}
