public ProposalItemWithPrice(string proposalUId, BacklogItem item, decimal value)
{
Price = value;
BacklogItemUId = item.BacklogItemUId;
Item = item;
ProposalUId = ProposalUId;
}
public ProposalItemViewModel(ProposalViewModel proposal, BacklogItem item, BacklogItemGroup group)
{
this.proposal = proposal;
this.Item = item;
this.ItemGroup = group;
OnPropertyChanged("IsAtProposal");
}
public void ChangeBacklogItemIssueType(string backlogItemUId, short issueType)
{
BacklogItem item = GetBacklogItem(backlogItemUId);
Project project = projectsService.GetProject(item.ProjectUId);
VerifyPermissionForCreateEditItem(item, project);
item.IssueType = issueType;
backlogRepository.SaveBacklogItemIgnoreHours(item);
}
public void ChangeBacklogItemGroup(string backlogItemUId, string groupUId)
{
BacklogItem item = GetBacklogItem(backlogItemUId);
Project project = projectsService.GetProject(item.ProjectUId);
VerifyPermissionForCreateEditItem(item, project);
item.GroupUId = groupUId;
backlogRepository.SaveBacklogItemIgnoreHours(item);
}
public void CanAddUserStoryWithComponents()
{
var backlog = new Backlog();
var component = new Component("A");
var item = new BacklogItem("US1", component);
backlog.Add(item);
var backlogItem = backlog.Items.Single();
Assert.AreEqual(new Component("A"), backlogItem.FindComponentFor(new Skill("A")));
}
public ActionResult Edit([Bind(Include = "BacklogItemId,Description,Estimate,SprintId")] BacklogItem backlogitem)
{
if (ModelState.IsValid)
{
db.Entry(backlogitem).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.SprintId = new SelectList(db.Sprints.OrderBy(s => s.SprintName), "SprintId", "SprintName", backlogitem.SprintId);
return(View(backlogitem));
}
/// <summary>
/// Saves a backlog item.
/// If the item planned hours is old, it also replan the hours for the current planning number.
/// </summary>
/// <param name="item">The iem to be saved</param>
public int AddBacklogItem(BacklogItem item)
{
if (item.Project == null)
throw new Exception("Can not save a backlogitem without a Project property");
var client = ClientHelper.GetClient(authorizator);
HttpResponseMessage response = client.Post(Url("BacklogItems"), new ObjectContent<BacklogItem>(item, JsonValueMediaTypeFormatter.DefaultMediaType));
ClientHelper.HandleHTTPErrorCode(response);
item.BacklogItemNumber = response.Content.ReadAs<int>();
return item.BacklogItemNumber;
}
public void UpdateItemStatusToWorking(Task task)
{
BacklogItem item = GetBacklogItem(task.BacklogItemUId);
if (item.Status != (short)BacklogItemStatus.ITEM_REQUIRED || task.EffectiveHours == 0)
{
return;
}
item.Status = (short)BacklogItemStatus.ITEM_WORKING;
backlogRepository.SaveBacklogItemIgnoreHours(item);
}
public void ESAggregateA_Applies_Domain_Events()
{
var id = new BacklogItemId();
var item = BacklogItem.FromSummary(id, "summary");
Assert.Equal(id, item.Id);
Assert.Equal("summary", item.Summary);
Assert.Equal(0, item.Version);
Assert.Contains(item.DomainEvents, e => e is BacklogItemCreated);
}
public void Update(object data)
{
try
{
BacklogItem item = (BacklogItem)data;
//We can do something here with the data for now just print a console line
Console.WriteLine("Notification Received: " + item.description + " Has been updated");
} catch {
//Normally use logger here, for now print line
Console.WriteLine("Can't cast data object to backlogitem");
}
}
public void Commit(BacklogItem backlogItem)
{
var ordering = this.backlogItems.Count + 1;
var committedBacklogItem = new CommittedBacklogItem(
this.TenantId,
this.SprintId,
backlogItem.BacklogItemId,
ordering);
this.backlogItems.Add(committedBacklogItem);
}
public static DBBacklogItem ToEntity(this BacklogItem backlogItem)
{
return(new DBBacklogItem
{
Created = backlogItem.Created,
Description = backlogItem.Description,
EstimatedTime = backlogItem.EstimatedTime,
Id = backlogItem.Id,
Tasks = backlogItem.Tasks.Select(task => task.ToEntity()),
Title = backlogItem.Title
});
}
public void Commit(BacklogItem backlogItem)
{
var ordering = _backlogItems.Count + 1;
var committedBacklogItem = new CommittedBacklogItem(
TenantId,
SprintId,
backlogItem.BacklogItemId,
ordering);
_backlogItems.Add(committedBacklogItem);
}
private BacklogItem PrepareDefaultItem(Project project, string name, string groupName, int sprintNumber, DefaultItemGroups defaultGroup, ItemOccurrenceContraints constraint)
{
// create the new item
BacklogItem item = new BacklogItem {
BacklogItemUId = Guid.NewGuid().ToString(),
ProjectUId = project.ProjectUId,
Name = name,
Description = null,
Status = (short)BacklogItemStatus.ITEM_REQUIRED,
BusinessPriority = 1,
OccurrenceConstraint = (short)constraint,
SizeFactor = 0,
CreateDate = DateTime.Now
};
item.Project = project;
item.SyncPlannedHoursAndRoles(sprintNumber);
// assign group
ICollection <BacklogItemGroup> groups = GetBacklogItemGroups(project.ProjectUId);
var group = groups.FirstOrDefault(g => g.DefaultGroup == (short)defaultGroup);
if (group == null)
{
group = CreateDefaultGroup(project.ProjectUId, defaultGroup, groupName);
}
item.Group = group;
item.GroupUId = group.GroupUId;
// assign size
ItemSize size = backlogRepository.GetItemSizeByConstraint((short)constraint);
if (size != null)
{
item.ItemSizeUId = size.ItemSizeUId;
item.SizeFactor = 1;
item.Size = size.Size * item.SizeFactor;
// tries to set the ideal hour values
foreach (var h in size.SizeIdealHours)
{
var ph = item.PlannedHours.SingleOrDefault(p => p.Role.RoleShortName.ToLower() == h.RoleShortName.ToLower());
if (ph != null)
{
ph.Hours = h.Hours;
}
}
}
return(item);
}
public void EntitiesWithSameIdentityAndProps_ShouldBeEqual()
{
var guid = Guid.NewGuid();
var id = new BacklogItemId(guid);
var item0 = BacklogItem.FromSummary(id, "item summary");
var item1 = BacklogItem.FromSummary(id, "item summary");
Assert.True(item0.Equals(item1));
Assert.Equal(item0, item1);
Assert.True(item0 == item1);
}
public ForumTest()
{
Backlog backlog = new Backlog();
Developer dev = new Developer();
ScrumMaster scrumMaster = new ScrumMaster();
Sprint sprint = new Sprint("Sprint 1", new DateTime(), new DateTime().AddDays(7), scrumMaster);
sprint.addTeamMember(dev);
Forum forum = new Forum(sprint);
_backlogItem = new BacklogItem(backlog, "a new item", 12);
_thread = forum.addThread(_backlogItem, "there is a issue", "description", dev);
}
// GET: BacklogItem/Create
public ActionResult Create(int?id)
{
if (id == null)
{
return(View());
}
var item = new BacklogItem
{
ProjectID = (int)id
};
return(View(item));
}
static void Main(string[] args)
{
BacklogItem backlogItem = new BacklogItem();
Dictionary <string, FormDrafter.ValueSetter> formInputs = backlogItem.GetFormInputs();
Dictionary <string, FormDrafter.ValueGetter> formCurrentValues = backlogItem.GetFormCurrentValues();
FormDrafter formDrafter = new FormDrafter();
formDrafter.Draw(formInputs, formCurrentValues);
Console.WriteLine();
formDrafter.Draw(formInputs, formCurrentValues);
Console.ReadKey();
}
public void UpdateBacklogItem(string backlogItemUId, BacklogItem item, Project project)
{
// updates the planning number
foreach (PlannedHour h in item.PlannedHours)
{
if (h.PlanningNumber < project.CurrentPlanningNumber)
{
h.PlanningNumber = project.CurrentPlanningNumber;
}
}
backlogRepository.SaveBacklogItem(item);
}
public void ToggleViewedBacklog(BacklogItem i)
{
try
{
i.Episode.HasBeenViewed = !i.Episode.HasBeenViewed;
UpdateViewedOnBacklog(i.Episode);
}
catch (Exception ex)
{
ErrorManager.Log(ex);
}
}
private void SendTicketEmail(BacklogItem ticket, Project project, bool PONotification)
{
try {
// get members and attach to the project
mailer.AttachProjectMembers(project);
// create body from the template
ReportHelper.Report reports = new ReportHelper.Report();
var template = "ticket_created";
if (PONotification)
{
template = "ticket_createdPO";
}
// get project scrum masters
string scrumMasterStr = "";
if (project.Roles != null && project.Memberships != null)
{
var scrumMasterRoles = project.Roles.Where(r => r.PermissionSet == (short)PermissionSets.SCRUM_MASTER).Select(r => r.RoleUId).ToArray();
var scrumMasters = project.Memberships.Where(m => m.IsActive && scrumMasterRoles.Contains(m.RoleUId)).Select(m => m.MemberUId).ToArray();
scrumMasterStr = string.Join(", ", scrumMasters);
}
ReportHelper.ReportConfig reportConfig = new ReportHelper.ReportConfig("EmailNotifications", template, Helper.ReportTemplate.ServerUrl);
reportConfig.ReportObjects.Add(project);
reportConfig.ReportObjects.Add(ticket);
reportConfig.ReportVars.Add("ProjectScrumMasters", scrumMasterStr);
string body = reports.CreateReportXAML(Helper.ReportTemplate.ServerUrl, reportConfig, true);
// subject
string subject = String.Format(TicketEmailSubject, project.ProjectNumber + "." + ticket.BacklogItemNumber);
if (!String.IsNullOrEmpty(ticket.ExternalId))
{
subject = String.Format(TicketEmailSubject, ticket.ExternalId);
}
// send it to all project members
bool send = mailer.SendEmail(project, subject, body, PONotification);
if (!send)
{
ScrumFactory.Services.Logic.Helper.Log.LogMessage("Ticket email was not send.");
}
} catch (System.Exception ex) {
ScrumFactory.Services.Logic.Helper.Log.LogError(ex);
}
}
// GET: /BacklogItem/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
BacklogItem backlogitem = db.BacklogItems.Find(id);
if (backlogitem == null)
{
return(HttpNotFound());
}
return(View(backlogitem));
}
public BacklogItem[] ChangeItemSprint(string backlogItemUId, int sprintNumber, bool lowPriority)
{
// get item
BacklogItem item = GetBacklogItem(backlogItemUId);
// verify permission
authorizationService.VerifyPermissionAtProject(item.ProjectUId, PermissionSets.SCRUM_MASTER);
ICollection <BacklogItem> backlog = GetCurrentBacklog(item.ProjectUId, (short)BacklogFiltersMode.ALL);
Project project = projectsService.GetProject(item.ProjectUId);
return(ChangeItemSprint(item, backlog, project, sprintNumber, lowPriority));
}
public int AddBacklogItem(BacklogItem item)
{
Project project = projectsService.GetProject(item.ProjectUId);
VerifyPermissionForCreateEditItem(item, project);
backlogRepository.SaveBacklogItem(item);
if (project.ProjectType == (short)ProjectTypes.TICKET_PROJECT && ShouldCreateTicketFolders) {
CreateTicketFolder(project, item);
}
return item.BacklogItemNumber;
}
//------------------------------------------------------------------------------------
/// <summary>
/// Begins the process of loading the current's team's planner schedule from the
/// repository.
/// </summary>
//------------------------------------------------------------------------------------
public void InitializeRepository(bool shouldClearProductGroup)
{
ExperienceItem.InitializeFilters();
BacklogItem.InitializeFilters();
if (shouldClearProductGroup)
{
BeginProductGroupQuery(null);
}
else
{
BeginOpenProductGroup();
}
}
private ICollection <BacklogItem> IncludeBacklogItemsThatHasTasks(string projectUId, ICollection <BacklogItem> items)
{
ICollection <Task> dailyTasks = tasksService.GetProjectTasks(projectUId, DateTime.MinValue, DateTime.MinValue, true, null);
List <Task> outsideTasks = dailyTasks.Where(t => !items.Any(i => i.BacklogItemUId == t.BacklogItemUId)).ToList();
foreach (Task task in outsideTasks)
{
BacklogItem item = GetBacklogItem(task.BacklogItemUId);
if (!items.Any(i => i.BacklogItemUId == item.BacklogItemUId))
{
items.Add(item);
}
}
return(items);
}
// GET: /BacklogItem/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
BacklogItem backlogitem = db.BacklogItems.Find(id);
if (backlogitem == null)
{
return(HttpNotFound());
}
ViewBag.SprintId = new SelectList(db.Sprints.OrderBy(s => s.SprintName), "SprintId", "SprintName", backlogitem.SprintId);
return(View(backlogitem));
}
public async Task Update(BacklogItem backlogItem)
{
var backlogItemToUpdate = await _context.BacklogItems.FirstOrDefaultAsync(b => b.Id == backlogItem.Id);
if (backlogItemToUpdate == default)
{
throw new Exception("Provided backlogItem id is invalid");
}
backlogItemToUpdate.Created = backlogItem.Created;
backlogItemToUpdate.Description = backlogItem.Description;
backlogItemToUpdate.Title = backlogItem.Title;
backlogItemToUpdate.EstimatedTime = backlogItem.EstimatedTime;
await _context.SaveChangesAsync();
}
public void PlannedProductBacklogItem(BacklogItem backlogItem)
{
AssertionConcern.AssertArgumentEquals(this.TenantId, backlogItem.TenantId, "The product and backlog item must have same tenant.");
AssertionConcern.AssertArgumentEquals(this.ProductId, backlogItem.ProductId, "The backlog item must belong to product.");
int ordering = this.backlogItems.Count + 1;
ProductBacklogItem productBacklogItem =
new ProductBacklogItem(
this.TenantId,
this.ProductId,
backlogItem.BacklogItemId,
ordering);
this.backlogItems.Add(productBacklogItem);
}
private static Project ToProject(XmlProject xmlProject)
{
ArgumentChecks.AssertNotNull(xmlProject, nameof(xmlProject));
var project = new Project(xmlProject.Id)
{
Title = xmlProject.Title
};
foreach (var xmlItem in xmlProject.Items)
{
var item = new Item(xmlItem.Id)
{
PublicIdentifier = xmlItem.PublicIdentifier,
Summary = xmlItem.Summary,
Description = xmlItem.Description,
EstimatedCostOfDelayPerDay = xmlItem.EstimatedCostOfDelayPerDay,
EstimatedDevelopmentDurationInDays = xmlItem.EstimatedDevelopmentDurationInDays
};
project.Items.Add(item);
}
foreach (var xmlBacklog in xmlProject.Backlogs)
{
var backlog = new Backlog(xmlBacklog.Id)
{
Name = xmlBacklog.Name
};
foreach (var xmlBacklogItem in xmlBacklog.BacklogItems)
{
var referencedItem = project.Items.Single(i => i.Id == xmlBacklogItem.ItemId);
var backlogItem = new BacklogItem(referencedItem)
{
Rank = xmlBacklogItem.Rank
};
backlog.BacklogItems.Add(backlogItem);
}
project.Backlogs.Add(backlog);
}
return(project);
}
public void Should_AddCommentToPost()
{
//arrange
BacklogItem backlogItem = new BacklogItem()
{
Title = "new featue",
State = new BacklogComponentStateDoing()
};
string content = "some content";
User user1 = new User()
{
FirstName = "Patrick",
MiddleName = "van",
LastName = "Batenburg",
Email = "*****@*****.**"
};
User user2 = new User()
{
FirstName = "Patrick2",
MiddleName = "van",
LastName = "Batenburg"
};
Comment comment = new Comment()
{
Author = user2,
Content = "test"
};
Mock <Post> mock = new Mock <Post>(backlogItem, content, user1)
{
CallBase = true
};
//act
mock.Object.Add(comment);
//assert
mock.Verify(x => x.Add(It.IsAny <Comment>()), Times.Exactly(1));
Assert.Single(mock.Object.Comments);
Assert.Equal(user1, mock.Object.Author);
Assert.Equal(user1.Email, mock.Object.Author.Email);
Assert.Equal(user1.FullName, mock.Object.Author.FullName);
Assert.Equal(user2, mock.Object.Comments[0].Author);
Assert.Equal(backlogItem.Title, mock.Object.Title);
Assert.Equal(content, mock.Object.Content);
}
public void ProgressTest()
{
//arrange
Mock <Sprint> sprint = new Mock <Sprint>();
Backlog backlog = new Backlog(sprint.Object);
BacklogItem headItem = new BacklogItem("Desc");
backlog.AddBacklogItem(headItem);
//act
headItem.Progress();
//assert
Assert.IsTrue(headItem.state.GetType().Equals("doing"));
}
public void AddBacklogItemToSprintTest()
{
//Arrange
ScrumBoard board = new ScrumBoard();
ScrumMaster master = new ScrumMaster();
Sprint sprint = new Sprint("sprint 1", DateTime.Now, DateTime.Now.AddDays(14), master);
Backlog backlog = new Backlog();
BacklogItem backlogitem = new BacklogItem(backlog, "test", 8);
//Act
project.AddBoard(board);
board.AddSprint(sprint);
board.AddBacklogItem(backlogitem);
//Assert
Assert.IsNotNull(project.GetBoard().getSprints());
Assert.IsTrue(sprint.backlog.backlogItems.Contains(backlogitem));
}
public void CheckSetBackHeadItem()
{
//arrange
Mock <Sprint> sprint = new Mock <Sprint>();
Backlog backlog = new Backlog(sprint.Object);
BacklogItem headItem = new BacklogItem("Desc");
backlog.AddBacklogItem(headItem);
//act
headItem.Progress();
headItem.state.SetBack();
//assert
Assert.IsTrue(headItem.state.GetType().Equals("todo"));
}
public void UpdateBacklogItem(string backlogItemUId, BacklogItem item)
{
Project project = projectsService.GetProject(item.ProjectUId);
VerifyPermissionForCreateEditItem(item, project);
UpdateBacklogItem(backlogItemUId, item, project);
}
public void ShowDetail(IChildWindow parentViewModel, BacklogItem item)
{
Item = item;
SuggestedHours = null;
((DelegateCommand)NavigateToNextItemCommand).NotifyCanExecuteChanged();
((DelegateCommand)NavigateToPreviousItemCommand).NotifyCanExecuteChanged();
if (!View.IsVisible)
Show(parentViewModel);
oldItem = Item.Clone();
SetIdealHours();
SetIsInEditMode();
ArtifactListViewModel.ChangeContext(ArtifactContexts.BACKLOGITEM_ARTIFACT, Item.BacklogItemUId, RefreshBacklogItemArtifactCount);
TaskListViewModel.Item = this.Item;
}
internal BacklogItem PrepareNewBacklogItem(string name, ItemOccurrenceContraints occurrenceConstraint, int? sprintNumber)
{
// if no sprint number was informed, tries to fit it at the avaiable sprints
if (sprintNumber == null)
sprintNumber = GetSprintNumberForInsert();
// create the new item
BacklogItem newItem = new BacklogItem {
BacklogItemUId = Guid.NewGuid().ToString(),
ProjectUId = Project.ProjectUId,
Project = Project,
Name = name,
Description = null,
Status = (short)BacklogItemStatus.ITEM_REQUIRED,
BusinessPriority = NextBusinessPriority,
OccurrenceConstraint = (short)occurrenceConstraint,
SizeFactor = 0,
CreateDate = DateTime.Now
};
SetItemGroupAndSize(newItem);
// if is a SCRUM MASTER plan it at the sprint
// if is a PRODUCT OWNER than sprintNumber will be null
if(Project.HasPermission(authorizator.SignedMemberProfile.MemberUId, PermissionSets.SCRUM_MASTER))
newItem.SyncPlannedHoursAndRoles(sprintNumber);
return newItem;
}
internal void DuplicateBacklogItemHours(BacklogItem newItem, BacklogItem fromItem, int? sprintNumber)
{
newItem.PlannedHours = new List<PlannedHour>();
Role[] orderedRoles = Project.Roles.OrderBy(r => r.PermissionSet).ThenBy(r => r.RoleName).ThenBy(r => r.RoleShortName).ToArray();
for(int i=0; i<orderedRoles.Length && i<fromItem.PlannedHours.Count; i++) {
PlannedHour h = fromItem.PlannedHours[i];
PlannedHour hour = new PlannedHour { BacklogItemUId = newItem.BacklogItemUId, Hours = h.Hours, SprintNumber = sprintNumber, PlanningNumber = Project.CurrentPlanningNumber, RoleUId = orderedRoles[i].RoleUId };
newItem.PlannedHours.Add(hour);
}
}
internal void DuplicateBacklogItemHoursSameProject(BacklogItem newItem, BacklogItem fromItem, int? sprintNumber)
{
newItem.PlannedHours = new List<PlannedHour>();
foreach (PlannedHour h in fromItem.CurrentPlannedHours) {
if (Project.Roles.Any(r => r.RoleUId == h.RoleUId)) {
PlannedHour hour = new PlannedHour { BacklogItemUId = newItem.BacklogItemUId, Hours = h.Hours, SprintNumber = sprintNumber, PlanningNumber = Project.CurrentPlanningNumber, RoleUId = h.RoleUId };
newItem.PlannedHours.Add(hour);
}
}
}
public BacklogItemViewModel(
IBacklogService backlogService,
IBackgroundExecutor backgroundExecutor,
IEventAggregator eventAggregator,
IAuthorizationService authorizator,
Project project,
BacklogItem item,
ScrumFactory.Composition.Configuration sfConfig)
{
Init(backlogService, backgroundExecutor, eventAggregator, authorizator, project, item);
SFConfig = sfConfig;
ShowRepositoryLogCommand = new DelegateCommand(ShowRepositoryLog);
}
internal BacklogItem DuplicateBacklogItem(BacklogItem fromItem)
{
int? sprintNumber = GetSprintNumberForInsert();
// create item
BacklogItem newItem = new BacklogItem {
BacklogItemUId = Guid.NewGuid().ToString(),
ProjectUId = Project.ProjectUId,
Project = Project,
Name = fromItem.Name,
Description = fromItem.Description,
Status = fromItem.Status,
BusinessPriority = NextBusinessPriority,
OccurrenceConstraint = fromItem.OccurrenceConstraint,
SizeFactor = fromItem.SizeFactor,
Size = fromItem.Size,
ItemSizeUId = fromItem.ItemSizeUId,
CancelReason = fromItem.CancelReason,
DeliveryDate = fromItem.DeliveryDate,
StartedAt = fromItem.StartedAt,
FinishedAt = fromItem.FinishedAt,
IssueType = fromItem.IssueType,
CreateDate = DateTime.Now
};
// copy planned hours
if (fromItem.ProjectUId == Project.ProjectUId)
DuplicateBacklogItemHoursSameProject(newItem, fromItem, sprintNumber);
else
DuplicateBacklogItemHours(newItem, fromItem, sprintNumber);
newItem.SyncPlannedHoursAndRoles(sprintNumber);
return newItem;
}
private void ShowTasksForItem(BacklogItem item)
{
ListMode = ListModes.LIST_MODE;
SelectedBacklogItem = item;
LoadItems();
aggregator.Publish<IProjectTabViewModel>(ScrumFactoryEvent.ShowProjectTab, this);
}
private void SendTicketEmail(BacklogItem ticket, string folder, Project project)
{
try {
// get members and attach to the project
mailer.AttachProjectMembers(project);
// create body from the template
ReportHelper.Report reports = new ReportHelper.Report();
ReportHelper.ReportConfig reportConfig = new ReportHelper.ReportConfig("EmailNotifications", "ticket_created", Helper.ReportTemplate.ServerUrl);
reportConfig.ReportObjects.Add(project);
reportConfig.ReportObjects.Add(ticket);
reportConfig.ReportVars.Add("TicketFolder", folder);
string body = reports.CreateReportXAML(Helper.ReportTemplate.ServerUrl, reportConfig);
// subject
string subject = "Ticket #" + project.ProjectNumber + "." + ticket.BacklogItemNumber;
// send it to all project members
bool send = mailer.SendEmail(project, subject, body);
if (!send)
ScrumFactory.Services.Logic.Helper.Log.LogMessage("Ticket email was not send.");
} catch (System.Exception ex) {
ScrumFactory.Services.Logic.Helper.Log.LogError(ex);
}
}
/// <summary>
/// Moves the item to the target item position - 1
/// </summary>
/// <param name="item"></param>
/// <param name="targetItem"></param>
/// <returns></returns>
private BacklogItem[] MoveItem(BacklogItem item, BacklogItem targetItem)
{
// verify permission
authorizationService.VerifyPermissionAtProject(targetItem.ProjectUId, PermissionSets.SCRUM_MASTER);
if (targetItem.OccurrenceConstraint == 0) // can not move to before a plan item
return null;
// get the sprint itens
List<BacklogItem> sprintItems = GetCurrentBacklog(targetItem.ProjectUId, (short)BacklogFiltersMode.ALL)
.Where(b => b.SprintNumber == targetItem.SprintNumber)
.OrderBy(b => b.OccurrenceConstraint).ThenBy(b => b.BusinessPriority).ToList();
Project project = projectsService.GetProject(item.ProjectUId);
return MoveItem(item, targetItem, sprintItems, project);
}
private BacklogItem[] ChangeItemSprint(BacklogItem item, ICollection<BacklogItem> backlog, Project project, int sprintNumber, bool lowPriority)
{
// if is moving back to the product backlog
if (sprintNumber < 0) {
item.SprintNumber = null;
UpdateBacklogItem(item.BacklogItemUId, item, project);
return new BacklogItem[] { item };
}
// if moving to a previous sprint or is low priority
// insert it at the end of the sprint
if (lowPriority || item.SprintNumber > sprintNumber) {
BacklogItem targetItem = GetLastSprintDevelopmentItem(backlog, sprintNumber);
int priority = 1;
if (targetItem != null)
priority = targetItem.BusinessPriority + 1;
item.SprintNumber = sprintNumber;
item.BusinessPriority = priority;
UpdateBacklogItem(item.BacklogItemUId, item, project);
return new BacklogItem[] { item };
}
// if moving to a sprint ahead, insert it at the begining
if (item.SprintNumber == null || item.SprintNumber < sprintNumber) {
BacklogItem targetItem = GetFirstSprintDevelopmentItem(backlog, sprintNumber);
// if the sprint has no items
if (targetItem == null) {
item.SprintNumber = sprintNumber;
item.BusinessPriority = 1;
UpdateBacklogItem(item.BacklogItemUId, item, project);
return new BacklogItem[] { item };
}
List<BacklogItem> sprintItems = backlog.Where(i => i.SprintNumber == sprintNumber).ToList();
return MoveItem(item, targetItem, sprintItems, project);
}
return null;
}
public void UpdateBacklogItem(string backlogItemUId, BacklogItem item, Project project)
{
// updates the planning number
foreach (PlannedHour h in item.PlannedHours)
h.PlanningNumber = project.CurrentPlanningNumber;
backlogRepository.SaveBacklogItem(item);
}
public void UpdateChangedItems(BacklogItem[] changedItems)
{
AskForRefresh();
}
private void Store(BacklogItem backlogItem)
{
_session.Store(backlogItem);
}
public void UpdateBacklogItemIgnoringHours(string backlogItemUId, BacklogItem item)
{
VerifyPermissionForCreateEditItem(item);
backlogRepository.SaveBacklogItemIgnoreHours(item);
}
private void OnItemsSelectedChanged(BacklogItem item)
{
OnPropertyChanged("SelectedItemsCount");
OnPropertyChanged("SelectedItemsPlannedHours");
OnPropertyChanged("SelectedItemsEffectiveHours");
}
private void CreateTicketFolder(Project project, BacklogItem item)
{
string path = "";
try {
if (!string.IsNullOrEmpty(project.DocRepositoryPath)) {
// creates the folder
if (project.DocRepositoryPath.EndsWith("\\"))
path = project.DocRepositoryPath + "Ticket " + item.BacklogItemNumber;
else
path = project.DocRepositoryPath + "\\Ticket " + item.BacklogItemNumber;
System.IO.Directory.CreateDirectory(path);
// adds as an artifact at the item
Artifact artifact = new Artifact();
artifact.ArtifactPath = path;
artifact.ArtifactName = "Ticket " + item.BacklogItemNumber;
artifact.ArtifactUId = Guid.NewGuid().ToString();
artifact.ArtifactContext = (short)ArtifactContexts.BACKLOGITEM_ARTIFACT;
artifact.ContextUId = item.BacklogItemUId;
artifact.ProjectUId = project.ProjectUId;
artifactService.AddArtifact(artifact);
}
} catch (Exception ex) {
ScrumFactory.Services.Logic.Helper.Log.LogError(ex);
}
try {
SendTicketEmail(item, path, project);
} catch (Exception ex) {
ScrumFactory.Services.Logic.Helper.Log.LogError(ex);
}
}
private void PasteTextItems(string text)
{
if (String.IsNullOrEmpty(text))
return;
string[] items = text.Split(new char[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
if (items.Length == 0)
return;
List<BacklogItem> clipItems = new List<BacklogItem>();
foreach (string item in items) {
string[] fields = item.Replace("\r","").Split(new char[] { '\t' }, StringSplitOptions.None);
BacklogItem newItem = new BacklogItem() {
Name = fields[0],
BacklogItemUId = Guid.NewGuid().ToString(),
Status = (short)BacklogItemStatus.ITEM_REQUIRED,
OccurrenceConstraint = (int)ItemOccurrenceContraints.DEVELOPMENT_OCC,
SizeFactor = 1,
CreateDate = DateTime.Now
};
newItem.PlannedHours = new List<PlannedHour>();
for (int i = 2; i < fields.Length; i++) {
decimal hours;
decimal.TryParse(fields[i], out hours);
newItem.PlannedHours.Add(new PlannedHour() { BacklogItemUId = newItem.BacklogItemUId, Hours = hours });
}
clipItems.Add(newItem);
}
PasteObjectItems(clipItems);
}
private BacklogItem[] MoveItem(BacklogItem item, BacklogItem targetItem, List<BacklogItem> sprintItems, Project project)
{
int itemIndex = sprintItems.IndexOf(sprintItems.Where(b => b.BacklogItemUId == item.BacklogItemUId).SingleOrDefault());
int targetIndex = sprintItems.IndexOf(sprintItems.Where(b => b.BacklogItemUId == targetItem.BacklogItemUId).SingleOrDefault());
if (itemIndex == targetIndex)
return null;
// The item sprint may change, so link it to its project before do that
// -> item.SprintNumber requires a project
item.Project = project;
// keep tracking of the changing items
List<BacklogItem> changedItems = new List<BacklogItem>();
changedItems.Add(item);
// item was at other sprint
if (itemIndex == -1) {
// update item priority and resets the delivery date
item.BusinessPriority = CalcsNewPriority(sprintItems, targetIndex);
item.SprintNumber = targetItem.SprintNumber;
item.DeliveryDate = null;
UpdateBacklogItem(item.BacklogItemUId, item, project);
for (int i = targetIndex; i < sprintItems.Count - 1; i++) {
if (sprintItems[i].OccurrenceConstraint == 1) {
sprintItems[i].BusinessPriority = sprintItems[i].BusinessPriority + 10;
UpdateBacklogItem(sprintItems[i].BacklogItemUId, sprintItems[i], project);
changedItems.Add(sprintItems[i]);
}
}
//BacklogItem last = sprintItems.Last();
//last.BusinessPriority = last.BusinessPriority + 1;
//UpdateBacklogItem(last.BacklogItemUId, last, project);
//changedItems.Add(last);
}
// item at the same sprint and moving an item up
else if (itemIndex > targetIndex) {
// update item priority
item.BusinessPriority = targetItem.BusinessPriority;
item.SprintNumber = targetItem.SprintNumber;
UpdateBacklogItem(item.BacklogItemUId, item, project);
for (int i = targetIndex; i < itemIndex; i++) {
sprintItems[i].BusinessPriority = sprintItems[i + 1].BusinessPriority;
UpdateBacklogItem(sprintItems[i].BacklogItemUId, sprintItems[i], project);
changedItems.Add(sprintItems[i]);
}
}
// item at the same sprint and moving an item down
else if (itemIndex < targetIndex) {
int realTargetIndex = targetIndex - 1;
int itemPriority = sprintItems[realTargetIndex].BusinessPriority;
for (int i = realTargetIndex; i >= itemIndex + 1; i--) {
sprintItems[i].BusinessPriority = sprintItems[i - 1].BusinessPriority;
UpdateBacklogItem(sprintItems[i].BacklogItemUId, sprintItems[i], project);
changedItems.Add(sprintItems[i]);
}
// update item priority
item.BusinessPriority = itemPriority;
item.SprintNumber = targetItem.SprintNumber;
UpdateBacklogItem(item.BacklogItemUId, item, project);
}
return changedItems.ToArray();
}
private void SetItemGroupAndSize(BacklogItem item)
{
// find out the size of the new item
if (ItemSizeListViewModel.PlanningSize == null)
throw new Exception("Size list was not loaded yet");
ItemSize size = null;
if (item.OccurrenceConstraint == (int)ItemOccurrenceContraints.DEVELOPMENT_OCC) {
if (GroupList.SelectedGroup != null)
item.Group = GroupList.SelectedGroup;
else
item.Group = GroupList.DevelopmentGroup;
}
if (item.OccurrenceConstraint == (int)ItemOccurrenceContraints.PLANNING_OCC) {
size = ItemSizeListViewModel.PlanningSize.ItemSize;
item.Group = GroupList.PlanGroup;
}
if (item.OccurrenceConstraint == (int)ItemOccurrenceContraints.DELIVERY_OCC) {
size = ItemSizeListViewModel.DeliverySize.ItemSize;
item.Group = GroupList.DeliveryGroup;
}
// SINGLE SIZE MODE
if (size==null) {
size = ItemSizeListViewModel.SingleSize.ItemSize;
}
if (size != null) {
item.Size = size.Size * item.SizeFactor;
item.ItemSizeUId = size.ItemSizeUId;
}
item.GroupUId = item.Group.GroupUId;
}
private BacklogItem PrepareDefaultItem(Project project, string name, string groupName, int sprintNumber, DefaultItemGroups defaultGroup, ItemOccurrenceContraints constraint)
{
// create the new item
BacklogItem item = new BacklogItem {
BacklogItemUId = Guid.NewGuid().ToString(),
ProjectUId = project.ProjectUId,
Name = name,
Description = null,
Status = (short)BacklogItemStatus.ITEM_REQUIRED,
BusinessPriority = 1,
OccurrenceConstraint = (short)constraint,
SizeFactor = 0,
CreateDate = DateTime.Now
};
item.Project = project;
item.SyncPlannedHoursAndRoles(sprintNumber);
// assign group
ICollection<BacklogItemGroup> groups = GetBacklogItemGroups(project.ProjectUId);
var group = groups.FirstOrDefault(g => g.DefaultGroup == (short)defaultGroup);
if (group == null)
group = CreateDefaultGroup(project.ProjectUId, defaultGroup, groupName);
item.Group = group;
item.GroupUId = group.GroupUId;
// assign size
ItemSize size = backlogRepository.GetItemSizeByConstraint((short)constraint);
if (size != null) {
item.ItemSizeUId = size.ItemSizeUId;
item.SizeFactor = 1;
item.Size = size.Size * item.SizeFactor;
}
return item;
}
private void ShowDetailWindow(BacklogItem item)
{
itemDetail.ShowDetail(projectContainer.Value, item);
}
private void VerifyPermissionForCreateEditItem(BacklogItem item, Project project = null)
{
PermissionSets[] permissions = new PermissionSets[] { PermissionSets.SCRUM_MASTER, PermissionSets.PRODUCT_OWNER };
if (project == null)
project = projectsService.GetProject(item.ProjectUId);
if (project.IsTicketProject)
permissions = new PermissionSets[] { PermissionSets.SCRUM_MASTER, PermissionSets.PRODUCT_OWNER, PermissionSets.TEAM };
authorizationService.VerifyPermissionAtProject(item.ProjectUId, permissions);
if (!project.IsTicketProject && !authorizationService.IsProjectScrumMaster(item.ProjectUId) && item.SprintNumber != null)
throw new WebFaultException<String>("Product owners can not plan items", System.Net.HttpStatusCode.BadRequest);
}
public void UpdateChangedItems(BacklogItem[] changedItems)
{
if (changedItems == null || Items==null)
return;
foreach (BacklogItem changedItem in changedItems) {
BacklogItemViewModel itemVM = Items.SingleOrDefault(b => b.Item.BacklogItemUId == changedItem.BacklogItemUId);
if (itemVM != null) {
itemVM.Item.SprintNumber = changedItem.SprintNumber;
itemVM.Item.BusinessPriority = changedItem.BusinessPriority;
itemVM.Item.Status = changedItem.Status;
if (changedItem.ArtifactCount != null)
itemVM.Item.ArtifactCount = changedItem.ArtifactCount;
//itemVM.IgnoreChangeCommands = true;
//itemVM.RefreshUI();
//itemVM.IgnoreChangeCommands = false;
}
}
if (changedItems.Length == 1) {
BacklogItemViewModel firstItem = Items.SingleOrDefault(b => b.Item.BacklogItemUId == changedItems[0].BacklogItemUId);
((IEditableCollectionView)backlogViewSource.View).EditItem(firstItem);
((IEditableCollectionView)backlogViewSource.View).CommitEdit();
}
else
backlogViewSource.View.Refresh();
OnPropertyChanged("ItemsLeftTotalHours");
OnPropertyChanged("ItemsLeftTotalSize");
OnPropertyChanged("RequiredVelocity");
}
private void CloseItem(BacklogItem item)
{
executor.StartBackgroundTask(() => {
backlogService.ChangeBacklogItemStatus(item.BacklogItemUId, (short) BacklogItemStatus.ITEM_DONE);
},
() => {
((IEditableCollectionView)backlogViewSource.View).EditItem(item);
item.Status = (short)BacklogItemStatus.ITEM_DONE;
((IEditableCollectionView)backlogViewSource.View).CommitEdit();
aggregator.Publish<BacklogItem[]>(ScrumFactoryEvent.BacklogItemsChanged, new BacklogItem[] { item });
});
}
/// <summary>
/// Creates the new backlog item and saves it.
/// </summary>
private void CreateNewBacklogItem(BacklogItem newItem)
{
// save its
executor.StartBackgroundTask(
() => { backlogService.AddBacklogItem(newItem); },
() => {
NewItemName = String.Empty;
BacklogItemViewModel vm = new BacklogItemViewModel();
vm.Init(backlogService, executor, aggregator, authorizator, Project, newItem);
// TO THIS STRANGE CHECK 'CUZ WHEN LIST IS EMPTY COMMITNEW THROWS STRANGE EXCEPTION
if (FilteredBacklog.IsEmpty || Items.Count == 0) {
Items.Add(vm);
backlogViewSource.View.Refresh();
}
else {
((System.Windows.Data.ListCollectionView)backlogViewSource.View).AddNewItem(vm);
((System.Windows.Data.ListCollectionView)backlogViewSource.View).CommitNew();
}
vm.NotifyAdded();
aggregator.Publish<BacklogItem[]>(ScrumFactoryEvent.BacklogItemsChanged, new BacklogItem[] { newItem });
});
}
