public override string ToString() { string effortString = "{0} "; string burnPartString = string.Empty; bool needSpace = false; if (Effort > 0) { effortString += "({" + "1" + "})"; if (DevEffort > 0) { burnPartString = "Dev:" + DevEffort.ToString(); needSpace = true; } if (QAEffort > 0) { if (needSpace) { burnPartString += " "; } burnPartString += "QA:" + QAEffort.ToString(); needSpace = true; } if (TWEffort > 0) { if (needSpace) { burnPartString += " "; } burnPartString += "TW:" + TWEffort.ToString(); } } return(string.Format(effortString, Effort.ToString(), burnPartString)); }
/// <summary> /// Finds Effort By Id /// </summary> /// <param name="id">Injected <see cref="int"/></param> /// <returns>Instance of <see cref="Task{Effort}"/></returns> public async Task <Effort> FindEffortById(int @id) { Effort @effort = await Context.Effort .TagWith("FindEffortById") .FirstOrDefaultAsync(x => x.Id == @id); if (@effort == null) { // Log string @logData = @effort.GetType().Name + " with Id " + @id + " was not found at " + DateTime.Now.ToShortTimeString(); Logger.WriteGetItemNotFoundLog(@logData); throw new Exception(@effort.GetType().Name + " with Id " + @id + " does not exist"); } return(@effort); }
/// <summary> /// De Activates Stop /// </summary> /// <param name="viewmodel">Injected <see cref="AddEffort"/></param> /// <returns>Instance of <see cref="Task"/></returns> public async Task DeActivateStop(AddEffort @viewmodel) { Effort @effort = await this.FindFormerDayActiveEffortByApplicationUserId(@viewmodel.ApplicationUserId); if (@effort != null) { if (@effort.Kind.Id.Equals((int)EffortKinds.Stop)) { @effort.Active = false; @effort.Finish = DateTime.Now; Context.Effort.Update(@effort); // Log string @logData = @effort.GetType().Name + " with Id " + @effort.Id + " was updated at " + DateTime.Now.ToShortTimeString(); Logger.WriteUpdateItemLog(@logData); } else { throw new Exception(@effort.GetType().Name + " with Id " + @effort.Id + " can not be stopped"); } } }
public HttpResponseMessage insertNewTask([FromBody] Effort effort) { try { using (var unitOfWork = new UnitOfWork(new FoolStaffContext())) { Effort oEffort = new Effort(); oEffort.Titolo = effort.Titolo; oEffort.Descrizione = effort.Descrizione; oEffort.Priorita = effort.Priorita; oEffort.DataCreazione = UtilDate.CurrentTimeMillis(); oEffort.Stato = "OPEN"; unitOfWork.Efforts.Add(oEffort); unitOfWork.Complete(); var entity = unitOfWork.Efforts.Find(t => t.Stato == "OPEN").OrderByDescending(t => t.Priorita).ToList(); log.Debug("insertNewTask - task inserito correttamente"); return(Request.CreateResponse(HttpStatusCode.OK, entity)); } } catch (Exception ex) { log.Error("insertNewTask - errore nell'inserimento del task ", ex); return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex)); } }
public static bool EffortEdit(Effort effort) { bool ret = true; User curUser = Viola.Models.User.GetCurrentUser(); // company kontrolü if (effort.CompanyId != curUser.CompanyId) { ret = false; } // kullanıcı eforunu sadece yetkisi olduğu tasklara girebilir if (!Task.GetTasksByRole().Where(x => x.Id == effort.TaskId).Any()) { ret = false; } // kullanıcılar sadece yetkileri olduğu kişilerin eforlarını düzenleyebilir // admin: herkesi // user: sadece kendisini if (!Viola.Models.User.GetUsersForEffort().Where(x => x.Id == effort.UserId).Any()) { ret = false; } return(ret); }
public void TestMediumEffort() { var circuit = sampleCircuit(0, 8, 0); var level = new Level(2, breakTime: 20, switchTime: 0, exerciseTime: 10); Assert.AreEqual(level.Effort(circuit), Effort.FromRatio((double)160 / 200)); }
public HttpResponseMessage giveUpTask(string userId, [FromBody] int idEffort) { try { using (var unitOfWork = new UnitOfWork(new FoolStaffContext())) { User entityUser = unitOfWork.Users.Search(u => u.Id == userId).SingleOrDefault(); Effort entityTask = unitOfWork.Efforts.Search(t => t.Id == idEffort).Include(c => c.Users).SingleOrDefault(); if (entityTask.Users.Contains(entityUser)) { entityTask.Users.Remove(entityUser); unitOfWork.Complete(); } var entity = unitOfWork.Efforts.Find(t => t.Stato == "OPEN").OrderByDescending(t => t.Priorita).ToList(); log.Debug("giveUpTask - rinuncia al task da parte dell'utente id [" + entityUser.Id + "] avvenuta con successo"); return(Request.CreateResponse(HttpStatusCode.OK, entity)); } } catch (Exception ex) { log.Error("giveUpTask - errore nella rinuncia al task ", ex); return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex)); } }
public void UpdateDisplay(Effort effort) { text.text = ""; foreach (Effort.EffortType type in System.Enum.GetValues(typeof(Effort.EffortType))) { text.text += type + ": " + effort.GetEffort(type) + " / " + effort.GetMaxEffort(type) + "\n"; } }
public void TestGetEffort() { Effort effort = Instance.Get.EffortByID(AssetID.FromToken("Actual:1448")); Assert.IsNotNull(effort); Assert.AreEqual(4, effort.Value); Assert.AreEqual("Boris Tester", effort.Member.Name); }
public async Task <IActionResult> UpdateEffort(Guid Id, Effort effort) { effort.Id = Id; return(Ok(await Mediator.Send(new Edit.Command { Effort = effort }))); }
public void CreateEffort(Effort cmd) { if (cmd == null) { throw new ArgumentNullException(nameof(cmd)); } _access.Efforts.Add(cmd); }
private Task(string title, Guid teamId, Priority priority, Effort effort) : base(title, teamId, priority) { if (effort == null) { throw new DomainException(nameof(Effort), "Effort cannot be empty"); } State = WorkItemState.New; StateReason = StateReason.New; Effort = effort; }
public Effort Create(Effort effort) { var req = _contextProvider.Requirements.Find(effort.RequirementId); if (req == null) throw new NotFoundException("Requirement not found."); var user = _contextProvider.Users.Find(effort.UserId); if(user == null) throw new NotFoundException("User not found."); var project = _contextProvider.Projects.Find(req.ProjectId); if(project == null) throw new NotFoundException("Project not found."); if(project.UserId != effort.UserId && project.Users.All(p => p.UserId != effort.UserId)) throw new UnauthorizedAccessException("User does not have access to project."); if(project.StartDate.HasValue && project.StartDate > effort.StartDate) throw new ValidationException("Invalid start date."); if (project.EndDate.HasValue && project.EndDate < effort.EndDate) throw new ValidationException("Invalid end date."); if(effort.StartDate > DateTime.Now.Date) throw new ValidationException("Invalid start date."); if (effort.EndDate.Date > DateTime.Now.Date) throw new ValidationException("Invalid end date."); if(effort.Hours <= 0) throw new ValidationException("Hours must be greater than 0."); var startDate = effort.StartDate.DayOfYear; var endDate = effort.EndDate.DayOfYear; var dateDiff = endDate - startDate; if (dateDiff != 0 && dateDiff != 6) throw new ValidationException("Invalid date range."); if(dateDiff == 0 && effort.Hours > 24) throw new ValidationException("Hours exceed date range."); if(dateDiff == 6 && effort.Hours > 168) throw new ValidationException("Hours exceed date range."); if (effort.EffortTypeId < 0 || effort.EffortTypeId > 5) throw new ValidationException("Invalid effort type."); var newEffort = _contextProvider.Efforts.Add(effort); _contextProvider.SaveChanges(); return newEffort; }
public IActionResult AddEffort([FromBody] Effort effort) { if (effort != null && ModelState.IsValid) { this.employeeService.AddEmployeeEffort(effort); return(new ObjectResult(true)); } return(new ObjectResult(false)); }
public override int GetHashCode() { unchecked { var hashCode = Lower.GetHashCode(); hashCode = (hashCode * 397) ^ Upper.GetHashCode(); hashCode = (hashCode * 397) ^ Effort.GetHashCode(); hashCode = (hashCode * 397) ^ Velocity.GetHashCode(); return(hashCode); } }
public void EffortFactory() { Effort testEffort1 = Effort.GetNewEffort(1, 2, 3, 4); Assert.IsNotNull(testEffort1); Assert.AreEqual(testEffort1.TimeElapsed.TotalSeconds, 0); Assert.AreEqual(testEffort1.UserId, 1); Assert.AreEqual(testEffort1.ContractId, 2); Assert.AreEqual(testEffort1.PhaseId, 3); Assert.AreEqual(testEffort1.TaskId, 4); }
public async Task <Unit> Handle(AddWorkItemToSprintCommand request, CancellationToken cancellationToken) { var sprint = await _repository.GetAsync(request.SprintId); var effort = new Effort(request.OriginalEstimate, request.Remaining, request.Completed); sprint.AddWorkItem(new WorkItem(request.BugId, effort)); await _repository.UnitOfWork.SaveChangesAsync(cancellationToken); return(Unit.Value); }
public void TestLevelOptimization() { var expectedDuration = Duration.fromMinutes(30); var effort = new Effort(95); var circuit = sampleCircuit(0, 8, 0); var finder = new Scheduler(circuit, expectedDuration, effort); var level = finder.Schedule; Assert.AreEqual(Effort.FromRatio(0.95), level.Effort(circuit)); Assert.AreEqual(30, level.TotalDuration(circuit).inMinutes()); }
public ActionResult DeleteConfirmed(int id) { Effort effort = db.Efforts.Find(id); if (!EntityAuthorization.EffortDelete(effort)) { return(HttpNotFound()); } db.Efforts.Remove(effort); db.SaveChanges(); return(RedirectToAction("Index")); }
private Bug(string title, Guid teamId, Priority priority, StateReason stateReason, Priority severity, Effort effort) : base(title, teamId, priority) { if (effort == null) { throw new DomainException(nameof(Effort), "Effort cannot be empty"); } ValidateStateAndStateReason(WorkItemState.New, stateReason); State = WorkItemState.New; StateReason = stateReason; Severity = severity; Effort = effort; }
/// <summary> /// Finds Last Active Effort By Application User Id /// </summary> /// <param name="id">Injected <see cref="int"/></param> /// <returns>Instance of <see cref="Task{ViewEffort}"/></returns> public async Task <ViewEffort> FindLastActiveEffortByApplicationUserId(int @id) { Effort @effort = await Context.Effort .AsNoTracking() .AsQueryable() .TagWith("FindLastActiveEffortByApplicationUserId") .Include(x => x.ApplicationUser) .Include(x => x.Kind) .Where(x => x.ApplicationUser.Id == @id) .Where(x => x.Active) .OrderByDescending(x => x.LastModified) .FirstOrDefaultAsync(x => x.Active); return(Mapper.Map <ViewEffort>(@effort)); }
public void EffortTimeElapsed() { Effort testEffort1 = Effort.GetNewEffort(1, 2, 3, 4); Assert.IsNotNull(testEffort1); Assert.AreEqual(testEffort1.TimeElapsed.TotalSeconds, 0); Assert.IsTrue(testEffort1.StartEffort()); System.Threading.Thread.Sleep(1000); // wait for 1 second Assert.IsTrue(testEffort1.StopEffort()); Assert.IsTrue(testEffort1.TimeElapsed.TotalSeconds - 1 <= 0.002); Console.WriteLine(testEffort1.TimeElapsed.TotalSeconds); }
static void Main(string[] args) { Console.WriteLine("Estimating ..."); var parsedTime = int.TryParse(args[0], out int result); var parsedIncrement = Enum.TryParse(args[1], true, out TimeIncrement timeIncrement); if (!parsedTime || !parsedIncrement) { Console.WriteLine("I was unable to parse your command."); Console.WriteLine("Please format your args accordingly estimate {1} {days, weeks, months}"); return; } var effort = Effort.Create(timeIncrement, result); Console.WriteLine($"Your Tshirt Size Estimate is: {effort.TshirtSize.TshirtSizeEnum.ToString()} (days: {effort.Days}, weeks: {effort.Weeks}, months: {effort.Months}"); }
/// <summary> /// De Activates Resume /// </summary> /// <param name="viewmodel">Injected <see cref="AddEffort"/></param> /// <returns>Instance of <see cref="Task"/></returns> public async Task DeActivateResume(AddEffort @viewmodel) { Effort @effort = await FindCurrentDayActiveEffortByApplicationUserId(@viewmodel.ApplicationUserId); if (@effort != null) { if (@effort.Kind.Id.Equals((int)EffortKinds.Resume) || @effort.Kind.Id.Equals((int)EffortKinds.Start)) { effort.ApplicationUser = await FindApplicationUserById(@viewmodel.ApplicationUserId); @effort.Active = false; @effort.Finish = DateTime.Now; Context.Effort.Update(@effort); // Log string @logData = @effort.GetType().Name + " with Id " + @effort.Id + " was updated at " + DateTime.Now.ToShortTimeString(); Logger.WriteUpdateItemLog(@logData); } else { throw new Exception(@effort.GetType().Name + " with Id " + @effort.Id + " can not be stoppped"); } } else { // Log string @logData = @effort.GetType().Name + " for Application User" + viewmodel.ApplicationUserId + " was not found at " + DateTime.Now.ToShortTimeString(); Logger.WriteGetItemNotFoundLog(@logData); throw new Exception(@effort.GetType().Name + " was not started"); } }
/// <summary> /// Save time sheet in to db /// </summary> public ResulDTO SaveTimeSheet(EmployeeTimeSheetDTO timeSheetDto) { ResulDTO result = new ResulDTO(); try { foreach (var day in timeSheetDto.TimeSheets) { foreach (var effort in day.EffortLogs) { Effort dbEffort = db.Efforts.FirstOrDefault(f => f.EmployeeId == timeSheetDto.EmployeeId && f.Date == day.Date && f.TaskId == effort.TaskId); if (dbEffort != null) { dbEffort.EffortInHrs = effort.EffortInHrs; db.Efforts.Update(dbEffort); } else { dbEffort = new Effort { EmployeeId = timeSheetDto.EmployeeId, Date = day.Date, TaskId = effort.TaskId, EffortInHrs = effort.EffortInHrs }; db.Efforts.Add(dbEffort); } } } db.SaveChanges(); result.Success = true; } catch (Exception ex) { System.Diagnostics.Trace.WriteLine(ex.ToString()); result.ErrorMsg = "Something went wrong !!, Please try again."; } return(result); }
/// <summary> /// Stops /// </summary> /// <param name="viewmodel">Injected <see cref="AddEffort"/></param> /// <returns>Instance of <see cref="Task{ViewEffort}"/></returns> public async Task <ViewEffort> Stop(AddEffort @viewmodel) { await DeActivateResume(@viewmodel); Effort @effort = await AddStopEffort(@viewmodel); await Context.SaveChangesAsync(); // Log string @logData = @effort.GetType().Name + " with Id " + @effort.Id + " was added at " + DateTime.Now.ToShortTimeString(); Logger.WriteInsertItemLog(@logData); return(Mapper.Map <ViewEffort>(@effort)); }
public Task <Guid> Handle(CreateBugCommand request, CancellationToken cancellationToken) { var effort = new Effort(request.OriginalEstimate, request.Remaining, request.Completed); var builder = new Bug.BugBuilder(request.Title, request.TeamId, effort, (Priority)request.PriorityId, (StateReason)request.StateReasonId, (Priority)request.SeverityId); builder.SetWorkItemOptionalFields(request.Description, request.AssignedTo, request.SprintId, String.IsNullOrWhiteSpace(request.RepoLink) ? null : new Link(request.RepoLink)); builder.SetBugOptionalFields(request.IntegratedInBuild, request.StoryPoints, request.SystemInfo, request.FoundInBuild); var now = _dateTime.UtcNow; foreach (var dto in request.RelatedWorks) { builder.AddRelatedWork(dto.ToRelatedWork()); } foreach (var dto in request.Attachments) { builder.AddAttachment(dto.ToAttachment(_mimeTypeMapper.GetMimeType(dto.FileName), now)); } foreach (var tag in request.Tags) { builder.AddTag(new Tag(tag)); } var bug = builder.BuildWorkItem(); _uow.BugRepository.Insert(bug); if (request.SprintId.HasValue) { _workItemIntegrationEventService.AddAndSaveEventAsync( new BugCreatedIntegrationEvent(bug.Id, request.OriginalEstimate, request.Remaining, request.Completed, request.SprintId.Value)); } return(Task.FromResult(bug.Id)); }
public static bool EffortDelete(Effort effort) { bool ret = true; User curUser = Viola.Models.User.GetCurrentUser(); // company kontrolü if (effort.CompanyId != curUser.CompanyId) { ret = false; } // kullanıcılar sadece yetkileri olduğu kişilerin eforlarını silebilir // admin: herkesi // user: sadece kendisini if (!Viola.Models.User.GetUsersForEffort().Where(x => x.Id == effort.UserId).Any()) { ret = false; } return(ret); }
// GET: Efforts/Delete/5 public ActionResult Delete(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } Effort effort = db.Efforts.Find(id); if (effort == null) { return(HttpNotFound()); } if (!EntityAuthorization.EffortDelete(effort)) { return(HttpNotFound()); } return(View(effort)); }
private Effort CalculateMaxEffort([NotNull] EffortPropertySchemaManager schemaManager) { Effort result = Effort.Undefined; var model = _mitigation.Model; var propertyType = schemaManager.GetPropertyType(); if (model != null && propertyType != null) { CalculateMaxEffort(model, propertyType); var entities = model.Entities?.ToArray(); if (entities?.Any() ?? false) { foreach (var entity in entities) { var effort = CalculateMaxEffort(entity, propertyType); if (effort > result) { result = effort; } } } var flows = model.DataFlows?.ToArray(); if (flows?.Any() ?? false) { foreach (var flow in flows) { var effort = CalculateMaxEffort(flow, propertyType); if (effort > result) { result = effort; } } } } return(result); }
public HttpResponseMessage addUserToTask(string userId, [FromBody] int idEffort) { try { using (var unitOfWork = new UnitOfWork(new FoolStaffContext())) { User user = unitOfWork.Users.Search(u => u.Id == userId).Include(e => e.Efforts).FirstOrDefault(); Effort entityEffort = unitOfWork.Efforts.SingleOrDefault(t => t.Id == idEffort); user.Efforts.Add(entityEffort); unitOfWork.Complete(); var entity = unitOfWork.Efforts.Search(t => t.Stato == "OPEN").Include(c => c.Users).OrderByDescending(t => t.Priorita).ToList(); log.Debug("addUserToTask - utente id [" + unitOfWork.Users.SingleOrDefault(u => u.Id == userId).Id + "] correttamente associato al task"); return(Request.CreateResponse(HttpStatusCode.OK, entity)); } } catch (Exception ex) { log.Error("addUserToTask - errore nell'associazione dell'utente al task ", ex); return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex)); } }
public Scheduler(Circuit circuit, Duration duration, Effort effort) { candidateLevels = new List<Level>(); BuildCandidates(); schedule = candidateLevels[0]; this.circuit = circuit; this.duration = duration; this.effort = effort; }
public void Easier() { effort = effort.PreviousLevel(); }
public void Harder() { effort = effort.NextLevel(); }
public void ShouldBeComparable() { var effort1 = new Effort(50); var effort2 = new Effort(51); var effort3 = new Effort(50); Assert.AreEqual(effort1, effort1); Assert.AreEqual(effort1, effort3); Assert.AreNotEqual(effort1, effort2); }
public void NormalizedValueShouldBeAvailable() { var effort = new Effort(75); Assert.AreEqual(0.75D, effort.Normalized()); }
public void ShouldBeAvailableAsPercentage() { const int PERCENTAGE = 75; var effort = new Effort(PERCENTAGE); Assert.AreEqual(PERCENTAGE, effort.AsPercentage()); }
public void ShouldRejectValueAbove100() { var effort = new Effort(140); }
public void ShouldRejectNegativeValue() { var effort = new Effort(-34); }
public void ShouldBeSetByDefault() { var effort = new Effort(); Assert.IsTrue(effort.IsDefault()); }
public void ShouldBeIncrementable() { var effort = new Effort(75); var newEffort = effort.NextLevel(); Assert.IsTrue(newEffort.IsHarderThan(effort)); }
public void ShouldBeDecrementable() { var effort = new Effort(75); var newEffort = effort.PreviousLevel(); Assert.IsTrue(effort.IsHarderThan(newEffort)); }