public void SavePokerCard(PokerCard card)
{
using (var context = new ScrumFactoryEntities(this.connectionString))
{
PokerCard oldCard = context.PokerCards.Where(c => c.MemberUId == card.MemberUId && c.BacklogItemUId == card.BacklogItemUId).SingleOrDefault();
if (oldCard == null)
{
card.VoteDate = System.DateTime.Now;
context.PokerCards.AddObject(card);
}
else
{
if (!card.Value.HasValue)
{
context.PokerCards.DeleteObject(oldCard);
var now = System.DateTime.Now.AddHours(-2);
var strNow = now.Year + "-" + now.Month + "-" + now.Day + " " + now.Hour + ":" + now.Minute + ":" + now.Second;
context.ExecuteStoreCommand("DELETE FROM factory.PokerCard WHERE VoteDate < '" + strNow + "'");
}
else
{
card.VoteDate = System.DateTime.Now;
context.ApplyCurrentValues <PokerCard>("PokerCard", card);
}
}
context.SaveChanges();
}
}
private void SaveBacklogItem(BacklogItem item, bool saveHours)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
SaveBacklogItem(context, item, saveHours);
context.SaveChanges();
}
}
public void CreateHourCosts(Project project, Project similarProject)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
// get similar costs
RoleHourCost[] similarCosts = null;
if(similarProject!=null)
similarCosts = GetHourCosts(similarProject.ProjectUId);
// fore each role at this project
foreach (Role r in project.Roles) {
// checks if there is a role with the same shortname at the similar project, and if so, uses its costs
Role similarRole = null;
string roleName = r.RoleShortName.ToLower();
if(similarProject!=null)
similarRole = similarProject.Roles.FirstOrDefault(sr => sr.RoleShortName.ToLower() == roleName);
RoleHourCost similarHourCost = null;
if(similarRole!=null && similarCosts!=null)
similarHourCost = similarCosts.FirstOrDefault(c => c.RoleUId == similarRole.RoleUId);
if(similarHourCost==null)
similarHourCost = new RoleHourCost() { Price = 0, Cost = 0 };
// only if role is new
RoleHourCost oldCost = context.RoleHourCosts.SingleOrDefault(h => h.RoleUId == r.RoleUId);
if (oldCost == null) {
RoleHourCost cost = new RoleHourCost() { RoleUId = r.RoleUId, ProjectUId = project.ProjectUId, Cost = similarHourCost.Cost, Price = similarHourCost.Price };
context.RoleHourCosts.AddObject(cost);
}
}
context.SaveChanges();
}
}
public void SaveMemberAvatar(MemberAvatar avatar)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
MemberProfile oldMember = GetMember(avatar.MemberUId);
MemberAvatar oldAvatar = GetMemberAvatar(avatar.MemberUId);
if (oldMember == null)
{
throw new System.Exception("member not found");
}
if (oldAvatar == null)
{
context.MembersAvatar.AddObject(avatar);
}
else
{
context.AttachTo("MembersAvatar", oldAvatar);
context.ApplyCurrentValues <MemberAvatar>("MembersAvatar", avatar);
}
context.SaveChanges();
}
}
public void DeleteProjectRole(string roleUId)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
Role oldRole = GetProjectRole(roleUId, true);
context.AttachTo("Roles", oldRole);
context.DeleteObject(oldRole);
context.SaveChanges();
}
}
public void DeleteSprint(string sprintUId)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
Sprint oldSprint = GetSprint(sprintUId);
context.AttachTo("Sprints", oldSprint);
context.DeleteObject(oldSprint);
context.SaveChanges();
}
}
public void DeleteProjectRole(string roleUId)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
Role oldRole = GetProjectRole(roleUId, true);
context.AttachTo("Roles", oldRole);
context.DeleteObject(oldRole);
context.SaveChanges();
}
}
public void DeleteSprint(string sprintUId)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
Sprint oldSprint = GetSprint(sprintUId);
context.AttachTo("Sprints", oldSprint);
context.DeleteObject(oldSprint);
context.SaveChanges();
}
}
public void RemoveArtifact(string artifactUId)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
Artifact artifact = context.Artifacts.SingleOrDefault(a => a.ArtifactUId == artifactUId);
if (artifact == null)
return;
context.Artifacts.DeleteObject(artifact);
context.SaveChanges();
};
}
public void SaveHourCosts(RoleHourCost[] costs)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
foreach (RoleHourCost cost in costs)
{
SaveHourCost(cost, context);
}
context.SaveChanges();
}
}
public void DeleteProjectConstraint(string constraintUId)
{
using (var context = new ScrumFactoryEntities(connectionString)) {
var constraint = context.ProjectConstraints.SingleOrDefault(c => c.ConstraintUId == constraintUId);
if (constraint == null)
return;
context.ProjectConstraints.DeleteObject(constraint);
context.SaveChanges();
}
}
public void DeleteProjectConstraint(string constraintUId)
{
using (var context = new ScrumFactoryEntities(connectionString)) {
var constraint = context.ProjectConstraints.SingleOrDefault(c => c.ConstraintUId == constraintUId);
if (constraint == null)
return;
context.ProjectConstraints.DeleteObject(constraint);
context.SaveChanges();
}
}
public void DeleteBacklogItem(string backlogItemUId)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
var item = context.BacklogItems.Include("PlannedHours").SingleOrDefault(b => b.BacklogItemUId == backlogItemUId);
if (item != null) {
context.DeleteObject(item);
context.SaveChanges();
}
}
}
public void RemoveMemberAvatar(string memberUId)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
MemberAvatar avatar = context.MembersAvatar.SingleOrDefault(a => a.MemberUId == memberUId);
if (avatar != null)
{
context.MembersAvatar.DeleteObject(avatar);
context.SaveChanges();
}
}
}
public void UpdateBacklogItemArtifactCount(string backlogItemUId, int count)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
var item = context.BacklogItems.SingleOrDefault(i => i.BacklogItemUId == backlogItemUId);
if (item == null)
{
return;
}
item.ArtifactCount = count;
context.SaveChanges();
}
}
public void UpdateTaskArtifactCount(string taskUId, int count)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
var task = context.Tasks.SingleOrDefault(t => t.TaskUId == taskUId);
if (task == null)
{
return;
}
task.ArtifactCount = count;
context.SaveChanges();
}
}
public void RemoveArtifact(string artifactUId)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
Artifact artifact = context.Artifacts.SingleOrDefault(a => a.ArtifactUId == artifactUId);
if (artifact == null)
{
return;
}
context.Artifacts.DeleteObject(artifact);
context.SaveChanges();
};
}
public void SaveProjectConstraint(ProjectConstraint constraint)
{
using (var context = new ScrumFactoryEntities(connectionString)) {
var old = context.ProjectConstraints.SingleOrDefault(c => c.ConstraintUId == constraint.ConstraintUId);
if (old != null) {
context.AttachTo("ProjectConstraints", old);
context.ApplyCurrentValues<ProjectConstraint>("ProjectConstraints", constraint);
}
else
context.ProjectConstraints.AddObject(constraint);
context.SaveChanges();
}
}
public void SaveProjectConstraint(ProjectConstraint constraint)
{
using (var context = new ScrumFactoryEntities(connectionString)) {
var old = context.ProjectConstraints.SingleOrDefault(c => c.ConstraintUId == constraint.ConstraintUId);
if (old != null) {
context.AttachTo("ProjectConstraints", old);
context.ApplyCurrentValues<ProjectConstraint>("ProjectConstraints", constraint);
}
else
context.ProjectConstraints.AddObject(constraint);
context.SaveChanges();
}
}
public void CreateHourCosts(Project project, Project similarProject)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
// get similar costs
RoleHourCost[] similarCosts = null;
if (similarProject != null)
{
similarCosts = GetHourCosts(similarProject.ProjectUId);
}
// fore each role at this project
foreach (Role r in project.Roles)
{
// checks if there is a role with the same shortname at the similar project, and if so, uses its costs
Role similarRole = null;
string roleName = r.RoleShortName.ToLower();
if (similarProject != null)
{
similarRole = similarProject.Roles.FirstOrDefault(sr => sr.RoleShortName.ToLower() == roleName);
}
RoleHourCost similarHourCost = null;
if (similarRole != null && similarCosts != null)
{
similarHourCost = similarCosts.FirstOrDefault(c => c.RoleUId == similarRole.RoleUId);
}
if (similarHourCost == null)
{
similarHourCost = new RoleHourCost()
{
Price = 0, Cost = 0
}
}
;
// only if role is new
RoleHourCost oldCost = context.RoleHourCosts.SingleOrDefault(h => h.RoleUId == r.RoleUId);
if (oldCost == null)
{
RoleHourCost cost = new RoleHourCost()
{
RoleUId = r.RoleUId, ProjectUId = project.ProjectUId, Cost = similarHourCost.Cost, Price = similarHourCost.Price
};
context.RoleHourCosts.AddObject(cost);
}
}
context.SaveChanges();
}
}
public bool DeleteBacklogItemGroup(string groupUId)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
var inUse = context.BacklogItems.Any(i => i.GroupUId == groupUId);
if (inUse)
return false;
var group = context.BacklogItemGroups.SingleOrDefault(g => g.GroupUId == groupUId);
context.BacklogItemGroups.DeleteObject(group);
context.SaveChanges();
return true;
}
}
public void DeleteItemSize(string itemSizeUId)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
ItemSize size = context.ItemSizes.Include("SizeIdealHours").SingleOrDefault(z => z.ItemSizeUId == itemSizeUId);
if (size == null)
return;
//if (size.SizeIdealHours != null) {
// foreach (SizeIdealHour h in size.SizeIdealHours)
// context.SizeIdealHours.DeleteObject(h);
//}
context.ItemSizes.DeleteObject(size);
context.SaveChanges();
}
}
public void DeleteTaskTag(string tagUId)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
// first un-mark tasks
var tasks = context.Tasks.Where(t => t.TagUId == tagUId);
foreach (Task task in tasks)
task.TagUId = null;
// now deletes the tag
var oldTag = context.TaskTags.SingleOrDefault(t => t.TagUId == tagUId);
context.TaskTags.DeleteObject(oldTag);
context.SaveChanges();
}
}
public void UpdateBacklogItemGroup(BacklogItemGroup group)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
BacklogItemGroup oldGroup = context.BacklogItemGroups.Where(g => g.GroupUId == group.GroupUId).SingleOrDefault();
if (oldGroup == null)
{
context.AddObject("BacklogItemGroups", group);
}
else
{
context.ApplyCurrentValues <BacklogItemGroup>("BacklogItemGroups", group);
}
context.SaveChanges();
}
}
public bool DeleteBacklogItemGroup(string groupUId)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
var inUse = context.BacklogItems.Any(i => i.GroupUId == groupUId);
if (inUse)
{
return(false);
}
var group = context.BacklogItemGroups.SingleOrDefault(g => g.GroupUId == groupUId);
context.BacklogItemGroups.DeleteObject(group);
context.SaveChanges();
return(true);
}
}
public void SaveProjectMembership(ProjectMembership membership)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
ProjectMembership existMembership = context.ProjectMemberships.SingleOrDefault(m => m.MemberUId == membership.MemberUId && m.ProjectUId == membership.ProjectUId && m.RoleUId == membership.RoleUId);
if (existMembership == null)
{
context.ProjectMemberships.AddObject(membership);
}
else
{
context.AttachTo("ProjectMemberships", existMembership);
context.ApplyCurrentValues <ProjectMembership>("ProjectMemberships", membership);
}
context.SaveChanges();
}
}
public void SaveItemSize(ItemSize size)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
ItemSize oldSize = GetItemSize(size.ItemSizeUId);
if (oldSize == null)
{
context.ItemSizes.AddObject(size);
}
else
{
context.AttachTo("ItemSizes", oldSize);
context.ApplyCurrentValues <ItemSize>("ItemSizes", size);
if (oldSize.SizeIdealHours == null)
{
oldSize.SizeIdealHours = new List <SizeIdealHour>();
}
if (size.SizeIdealHours == null)
{
oldSize.SizeIdealHours = new List <SizeIdealHour>();
}
var deletedHours = oldSize.SizeIdealHours.Where(o => !size.SizeIdealHours.Any(s => s.IdealHourUId == o.IdealHourUId));
var updatedHours = size.SizeIdealHours.Where(s => oldSize.SizeIdealHours.Any(o => o.IdealHourUId == s.IdealHourUId));
var insertedHours = size.SizeIdealHours.Where(s => !oldSize.SizeIdealHours.Any(o => o.IdealHourUId == s.IdealHourUId));
foreach (SizeIdealHour h in deletedHours)
{
context.SizeIdealHours.DeleteObject(h);
}
foreach (SizeIdealHour h in updatedHours)
{
context.ApplyCurrentValues <SizeIdealHour>("SizeIdealHours", h);
}
foreach (SizeIdealHour h in insertedHours)
{
context.SizeIdealHours.AddObject(h);
}
}
context.SaveChanges();
}
}
public void DeleteBacklogItem(string backlogItemUId)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
var item = context.BacklogItems.Include("PlannedHours").SingleOrDefault(b => b.BacklogItemUId == backlogItemUId);
if (item != null)
{
context.BacklogItems.DeleteObject(item);
var a = context.SaveChanges();
System.Diagnostics.Debug.WriteLine("** item deleteed DATA " + backlogItemUId);
}
else
{
System.Diagnostics.Debug.WriteLine("** item " + backlogItemUId + " not found");
}
}
}
public void SaveTaskTag(TaskTag tag)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
var oldTag = context.TaskTags.SingleOrDefault(t => t.TagUId == tag.TagUId);
if (oldTag == null)
{
context.TaskTags.AddObject(tag);
}
else
{
context.AttachTo("TaskTags", oldTag);
context.ApplyCurrentValues <TaskTag>("TaskTags", tag);
}
context.SaveChanges();
}
}
public void DeleteTaskTag(string tagUId)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
// first un-mark tasks
var tasks = context.Tasks.Where(t => t.TagUId == tagUId);
foreach (Task task in tasks)
{
task.TagUId = null;
}
// now deletes the tag
var oldTag = context.TaskTags.SingleOrDefault(t => t.TagUId == tagUId);
context.TaskTags.DeleteObject(oldTag);
context.SaveChanges();
}
}
public void DeleteItemSize(string itemSizeUId)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
ItemSize size = context.ItemSizes.Include("SizeIdealHours").SingleOrDefault(z => z.ItemSizeUId == itemSizeUId);
if (size == null)
{
return;
}
//if (size.SizeIdealHours != null) {
// foreach (SizeIdealHour h in size.SizeIdealHours)
// context.SizeIdealHours.DeleteObject(h);
//}
context.ItemSizes.DeleteObject(size);
context.SaveChanges();
}
}
public void SaveArtifact(Artifact artifact)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
Artifact oldArtifact = context.Artifacts.SingleOrDefault(a => a.ArtifactUId == artifact.ArtifactUId);
if (oldArtifact == null)
context.Artifacts.AddObject(artifact);
else {
context.AttachTo("Artifacts", oldArtifact);
context.ApplyCurrentValues<Artifact>("Artifacts", artifact);
}
context.SaveChanges();
};
}
public void SaveAuthorizationInfo(AuthorizationInfo info)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
AuthorizationInfo oldInfo = context.AuthorizationInfos.Where(a => a.MemberUId == info.MemberUId).FirstOrDefault();
if (oldInfo == null)
context.AuthorizationInfos.AddObject(info);
else {
context.AttachTo("AuthorizationInfos", oldInfo);
oldInfo.Token = info.Token;
oldInfo.IssueDate = info.IssueDate;
}
context.SaveChanges();
};
}
public void SaveMember(MemberProfile newMember)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
MemberProfile oldMember = GetMember(newMember.MemberUId);
if (oldMember == null)
{
context.MembersProfile.AddObject(newMember);
}
else
{
context.AttachTo("MemberProfiles", oldMember);
context.ApplyCurrentValues <MemberProfile>("MemberProfiles", newMember);
}
context.SaveChanges();
}
}
public void SaveArtifact(Artifact artifact)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
Artifact oldArtifact = context.Artifacts.SingleOrDefault(a => a.ArtifactUId == artifact.ArtifactUId);
if (oldArtifact == null)
{
context.Artifacts.AddObject(artifact);
}
else
{
context.AttachTo("Artifacts", oldArtifact);
context.ApplyCurrentValues <Artifact>("Artifacts", artifact);
}
context.SaveChanges();
};
}
public int InsertProject(ScrumFactory.Project project)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
context.Projects.AddObject(project);
if (project.Memberships != null)
{
foreach (ProjectMembership m in project.Memberships)
{
context.AddObject("ProjectMemberships", m);
}
}
context.SaveChanges();
}
return(project.ProjectNumber);
}
public void SaveAuthorizationInfo(AuthorizationInfo info)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
AuthorizationInfo oldInfo = context.AuthorizationInfos.Where(a => a.MemberUId == info.MemberUId).FirstOrDefault();
if (oldInfo == null)
{
context.AuthorizationInfos.AddObject(info);
}
else
{
context.AttachTo("AuthorizationInfos", oldInfo);
oldInfo.Token = info.Token;
oldInfo.IssueDate = info.IssueDate;
}
context.SaveChanges();
};
}
public void SaveProjectRole(ScrumFactory.Role role)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
Role oldRole = GetProjectRole(role.RoleUId);
if (oldRole == null)
{
context.Roles.AddObject(role);
}
else
{
context.AttachTo("Roles", oldRole);
context.ApplyCurrentValues <Role>("Roles", role);
}
context.SaveChanges();
}
}
public void SaveRisk(Risk risk)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
Risk oldRisk = GetRisk(risk.RiskUId);
// if is a new item insert it
if (oldRisk == null)
{
context.Risks.AddObject(risk);
// updates the item
}
else
{
context.AttachTo("Risks", oldRisk);
context.ApplyCurrentValues <Risk>("Risks", risk);
}
context.SaveChanges();
}
}
public void SaveSprint(Sprint sprint)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
Sprint oldSprint = GetSprint(sprint.SprintUId);
// if is a new item insert it
if (oldSprint == null)
{
context.Sprints.AddObject(sprint);
// updates the item
}
else
{
context.AttachTo("Sprints", oldSprint);
context.ApplyCurrentValues <Sprint>("Sprints", sprint);
}
context.SaveChanges();
}
}
public void SaveTask(Task task)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
Task oldTask = GetTask(task.TaskUId);
if (oldTask == null)
{
context.Tasks.AddObject(task);
if (task.TaskDetail != null)
{
context.TaskDetails.AddObject(task.TaskDetail);
}
}
else
{
// apply current values, but preserve create at date
System.DateTime createAt = oldTask.CreatedAt;
string owner = oldTask.TaskOwnerUId;
context.AttachTo("Tasks", oldTask);
context.ApplyCurrentValues <Task>("Tasks", task);
oldTask.CreatedAt = createAt;
oldTask.TaskOwnerUId = owner;
if (task.TaskDetail != null && oldTask.TaskDetail == null)
{
context.TaskDetails.AddObject(task.TaskDetail);
}
else
if (task.TaskDetail != null && oldTask.TaskDetail != null)
{
context.AttachTo("TaskDetails", oldTask.TaskDetail);
context.ApplyCurrentValues <TaskDetail>("TaskDetails", task.TaskDetail);
}
}
context.SaveChanges();
}
}
public void UpdateProject(ScrumFactory.Project project)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
var projectOld = GetProject(project.ProjectUId);
context.AttachTo("Projects", projectOld);
context.ApplyCurrentValues <Project>("Projects", project);
if (projectOld.Memberships == null)
{
projectOld.Memberships = new List <ProjectMembership>();
}
if (project.Memberships == null)
{
project.Memberships = new List <ProjectMembership>();
}
var insertedMemberships = project.Memberships.Where(m => !projectOld.Memberships.Any(o => (o.MemberUId == m.MemberUId && o.RoleUId == m.RoleUId))).ToList();
var updatedMemberships = project.Memberships.Where(m => projectOld.Memberships.Any(o => (o.MemberUId == m.MemberUId && o.RoleUId == m.RoleUId))).ToList();
var deletedMemberships = projectOld.Memberships.Where(m => !project.Memberships.Any(o => (o.MemberUId == m.MemberUId && o.RoleUId == m.RoleUId))).ToList();
foreach (ProjectMembership m in insertedMemberships)
{
context.AddObject("ProjectMemberships", m);
}
foreach (ProjectMembership m in updatedMemberships)
{
context.ApplyCurrentValues <ProjectMembership>("ProjectMemberships", m);
}
foreach (ProjectMembership m in deletedMemberships)
{
context.DeleteObject(m);
}
context.SaveChanges();
}
}
public void SaveProposal(Proposal proposal)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
Proposal oldProposal = GetProjectProposal(proposal.ProjectUId, proposal.ProposalUId);
using (TransactionScope scope = new TransactionScope()) {
// if its a new proposal
if (oldProposal == null) {
// proposals
context.Proposals.AddObject(proposal);
// items
foreach (ProposalItem pitem in proposal.Items)
context.ProposalItems.AddObject(pitem);
// clauses
if(proposal.Clauses!=null) {
foreach (ProposalClause clause in proposal.Clauses)
context.ProposalClauses.AddObject(clause);
}
}
// if is an old one
else {
context.AttachTo("Proposals", oldProposal);
context.ApplyCurrentValues<Proposal>("Proposals", proposal);
// if is approving a proposal, adds its XAML document
if (proposal.ProposalDocument != null)
context.ProposalDocuments.AddObject(proposal.ProposalDocument);
if (oldProposal.Items == null)
oldProposal.Items = new List<ProposalItem>();
if (proposal.Items == null)
proposal.Items = new List<ProposalItem>();
UpdateProposalItems(context, proposal, oldProposal);
UpdateProposalClauses(context, proposal, oldProposal);
UpdateProposalFixedCosts(context, proposal, oldProposal);
}
context.SaveChanges();
scope.Complete();
}
}
}
public void SaveHourCosts(RoleHourCost[] costs)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
foreach (RoleHourCost cost in costs)
SaveHourCost(cost, context);
context.SaveChanges();
}
}
public void SaveMember(MemberProfile newMember)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
MemberProfile oldMember = GetMember(newMember.MemberUId);
if (oldMember == null)
context.MembersProfile.AddObject(newMember);
else {
context.AttachTo("MemberProfiles", oldMember);
context.ApplyCurrentValues<MemberProfile>("MemberProfiles", newMember);
}
context.SaveChanges();
}
}
public void SaveTask(Task task)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
Task oldTask = GetTask(task.TaskUId);
if (oldTask == null) {
context.Tasks.AddObject(task);
if(task.TaskDetail!=null)
context.TaskDetails.AddObject(task.TaskDetail);
} else {
// apply current values, but preserve create at date
System.DateTime createAt = oldTask.CreatedAt;
string owner = oldTask.TaskOwnerUId;
context.AttachTo("Tasks", oldTask);
context.ApplyCurrentValues<Task>("Tasks", task);
oldTask.CreatedAt = createAt;
oldTask.TaskOwnerUId = owner;
if (task.TaskDetail != null && oldTask.TaskDetail==null) {
context.TaskDetails.AddObject(task.TaskDetail);
}
else
if (task.TaskDetail != null && oldTask.TaskDetail != null) {
context.AttachTo("TaskDetails", oldTask.TaskDetail);
context.ApplyCurrentValues<TaskDetail>("TaskDetails", task.TaskDetail);
}
}
context.SaveChanges();
}
}
public int InsertProject(ScrumFactory.Project project)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
context.Projects.AddObject(project);
if(project.Memberships!=null)
foreach (ProjectMembership m in project.Memberships)
context.AddObject("ProjectMemberships", m);
context.SaveChanges();
}
return project.ProjectNumber;
}
public void SaveProjectMembership(ProjectMembership membership)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
ProjectMembership existMembership = context.ProjectMemberships.SingleOrDefault(m => m.MemberUId == membership.MemberUId && m.ProjectUId == membership.ProjectUId && m.RoleUId == membership.RoleUId);
if (existMembership == null) {
context.ProjectMemberships.AddObject(membership);
} else {
context.AttachTo("ProjectMemberships", existMembership);
context.ApplyCurrentValues<ProjectMembership>("ProjectMemberships", membership);
}
context.SaveChanges();
}
}
public void SaveProjectRole(ScrumFactory.Role role)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
Role oldRole = GetProjectRole(role.RoleUId);
if (oldRole == null) {
context.Roles.AddObject(role);
} else {
context.AttachTo("Roles", oldRole);
context.ApplyCurrentValues<Role>("Roles", role);
}
context.SaveChanges();
}
}
public void SaveRisk(Risk risk)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
Risk oldRisk = GetRisk(risk.RiskUId);
// if is a new item insert it
if (oldRisk == null) {
context.Risks.AddObject(risk);
// updates the item
}
else {
context.AttachTo("Risks", oldRisk);
context.ApplyCurrentValues<Risk>("Risks", risk);
}
context.SaveChanges();
}
}
public void UpdateProject(ScrumFactory.Project project)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
var projectOld = GetProject(project.ProjectUId);
context.AttachTo("Projects", projectOld);
context.ApplyCurrentValues<Project>("Projects", project);
if (projectOld.Memberships == null)
projectOld.Memberships = new List<ProjectMembership>();
if (project.Memberships == null)
project.Memberships = new List<ProjectMembership>();
var insertedMemberships = project.Memberships.Where(m => !projectOld.Memberships.Any(o => (o.MemberUId == m.MemberUId && o.RoleUId == m.RoleUId))).ToList();
var updatedMemberships = project.Memberships.Where(m => projectOld.Memberships.Any(o => (o.MemberUId == m.MemberUId && o.RoleUId == m.RoleUId))).ToList();
var deletedMemberships = projectOld.Memberships.Where(m => !project.Memberships.Any(o => (o.MemberUId == m.MemberUId && o.RoleUId == m.RoleUId))).ToList();
foreach (ProjectMembership m in insertedMemberships)
context.AddObject("ProjectMemberships", m);
foreach (ProjectMembership m in updatedMemberships)
context.ApplyCurrentValues<ProjectMembership>("ProjectMemberships", m);
foreach (ProjectMembership m in deletedMemberships)
context.DeleteObject(m);
context.SaveChanges();
}
}
public void UpdateItemSizeOccurrenceContraint(string itemSizeUId, ItemOccurrenceContraints constraint)
{
// gets the item and set the constraint
ItemSize newSize = GetItemSize(itemSizeUId);
if (newSize == null)
return;
// now seacrh for the olditem with the same constraint and clean it
using (var context = new ScrumFactoryEntities(this.connectionString)) {
ItemSize oldSize = context.ItemSizes.SingleOrDefault(z => z.OccurrenceConstraint == (int)constraint);
if (oldSize != null)
oldSize.OccurrenceConstraint = (int)ItemOccurrenceContraints.DEVELOPMENT_OCC;
context.AttachTo("ItemSizes", newSize);
newSize.OccurrenceConstraint = (int)constraint;
context.SaveChanges();
}
}
public void UpdateBacklogItemGroup(BacklogItemGroup group)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
BacklogItemGroup oldGroup = context.BacklogItemGroups.Where(g => g.GroupUId == group.GroupUId).SingleOrDefault();
if (oldGroup == null)
context.AddObject("BacklogItemGroups", group);
else
context.ApplyCurrentValues<BacklogItemGroup>("BacklogItemGroups", group);
context.SaveChanges();
}
}
public void UpdateBacklogItemArtifactCount(string backlogItemUId, int count)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
var item = context.BacklogItems.SingleOrDefault(i => i.BacklogItemUId == backlogItemUId);
if (item == null)
return;
item.ArtifactCount = count;
context.SaveChanges();
}
}
public void SaveTaskTag(TaskTag tag)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
var oldTag = context.TaskTags.SingleOrDefault(t => t.TagUId == tag.TagUId);
if (oldTag == null) {
context.TaskTags.AddObject(tag);
} else {
context.AttachTo("TaskTags", oldTag);
context.ApplyCurrentValues<TaskTag>("TaskTags", tag);
}
context.SaveChanges();
}
}
public void SaveMemberAvatar(MemberAvatar avatar)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
MemberProfile oldMember = GetMember(avatar.MemberUId);
MemberAvatar oldAvatar = GetMemberAvatar(avatar.MemberUId);
if (oldMember == null)
throw new System.Exception("member not found");
if (oldAvatar == null) {
context.MembersAvatar.AddObject(avatar);
} else {
context.AttachTo("MembersAvatar", oldAvatar);
context.ApplyCurrentValues<MemberAvatar>("MembersAvatar", avatar);
}
context.SaveChanges();
}
}
private void SaveBacklogItem(BacklogItem item, bool saveHours)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
SaveBacklogItem(context, item, saveHours);
context.SaveChanges();
}
}
public void SaveItemSize(ItemSize size)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
ItemSize oldSize = GetItemSize(size.ItemSizeUId);
if (oldSize == null) {
context.ItemSizes.AddObject(size);
}
else {
context.AttachTo("ItemSizes", oldSize);
context.ApplyCurrentValues<ItemSize>("ItemSizes", size);
if (oldSize.SizeIdealHours == null)
oldSize.SizeIdealHours = new List<SizeIdealHour>();
if(size.SizeIdealHours==null)
oldSize.SizeIdealHours = new List<SizeIdealHour>();
var deletedHours = oldSize.SizeIdealHours.Where(o => !size.SizeIdealHours.Any(s => s.IdealHourUId == o.IdealHourUId));
var updatedHours = size.SizeIdealHours.Where(s => oldSize.SizeIdealHours.Any(o => o.IdealHourUId == s.IdealHourUId));
var insertedHours = size.SizeIdealHours.Where(s => !oldSize.SizeIdealHours.Any(o => o.IdealHourUId == s.IdealHourUId));
foreach (SizeIdealHour h in deletedHours)
context.SizeIdealHours.DeleteObject(h);
foreach (SizeIdealHour h in updatedHours)
context.ApplyCurrentValues<SizeIdealHour>("SizeIdealHours", h);
foreach (SizeIdealHour h in insertedHours)
context.SizeIdealHours.AddObject(h);
}
context.SaveChanges();
}
}
public void SaveSprint(Sprint sprint)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
Sprint oldSprint = GetSprint(sprint.SprintUId);
// if is a new item insert it
if (oldSprint == null) {
context.Sprints.AddObject(sprint);
// updates the item
} else {
context.AttachTo("Sprints", oldSprint);
context.ApplyCurrentValues<Sprint>("Sprints", sprint);
}
context.SaveChanges();
}
}
public void UpdateTaskArtifactCount(string taskUId, int count)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
var task = context.Tasks.SingleOrDefault(t => t.TaskUId == taskUId);
if (task == null)
return;
task.ArtifactCount = count;
context.SaveChanges();
}
}