private WorkLogDetailsDto GetWorkLogDetails(WorkLog workLog)
{
var mapper = GetService <IModelMapper <WorkLog, WorkLogDetailsDto> >();
var model = mapper.MapToModel(workLog);
return(model);
}
private WorkLogDto GetWorkLogDto(WorkLog workLog)
{
var mapper = GetService <IBaseMapper <WorkLog, WorkLogDto> >();
var model = mapper.MapToModel(workLog);
return(model);
}
public async Task <StartLogResult> Handle(StartLogCommand request, CancellationToken cancellationToken)
{
// TODO: Throw error if null
Issue issue = await _context.Issues.FirstOrDefaultAsync(x => x.Identifier == request.Identifier, cancellationToken);
var workLog = await _context.WorkLogs.FirstOrDefaultAsync(x => x.IssueId == issue.Id && x.EndDate == null, cancellationToken);
// TODO: Check if activeWorkLog exist and throw error
if (workLog != null)
{
throw new InvalidOperationException("Stop previous time logging.");
}
WorkLog log = new WorkLog
{
IssueId = issue.Id,
StartDate = request.Start,
};
await _context.WorkLogs.AddAsync(log, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
return(new StartLogResult
{
Id = log.Id,
Start = log.StartDate,
Identifier = issue.Identifier
});
}
public async Task <IActionResult> Edit(int id, [Bind("Id,WLNumber,Type,State,DateTimeFrom,DateTimeTo,BusUnit,IncidentId,Subject,FEEntersSite,FEEExitsSite,TotalHours,WorkLogStatusId")] WorkLog workLog)
{
if (id != workLog.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(workLog);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WorkLogExists(workLog.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["IncidentId"] = new SelectList(_context.Incident, "Id", "Id", workLog.IncidentId);
ViewData["WorkLogStatusId"] = new SelectList(_context.Set <WorkLogStatus>(), "Id", "Id", workLog.WorkLogStatusId);
return(View(workLog));
}
public async Task AddWorkLog(WorkLog workLog)
{
workLog.CreatedDate = DateTime.Now;
workLog.Status = WorkLogStatus.PendingApproval;
await _context.WorkLogs.AddAsync(workLog);
}
private async Task <bool> DoWorkAsync(ProcessBase process, WorkItemBase currentItem)
{
try
{
WorkLog workLog = await process.DoWorkAsync(this._completedWorkLogs, currentItem);
// Processo executado mas retorno identifica que o resultado não obteve sucesso, Aborta o fluxo.
if (workLog.Result.Success == false)
{
this.IsAborted = true;
return(CaptureBrokenStep(process, "Cancel Step Based on result."));
}
this._doneWorkLogs.Push(workLog);
this._completedWorkLogs.Add(workLog);
// Próximo processo será executado
return(true);
}
catch (Exception e)
{
this._hasExceptionOccured = true;
return(CaptureBrokenStep(process, e.Message));
}
}
private async void InitialScreenSetup()
{
dbTransaction = DbTransaction.GetInstance();
workLog = await dbTransaction.GetLatestWorkLog();
if (workLog == null)
{
lblWorkStartTime.Text = "";
workLog = new WorkLog();
WorkStopState();
}
else
{
lblWorkStartTime.Text = workLog.StartTime?.ToString("hh:mm:ss");
WorkStartState();
}
breakLog = await dbTransaction.GetLatestBreakLog();
if (breakLog == null)
{
lblBreakStartTime.Text = "";
breakLog = new BreakLog();
BreakStopState();
}
else
{
lblBreakStartTime.Text = breakLog.StartTime?.ToString("hh:mm:ss");
BreakStartState();
}
}
public async Task AddWorkLog_OverlappingRecords_Throws()
{
var workLog1 = new WorkLog
{
Description = "sample description",
Details = "sample details",
EntryDate = DateTime.Today.Date,
StartTime = TimeSpan.Parse("9:15:00"),
EndTime = TimeSpan.Parse("15:0:0")
};
var result = await UserService.AddWorkLog(1, workLog1);
Assert.NotNull(result);
Assert.True(result.Id > 0);
Assert.Equal(1, result.UserId);
Assert.Equal(DateTime.Today.Date, result.EntryDate.Date);
Assert.Equal(TimeSpan.Parse("5:45:00"), result.EndTime - result.StartTime);
var workLog2 = new WorkLog
{
Description = "sample description 2",
Details = "sample details 2",
EntryDate = DateTime.Today.Date,
StartTime = workLog1.StartTime.Add(TimeSpan.FromMinutes(5)),
EndTime = TimeSpan.Parse("16:0:0")
};
await Assert.ThrowsAsync <InvalidOperationException>(() => UserService.AddWorkLog(1, workLog2));
}
public IHttpActionResult GetAllProjects(WorkLog wl)
{
string userId = UserRepository.GetUserId(Convert.ToString(wl.userId));
DataSet ds = WorkLogRepository.GetAllProjects(userId);
return(Ok(ds.Tables[0]));
}
public LogForm(WorkLog edit)
{
InitializeComponent();
Model = edit;
Init();
}
private void btnCargarDiferenciaEnJira_Click(object sender, EventArgs e)
{
var diff = CalcularDiferenciaHoraria();
if (MessageBox.Show($"Cargar {diff} hrs en Jira?", "Cargar en Jira", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
var jiraKey = GetJiraRow(null).Nro;//GetSelectedString(dgvHorasxJira, (int)HorasxJiraColunms.Nro);
var crearResponse = WorkLog.Crear(jiraKey, diff);
if (crearResponse.StatusCode == HttpStatusCode.Created)
{
MessageBox.Show("Creado");
var mantis = GetMantis(null);
CargarHorasxJira(mantis);
var unJira = Datos.Jiras.FirstOrDefault(j => j.NroMantis == mantis);
if (unJira != null)
{
var mantisRow = Datos.Mantis.First(m => m.Nro == mantis);
mantisRow.HrsJira = unJira.Hrs;
mantisRow.Diferencia = mantisRow.HrsMantis - mantisRow.HrsJira;
}
dgvHorasxJira.Refresh();
}
else
{
MessageBox.Show(crearResponse.ToString());
}
}
}
public async Task LoadWorkLog(int id)
{
DisableCodeHubMode();
var found = await WorkLogsService.GetWorkLogForEdit(id);
if (found.TaskId > 0 && found.ProviderType == StaticWorkProviderTypes.DevOps || found.ProviderType == StaticWorkProviderTypes.Zammad)
{
SelectedTask = WorkItems.FirstOrDefault(s => s.Id == found.TaskId);
}
else if (found.Id > 0 && found.ProviderType == StaticWorkProviderTypes.CodeHub)
{
await EnableCodeHubMode();
if (found.Epic != null)
{
await OrganizationChanged(found.Epic.Project.OrganizationId);
ProjectChanged(found.Epic.ProjectId);
}
}
Entity = found;
WorkedDateHelper = DateTimeHelpers.GetFormattedTime(Entity.Hours);
StateHasChanged();
}
public async Task SubmitForm()
{
InvalidHours = false;
ExceptionMessage = "";
try
{
Entity.Hours = DateTimeHelpers.GetHoursFromString(WorkedDateHelper, true);
try
{
Entity.ProviderType = CodeHubMode ? StaticWorkProviderTypes.CodeHub : SelectedTask.ProviderType;
Entity.OrganizationId = CodeHubMode ? SelectedOrganization.Id : SelectedTask.OrganizationId;
Entity.TaskId = CodeHubMode ? 0 : SelectedTask.Id; // TODO CodeHub Tasks
Entity = await WorkLogsService.CreateOrEditWorkLog(Entity);
Done();
}
catch (Exception e)
{
ExceptionMessage = e.Message;
}
}
catch
{
InvalidHours = true;
Entity.Hours = 0;
}
StateHasChanged();
}
private async Task Init()
{
if (string.IsNullOrEmpty(fooID) == true)
{
工作日報表項目 = new 工作日報表項目ViewModel();
}
else
{
工作日報表Model = await WorkLogTable.LookupAsync(fooID);
if (工作日報表Model == null)
{
工作日報表項目 = new 工作日報表項目ViewModel();
}
else
{
工作日報表項目 = new 工作日報表項目ViewModel
{
ID = 工作日報表Model.Id,
專案名稱 = 工作日報表Model.專案名稱,
工作內容 = 工作日報表Model.工作內容,
日期 = 工作日報表Model.日期,
是否顯示日期區塊 = true,
當日累計工時 = 0,
處理時間 = 工作日報表Model.處理時間,
};
}
}
}
public async Task <IActionResult> PutWorkLog([FromRoute] string id, [FromBody] WorkLog workLog)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != workLog.Id)
{
return(BadRequest());
}
db.Entry(workLog).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WorkLogExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
private void WorkLogEditControl_DataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
{
CurrentWorkLog = this.DataContext as WorkLog;
ObservableCollection <WorkLogStuff> stuffsource = new ObservableCollection <WorkLogStuff>(GetWorkLogStuffs(CurrentWorkLog.Key));
this.listBoxLogStuff.ItemsSource = stuffsource;
}
public void UpdateState()
{
Tabs.Visibility = Extension.State == GlobalState.Operational
? Visibility.Visible
: Visibility.Hidden;
Error.Visibility = Extension.State != GlobalState.Operational
? Visibility.Visible
: Visibility.Hidden;
switch (Extension.State)
{
case GlobalState.NoSolutionOpen:
Error.Content = Strings.Error_NoSolution;
break;
case GlobalState.NoConfigFile:
Error.Content = Strings.Error_ConfigNotFound;
break;
case GlobalState.Operational:
WorkLog.RefreshView();
MyTickets.RefreshView();
break;
}
DisplayScmIcon();
}
public ActionResult Create(CreateVM model)
{
if (HttpContext.Session.GetObjectFromJson <LoggedUser>("loggedUser") == null)
{
return(RedirectToAction("Login", "Home"));
}
if (!ModelState.IsValid)
{
return(View(model));
}
WorkLog item = new WorkLog
{
TaskId = model.TaskId,
UserId = model.UserId,
CreateDate = model.Date,
Hours = model.Hours
};
using ToDoManagerContext context = new ToDoManagerContext();
context.WorkLogs.Add(item);
context.SaveChanges();
return(RedirectToAction("Index", "WorkLog", new { taskId = model.TaskId }));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,CardId,Date,HoursWorked")] WorkLog workLog)
{
if (id != workLog.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(workLog);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WorkLogExists(workLog.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["CardId"] = new SelectList(_context.Card.Include(x => x.Worker).Select(x => new KeyValuePair <int, string>(x.Id, x.Worker.Name)), "Key", "Value", workLog.CardId);
return(View(workLog));
}
public async Task <WorkLog> CreateOrEditWorkLog(WorkLog workLog)
{
workLog.DateFinished = workLog.DateStarted;
if (workLog.ProviderType == StaticWorkProviderTypes.CodeHub)
{
if (workLog.EpicId.HasValue && workLog.EpicId != 0) // Handle CodeHub Item
{
workLog.Epic = await _context.Epics.FirstOrDefaultAsync(s => s.Id == workLog.EpicId);
}
if (workLog.Epic == null)
{
throw new Exception($"Epic not found!");
}
}
else if (workLog.ProviderType == StaticWorkProviderTypes.DevOps || workLog.ProviderType == StaticWorkProviderTypes.Zammad)
{
if (workLog.OrganizationId == 0 || workLog.TaskId == 0)
{
throw new Exception($"If epic is not set, you must provide Provider Type, OrganizationId and TaskId");
}
// Make sure this is not set, or remove it if set
workLog.Epic = null;
workLog.EpicId = null;
}
else
{
throw new Exception($"Unsupported Work Provider!");
}
return((workLog.Id == 0) ? await CreateWorkLog(workLog) : await UpdateWorkLog(workLog));
}
public void SetUp()
{
_shimsContext = ShimsContext.Create();
_testEntity = new WorkLog();
_privateObject = new PrivateObject(_testEntity);
ShimSPContext.CurrentGet = () => new ShimSPContext()
{
SiteGet = () => new ShimSPSite()
{
IDGet = () => DummySiteId
},
WebGet = () => new ShimSPWeb()
{
CurrentUserGet = () => new ShimSPUser()
{
NameGet = () => DummyUserName,
LoginNameGet = () => DummyUserLoginName
}
}
};
ShimDateTime.NowGet = () => DummyDateTimeNow;
InitializeUiControls();
}
private bool IsDuplicate(WorkLog workLog, CreateWorkLogRequest request)
{
return(workLog.Timestamp == request.TimeStamp &&
workLog.Length == request.Length &&
workLog.WorkItemId == request.WorkItemId &&
workLog.ActivityType.Id == request.ActivityTypeId &&
workLog.Comment == request.Comment);
}
private void AssertWorkLog(WorkLog workLog, WorkLog workLog2)
{
Assert.AreEqual(workLog.Id, workLog2.Id);
Assert.AreEqual(workLog.Description, workLog2.Description);
Assert.AreEqual(0, DbTestUtils.DiffInSeconds(workLog.Date, workLog2.Date));
Assert.AreEqual(0, DbTestUtils.DiffInSeconds(workLog.Timestamp, workLog2.Timestamp));
}
//TODO: add date on the worklog
public ActionResult WorkLog()
{
WorkLog model = new WorkLog();
model.Project = new Project();
return(View(model));
}
private void workloglistcontrol_OnMouseDoubleClick(WorkLog obj)
{
WorkLogEditDialog logedit = new WorkLogEditDialog();
logedit.DataContext = obj;
logedit.UpdateWorkLog += () => { QueryWorkLog(queryCondition); };
logedit.ShowDialog();
}
public override async Task <bool> CompensateAsync(WorkLog item, IRoutingSlip routingSlip)
{
Guid tokenId = item.Result.WorkId;
Guid cancelId = await PostCompensationEndpointAddress <Guid>();
Console.WriteLine("Compensate token {0} - confirmation Id: {1}.", tokenId, cancelId);
return(true);
}
public frmWorklogSetup(WorkLog workLog)
{
InitializeComponent();
lstEmployees = Global.GetEmployees();
cbEmployee.DataSource = lstEmployees;
cbEmployee.DisplayMember = "FirstName";
cbEmployee.ValueMember = "Id";
_WorkLog = workLog;
}
public RebuildFromLogsTest(WorkLog work)
{
if (!InstanceFieldsInitialized)
{
InitializeInstanceFields();
InstanceFieldsInitialized = true;
}
this._work = work.Transactions();
}
public LogForm(DateTime date)
{
InitializeComponent();
Model = new WorkLog {
Date = date
};
Init();
}
public async Task <WorkLog> AddWorkLog(int userId, WorkLog workLog)
{
if (workLog == null)
{
throw new ArgumentNullException(nameof(workLog));
}
var validationResult = _workLogValidator.Validate(workLog);
if (!validationResult.IsValid)
{
throw new WorkLogModelValidationException(validationResult
.Errors.Select(e => e.ErrorMessage).ToArray());
}
var user = await _dbContext.UserSet
.Include(u => u.WorkLog)
.SingleOrDefaultAsync(s => s.IsActive && s.Id == userId)
.ConfigureAwait(false);
if (user == null)
{
throw new ArgumentException("Invalid userId", nameof(userId));
}
var overlappingLogExists = user.WorkLog.Any(w =>
w.EntryDate.Date == workLog.EntryDate.Date &&
(workLog.StartTime >= w.StartTime && workLog.StartTime <w.EndTime ||
workLog.EndTime> w.StartTime && workLog.StartTime < w.StartTime));
if (overlappingLogExists)
{
throw new InvalidOperationException("Can not log overlapping work periods for a given date");
}
try
{
var addResult = await _dbContext.WorkLogSet.AddAsync(new WorkLog
{
Description = workLog.Description ?? "-",
Details = workLog.Details ?? "-",
EntryDate = workLog.EntryDate.Date,
StartTime = workLog.StartTime,
EndTime = workLog.EndTime,
UserId = user.Id
});
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
return(addResult.Entity);
}
catch (Exception e)
{
_logger.LogError("Exception occured while saving worklog", e);
throw;
}
}
