// [[1, 250, 'Unscheduled'], [2, 54, 'Sprint 1'], [3, 20, 'Sprint Banana'], [4, 0, 'Sprint Cross Reference'], [5, 8, 'Sprint Sammy']]
private List <object> CreateTaskHoursPerSprintJsonList(Product product, int currentSprintId)
{
List <object> taskHoursPerSprintJsonList = new List <object>();
ScrumTimeEntities scrumTimeEntities = new ScrumTimeEntities();
TaskService taskService = new TaskService(scrumTimeEntities);
decimal unassignedTaskHours = taskService.GetUnassignedTaskHours(product.ProductId);
CheckSetYAxisMax(unassignedTaskHours);
List <object> unassignedHoursList = new List <object>();
unassignedHoursList.Add(1);
unassignedHoursList.Add(unassignedTaskHours);
unassignedHoursList.Add("Unassigned");
taskHoursPerSprintJsonList.Add(unassignedHoursList);
Ticks.Add(" ");
SprintService sprintService = new SprintService(scrumTimeEntities);
List <Sprint> mostRecentSprints = sprintService.GetMostRecentSprints(product.ProductId, currentSprintId, 4);
int index = 2;
foreach (Sprint recentSprint in mostRecentSprints)
{
List <object> sprintHoursList = new List <object>();
sprintHoursList.Add(index);
sprintHoursList.Add(CalculateHoursForSprint(recentSprint));
sprintHoursList.Add(recentSprint.Name);
taskHoursPerSprintJsonList.Add(sprintHoursList);
Ticks.Add(" ");
index++;
}
return(taskHoursPerSprintJsonList);
}
public ActionResult Index()
{
DashboardViewModel dashboardVM = new DashboardViewModel();
SprintService sprintService = new SprintService();
dashboardVM.Sprint = sprintService.RetornaUltimoSprint();
dashboardVM.Eventos = db.Eventos.Where(c => c.SprintId == dashboardVM.Sprint.Id || c.Fixo == "S").ToList();
int dias = dashboardVM.Sprint.DataFim.Subtract(dashboardVM.Sprint.DataInicio).Days;
for (int i = 0; i < dias; i++)
{
dashboardVM.DiasSprint.Add(dashboardVM.Sprint.DataInicio.AddDays(i));
}
foreach (var dashboardVmEvento in dashboardVM.Eventos)
{
DateTime dataFinal = dashboardVM.Sprint.DataFim;
int tmSpanTotal = dashboardVM.Sprint.DataFim.Subtract(dashboardVM.Sprint.DataInicio).Days;
int tmSpan = tmSpanTotal - (dashboardVM.Sprint.DataFim.Subtract(dashboardVmEvento.DataEvento).Days);
dashboardVmEvento.PorcentagemSprint = Convert.ToInt32(((double)tmSpan / (double)tmSpanTotal) * 100);
}
return(View(dashboardVM));
}
public static void CreateFirstTimeDefaults(string username)
{
ScrumTimeEntities scrumTimeEntities = new ScrumTimeEntities();
UserSetting userSetting = UserSettingService.GetUserSettingByUsername(scrumTimeEntities, username);
if (userSetting == null)
{
// Load sample product id
ProductService productService = new ProductService(scrumTimeEntities);
int productIdOfSample = productService.GetProductIdOfSample();
if (productIdOfSample > -1)
{
SprintService sprintService = new SprintService(scrumTimeEntities);
List <Sprint> mostRecentSprints = sprintService.GetMostRecentSprints(productIdOfSample, -1, 1);
if (mostRecentSprints.Count > 0 && mostRecentSprints[0] != null)
{
userSetting = new UserSetting()
{
CurrentProduct = productIdOfSample,
CurrentSprint = mostRecentSprints[0].SprintId,
LastMainTabSelected = 1,
Username = username
};
scrumTimeEntities.AddToUserSettings(userSetting);
scrumTimeEntities.SaveChanges(System.Data.Objects.SaveOptions.AcceptAllChangesAfterSave);
}
}
}
}
public ActionResult CurrentReadOnly()
{
SprintService sprintService = new SprintService(_ScrumTimeEntities);
Sprint sprint = sprintService.GetSprintById(SessionHelper.GetCurrentSprintId(User.Identity.Name, Session));
return(PartialView(sprint));
}
public ActionResult Index()
{
ScrumTimeEntities scrumTimeEntities = new ScrumTimeEntities();
string currentProductName = "None";
string currentSprintName = "None";
string nextReleaseName = "None";
ProductService productService = new ProductService(scrumTimeEntities);
Product product = productService.GetProductById(SessionHelper.GetCurrentProductId(User.Identity.Name, Session));
if (product != null && product.ProductId > 0)
{
currentProductName = product.Name;
SprintService sprintService = new SprintService(scrumTimeEntities);
Sprint sprint = sprintService.GetSprintById(SessionHelper.GetCurrentSprintId(User.Identity.Name, Session));
if (sprint != null && sprint.SprintId > 0)
{
currentSprintName = sprint.Name;
ReleaseService releaseService = new ReleaseService(scrumTimeEntities);
Release nextRelease = releaseService.GetNextReleaseEqOrAfterDate(sprint.ProductId, sprint.FinishDate);
if (nextRelease != null && nextRelease.ReleaseId > 0)
{
nextReleaseName = nextRelease.Name;
}
}
}
DashboardViewModel dashboardViewModel = new DashboardViewModel()
{
CurrentProductName = currentProductName,
CurrentSprintName = currentSprintName,
NextReleaseName = nextReleaseName
};
return(PartialView(dashboardViewModel));
}
// GET: Eventoes
public ActionResult Index()
{
SprintService sprintService = new SprintService();
Sprint sprintAtual = sprintService.RetornaUltimoSprint();
return(View(db.Eventos.Where(c => c.SprintId == sprintAtual.Id || c.Fixo == "S").OrderBy(c => c.DataEvento).ToList()));
}
public JsonSprintBurnDown(int sprintId)
: base()
{
Data = new List <object>();
YAxisMin = 0;
if (sprintId >= 0)
{
ScrumTimeEntities scrumTimeEntities = new ScrumTimeEntities();
SprintService sprintService = new SprintService(scrumTimeEntities);
Sprint sprint = sprintService.GetSprintById(sprintId);
if (sprint != null && sprint.Scrums.Count() > 0)
{
Data.Add(CreateIdealScrumTaskJsonList(sprint));
Data.Add(CreateScrumTaskJsonList(sprint));
XAxisMinDate = sprint.StartDate.ToString("MM/dd/yyyy");
XAxisMaxDate = sprint.FinishDate.ToString("MM/dd/yyyy");
YAxisMin = 0;
ScrumService scrumService = new ScrumService(scrumTimeEntities);
YAxisMax = scrumService.GetMaxTaskHourCountBySprintId(sprint.SprintId);
}
else
{
HandleBadSprint();
}
}
else
{
HandleBadSprint();
}
}
public BugProblemaController(DevTestesContext context, FuncionarioService funcionarioService, SprintService sprintService, ProdutoService produtoService)
{
_context = context;
_funcionarioService = funcionarioService;
_sprintService = sprintService;
_produtoService = produtoService;
}
public ActionResult New()
{
List <Sprint> allSprints = SprintService.GetAllSprints(_ScrumTimeEntities,
SessionHelper.GetCurrentProductId(User.Identity.Name, Session));
Sprint noneSprint = new Sprint()
{
Name = "None",
SprintId = -1
};
allSprints.Insert(0, noneSprint);
int currentProductId = SessionHelper.GetCurrentProductId(User.Identity.Name, Session);
Product product = _ScrumTimeEntities.Products.First <Product>(p => p.ProductId == currentProductId);
StoryViewModel storyViewModel = new StoryViewModel()
{
StoryModel = new Story()
{
StoryId = 0,
Narrative = "As a ...",
Points = 0,
Priority = 0,
UserDefinedId = (product.Stories.Count() + 1).ToString()
},
AllSprints = allSprints
};
return(PartialView("Edit", storyViewModel));
}
public static IQueryable <ISprint> GetSprintList()
{
return(SprintService.SprintFetchInfoList()
.Cast <ISprint>()
.OrderBy(row => row.ProjectName)
.ThenByDescending(row => row.EstimatedCompletedDate)
.AsQueryable());
}
public ActionResult Delete(int id)
{
var sprint = SprintService.SprintFetch(id);
SprintService.SprintDelete(id);
return(this.RedirectToAction("Edit", "Project", new { id = sprint.ProjectId }));
}
public void GetSprintsTest()
{
var mock = new Mock <IUnitOfWork>();
mock.Setup(i => i.SprintRepository.GetAll()).Returns(new List <SprintDAL>().AsQueryable());
SprintService service = new SprintService(mock.Object);
var result = service.GetAllSprints();
Assert.IsAssignableFrom <IQueryable <SprintDTO> >(result);
}
public void Sprint_service_Delete_method_should_throw_null_exception_with_empty_input_object()
{
var mockRepo = new Mock <ISprintRepository>();
mockRepo.Setup(x => x.Delete(It.IsAny <int>()));
SprintService obj = new SprintService(mockRepo.Object);
var exception = Record.Exception(() => obj.Delete(It.IsAny <int>()));
Assert.Equal(null, exception);
}
public void Sprint_service_Update_method_should_throw_nullReferenceException()
{
var mockRepo = new Mock <ISprintRepository>();
mockRepo.Setup(x => x.Update(It.IsAny <int>(), It.IsAny <UserStory>())).Throws(new NullReferenceException());
SprintService obj = new SprintService(mockRepo.Object);
var exception = Record.Exception(() => obj.Update(It.IsAny <int>(), It.IsAny <UserStory>()));
Assert.IsType <NullReferenceException>(exception);
}
public void GetSprintsWithinDateRangeTest()
{
ScrumTimeEntities scrumTimeEntities = new ScrumTimeEntities();
SprintService sprintService = new SprintService(scrumTimeEntities);
List <Sprint> sprints =
sprintService.GetSprintsWithinDateRange(1, new DateTime(2010, 1, 1),
new DateTime(2010, 6, 5));
Assert.AreEqual(5, sprints.Count());
}
public void Sprint_service_Add_method_should_throw_nullReferenceException()
{
Sprint bk = new Sprint();
var mockRepo = new Mock <ISprintRepository>();
mockRepo.Setup(x => x.Add(bk)).Throws(new NullReferenceException());
SprintService obj = new SprintService(mockRepo.Object);
var exception = Record.Exception(() => obj.Add(bk));
Assert.IsType <NullReferenceException>(exception);
}
public void CreateTest()
{
var mock = new Mock <IUnitOfWork>()
{
DefaultValue = DefaultValue.Mock
};
var newSprint = new SprintDTO();
SprintService service = new SprintService(mock.Object);
service.Create(newSprint);
mock.Verify(i => i.Save());
}
public void Sprint_service_Delete_method_should_throw_FormatException()
{
Sprint bk = new Sprint();
var mockRepo = new Mock <ISprintRepository>();
mockRepo.Setup(x => x.Delete(It.IsAny <int>())).Throws(new FormatException());
SprintService obj = new SprintService(mockRepo.Object);
var exception = Record.Exception(() => obj.Delete(It.IsAny <int>()));
Assert.IsType <FormatException>(exception);
}
public static Sprint CreateSprint()
{
var sprint = SprintService.SprintNew();
var project = BusinessHelper.CreateProject();
sprint.ProjectId = project.ProjectId;
sprint.Name = DataHelper.RandomString(20);
sprint = SprintService.SprintSave(sprint);
return(sprint);
}
public void Sprint_Add()
{
var sprint = SprintService.SprintNew();
var project = BusinessHelper.CreateProject();
sprint.ProjectId = project.ProjectId;
sprint.Name = DataHelper.RandomString(20);
Assert.IsTrue(sprint.IsValid, "IsValid should be true");
SprintService.SprintSave(sprint);
}
public void Sprint_service_Add_method_should_throw_null_exception_with_empty_input_object()
{
Sprint bk = new Sprint();
var mockRepo = new Mock <ISprintRepository>();
mockRepo.Setup(x => x.Add(bk));
SprintService obj = new SprintService(mockRepo.Object);
var exception = Record.Exception(() => obj.Add(bk));
Assert.Equal(null, exception);
}
public void Sprint_Fetch()
{
var sprint = SprintService.SprintNew();
var project = BusinessHelper.CreateProject();
sprint.ProjectId = project.ProjectId;
sprint.Name = DataHelper.RandomString(20);
sprint = SprintService.SprintSave(sprint);
sprint = SprintService.SprintFetch(sprint.SprintId);
Assert.IsFalse(sprint == null, "Sprint should not be null");
}
public ActionResult CurrentSprintName()
{
string currentSprintName = "";
int currentSprintId = SessionHelper.GetCurrentSprintId(User.Identity.Name, Session);
if (currentSprintId > 0)
{
Sprint currentSprint = SprintService.GetSprintById(_ScrumTimeEntities, currentSprintId);
if (currentSprint != null)
{
currentSprintName = currentSprint.Name;
}
}
return(new SecureJsonResult(currentSprintName));
}
public void Sprint_New()
{
Exception exception = null;
try
{
SprintService.SprintNew();
}
catch (Exception ex)
{
exception = ex;
}
Assert.IsTrue(exception == null, "Exception should be null");
}
public void Sprint_Service_Get_Method_should_return_particular_particualr_sprint()
{
//Arrange
var request = new Sprint();
request.SprintId = 1;
var mockRepoReq = new Mock <ISprintRepository>(); //mocking RequestRepository
mockRepoReq.Setup(x => x.Get(1)).Returns(request); //mocking GetAll() of RequestRepository
SprintService obj = new SprintService(mockRepoReq.Object);
//Act
var res = obj.Get(1);
//Assert
Assert.Equal(res, request);
}
public void Sprint_New()
{
Exception exception = null;
try
{
SprintService.SprintNew();
}
catch (Exception ex)
{
exception = ex;
}
Assert.IsTrue(exception != null, "Exception should not be null");
Assert.IsTrue(exception.GetBaseException() is SecurityException);
}
public ActionResult Edit(int id, SprintFormModel model)
{
var sprint = SprintService.SprintFetch(id);
Csla.Data.DataMapper.Map(model, sprint, true, "ProjectName");
sprint = SprintService.SprintSave(sprint);
if (sprint.IsValid)
{
model.Message = Resources.SaveSuccessfulMessage;
}
this.MapToModel(sprint, model, true);
return(this.View(model));
}
// GET: ScrumBoard
public ActionResult Index()
{
ScrumBoardViewModel scrumBoardViewModel = new ScrumBoardViewModel();
SprintService sprintService = new SprintService();
Sprint sprintAtual = sprintService.RetornaUltimoSprint();
List <SprintAuxiliar> sprintAuxiliars = db.SprintAuxiliar.AsNoTracking().Where(c => c.SprintId == sprintAtual.Id).ToList();
scrumBoardViewModel.Sprint = sprintAtual;
sprintAuxiliars.ForEach(historiaAux =>
{
scrumBoardViewModel.Historias.Add(db.Historias.SingleOrDefault(c => c.Id == historiaAux.HistoriaId));
});
scrumBoardViewModel.ColunasScrum = db.ScrumBoardColunas.AsNoTracking().OrderBy(c => c.Ordem).ToList();
return(View(scrumBoardViewModel));
}
public void Sprint_Service_CreateGroup_Method_should_return()
{
//Arrange
List <SignalRMaster> requests = new List <SignalRMaster>();
var request = new SignalRMaster();
request.MemberId = 1;
requests.Add(request);
var mockRepoReq = new Mock <ISprintRepository>(); //mocking RequestRepository
mockRepoReq.Setup(x => x.CreateGroup(It.IsAny <int>())).Returns(requests); //mocking GetAll() of RequestRepository
SprintService obj = new SprintService(mockRepoReq.Object);
//Act
var res = obj.CreateGroup(It.IsAny <int>());
//Assert
Assert.IsType <List <SignalRMaster> >(res);
}
public void Sprint_Service_Get_Method_should_return_sprintBacklog_type_object()
{
//Arrange
List <Sprint> requests = new List <Sprint>();
var request = new Sprint();
request.SprintId = 1;
requests.Add(request);
var mockRepoReq = new Mock <ISprintRepository>(); //mocking RequestRepository
mockRepoReq.Setup(x => x.GetAll(1)).Returns(requests); //mocking GetAll() of RequestRepository
SprintService obj = new SprintService(mockRepoReq.Object);
//Act
var res = obj.GetAll(1);
//Assert
Assert.Equal(res, requests);
}
