protected override void Because()
{
_timeregistrationHandler.AsDynamic().Handle(new TimeRegistrationIncomeCorrected(_timeregistrationId,
500M, "Weekend work") { Version = 2 });
_timeregistration = _timeregistrationRepository.GetById(_timeregistrationId);
}
protected override void Because()
{
_timeregistrationHandler.AsDynamic().Handle(new TimeRegistrationDetailsChanged(_timeregistrationId, _clientId, _projectId,
"Meeting", "Doing some other work",
Date.Parse("2012-03-30"),
Time.Parse("11:00"), Time.Parse("15:00")) { Version = 2 });
_timeregistration = _timeregistrationRepository.GetById(_timeregistrationId);
}
protected override void Because()
{
var client = new Client(Guid.NewGuid(), "John Doe BVBA");
var project = new Project(Guid.NewGuid(), "Freelancemanager", "This app", client);
_timeregistration = new TimeRegistration(Guid.NewGuid(), client, project, project.Tasks.First(),
"Startup",
new Date(2013, 1, 2),
new Time(11, 0), new Time(13, 0));
}
protected override void Because()
{
_timeregistrationHandler.AsDynamic().Handle(new TimeRegistrationCreated(_timeregistrationId, _clientId, _projectId,
"Development", 50M, "Doing some work",
Date.Parse("2012-01-30"),
Time.Parse("12:00"), Time.Parse("14:00"),
DateTime.UtcNow) { Version = 1 });
_timeregistration = _timeregistrationRepository.GetById(_timeregistrationId);
}
protected override void Context()
{
var client = new Client(Guid.NewGuid(), "John Doe BVBA");
var project = new Project(Guid.NewGuid(), "Freelancemanager", "This app", client);
project.ChangeTasks(new[] { new Task { Name = "Dev", Rate = 50M } });
_timeregistration = new TimeRegistration(Guid.NewGuid(), client, project, project.Tasks.First(),
"Startup",
new Date(2013, 1, 2),
new Time(11, 0), new Time(13, 0));
}
protected override void Because()
{
var client = new Client(_clientId, "John Doe BVBA");
var project = new Project(_projectId, "Freelancemanager", "This app", client);
project.ChangeTasks(new[] { new Task { Name = "Dev", Rate = 50M } });
_timeregistration = new TimeRegistration(_id, client, project, project.Tasks.First(),
"Startup",
new Date(2013, 1, 2),
new Time(11, 0), null);
}
public NoteWindow(MainWindow mainWindow, TimeRegistration timeRegistration)
{
InitializeComponent();
this.timeRegistration = timeRegistration;
tbNote.Text = timeRegistration.Note;
tbNote.MaxLength = 50;
this.mainWindow = mainWindow;
tbNote.Focus();
tbNote.SelectAll();
}
public async Task <IActionResult> JoinChannel(string connectionId, string channelId)
{
await _chat.Groups.AddToGroupAsync(connectionId, channelId);
var channel = _chatService.GetAllChannels().FirstOrDefault(c => c.Id.ToString() == channelId);
var chat = _chatService.GetAllChannels().FirstOrDefault(c => c.Id.ToString() == channelId).Chat;
var profileId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
var profile = _chatService.GetAllProfiles().Where(x => x.Id == profileId).FirstOrDefault();
// register time
var timeregistration = new TimeRegistration()
{
Chat = chat,
ChatId = chat.Id,
Profile = profile,
ProfileId = profile.Id,
StartTime = DateTime.Now
};
_chatService.InsertTimeRegistration(timeregistration);
await _chatService.SaveChangesAsync();
// notify Clients in group
await _chat.Clients.Group(channelId)
.SendAsync("UserJoinedChannel", new
{
Text = " has joined.",
Name = profile.UserName,
ProfileId = profile.Id,
Timestamp = DateTime.Now.ToShortTimeString()
});
var trs = _chatService.GetAllTimeRegistrations().Where(tr => tr.ChatId == chat.Id && tr.EndTime == null);
var usersCurrentlyOnline = trs.Select(tr => new ProfileChatModel
{
ProfileName = tr.Profile.Name,
ProfileId = tr.ProfileId
});
await _chat.Clients.Group(channelId).
SendAsync("UpdateUsersOnline", usersCurrentlyOnline)
;
return(Ok());
}
public async Task <ActionResult> UpdateTimeRegistration(long id, TimeRegistration timeRegistration, Guid tenantId)
{
if (id != timeRegistration.Id)
{
return(NotFound());
}
bool success = await _timeRegistrationService.UpdateTimeRegistration(id, timeRegistration, tenantId);
if (!success)
{
return(NotFound());
}
return(NoContent());
}
public ActionResult Create([Bind(Include = "Id,WorkItemId,ModuleId,EmployeeWeekId,Notes")] TimeRegistration timeregistration)
{
if (ModelState.IsValid)
{
db.TimeRegistrations.Add(timeregistration);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.EmployeeWeekId = new SelectList(db.EmployeeWeeks, "Id", "Id", timeregistration.EmployeeWeekId);
ViewBag.ModuleId = new SelectList(db.Modules, "Id", "Name", timeregistration.ModuleId);
ViewBag.WorkItemId = new SelectList(db.WorkItems, "Id", "Title", timeregistration.WorkItemId);
return(View(timeregistration));
}
// GET: /TimeRegistration/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TimeRegistration timeregistration = db.TimeRegistrations.Find(id);
if (timeregistration == null)
{
return(HttpNotFound());
}
return(View(timeregistration));
}
public async Task <bool> CreateTimeRegistration(TimeRegistration timeRegistration, Guid tenantId)
{
try
{
_context.TimeRegistrations.Add(timeRegistration);
await _context.SaveChangesAsync();
return(true);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw;
}
}
public TimeRegistrationRepository_UnitTest() : base()
{
timeRegistration = new TimeRegistration()
{
Date = new DateTime(2021, 2, 19, 9, 0, 0),
TenantId = Guid.NewGuid(),
TaskId = 1,
Hours = 4
};
timeRegistrations = new List <TimeRegistration>()
{
timeRegistration
};
sut = new TimeRegistrationRepository(_context);
}
public void PostTimeRegistration_OK_CreatedAtAction()
{
//Arrange
var controller = new TimeRegistrationsController(_context);
var timeRegistration = new TimeRegistration()
{
Date = DateTime.Now, Duration = 1, WorkTypeId = 1
};
var projectId = _context.Projects.First().ProjectId;
//Act
var result = controller.PostTimeRegistration(timeRegistration, projectId).Result;
//Assert
Assert.IsInstanceOfType(result, typeof(CreatedAtActionResult));
}
private void BtnBadgeIn_Click(object sender, EventArgs e)
{
var temp = (Participant)LstParticipants.SelectedItem;
var toBeAdded = new TimeRegistration()
{
ParticipantID = temp.ID,
CourseID = Course.ID,
DateTime = DateTime.Now
};
using (AttendanceListDbEntities context = new AttendanceListDbEntities())
{
context.TimeRegistrations.Add(toBeAdded);
context.SaveChanges();
}
RefreshTimeregistrations();
}
public void PutTimeRegistration_IncorrectId_NotFound()
{
//Arrange
var controller = new TimeRegistrationsController(_context);
var timeRegistration = new TimeRegistration();
timeRegistration.TimeRegistrationId = -1000000;
timeRegistration.Date = DateTime.Now.AddDays(10);
timeRegistration.Duration = 5;
timeRegistration.WorkTypeId = 1;
//Act
var result = controller.PutTimeRegistration(timeRegistration.TimeRegistrationId, timeRegistration).Result;
//Assert
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
// GET: /TimeRegistration/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TimeRegistration timeregistration = db.TimeRegistrations.Find(id);
if (timeregistration == null)
{
return(HttpNotFound());
}
ViewBag.EmployeeWeekId = new SelectList(db.EmployeeWeeks, "Id", "Id", timeregistration.EmployeeWeekId);
ViewBag.ModuleId = new SelectList(db.Modules, "Id", "Name", timeregistration.ModuleId);
ViewBag.WorkItemId = new SelectList(db.WorkItems, "Id", "Title", timeregistration.WorkItemId);
return(View(timeregistration));
}
public async Task <IActionResult> PostTimeRegistration([FromBody] TimeRegistration timeRegistration, int projectId)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.Add(timeRegistration);
var project = _context.Projects.Include("TimeRegistrations").First(p => p.ProjectId == projectId);
project.TimeRegistrations.Add(timeRegistration);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTimeRegistration", new { id = timeRegistration.TimeRegistrationId }, timeRegistration));
}
public async Task <IActionResult> Update(int id, [FromBody] TimeRegistration timeRegistration, CancellationToken cancellationToken)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var updatedTimeRegistration = await _timeRegistrationService.UpdateAsync(id, timeRegistration, cancellationToken);
return(Ok(updatedTimeRegistration));
}
catch (TimeRegistrationNotFoundException)
{
return(NotFound());
}
}
public void PutTimeRegistration_IncorrectData_BadRequestResult()
{
//Arrange
var controller = new TimeRegistrationsController(_context);
var fakeTimeRegistration = new TimeRegistration();
fakeTimeRegistration.Date = DateTime.Now.AddDays(10);
fakeTimeRegistration.Duration = 5;
fakeTimeRegistration.WorkTypeId = 1;
var realTimeRegistrationId = _context.TimeRegistrations.First().TimeRegistrationId;
//Act
var result = controller.PutTimeRegistration(realTimeRegistrationId, fakeTimeRegistration).Result;
//Assert
Assert.IsInstanceOfType(result, typeof(BadRequestResult));
}
public async System.Threading.Tasks.Task CreateTimeRegistration_When_Called_With_TimeRegistrationAndGuid_Returns_CreatedAtActionResult()
{
// Arrange
var timeRegistration = new TimeRegistration()
{
Id = 1337,
Date = new DateTime(2021, 2, 19, 9, 0, 0),
OwnerId = 1337,
TaskId = 1337,
TenantId = Guid.NewGuid(),
Hours = 4
};
var tenantId = Guid.NewGuid();
// Act
var actualResult = await sut.CreateTimeRegistration(timeRegistration, tenantId);
// Assert
Assert.IsType <CreatedAtActionResult>(actualResult);
}
protected async Task <TimeRegistration> CreateTestTimeRegistration()
{
var task = await CreateTestTask();
var user = await CreateTestUser();
var timeRegistration = new TimeRegistration()
{
Date = new DateTime(2021, 2, 19, 9, 0, 0),
TenantId = Guid.NewGuid(),
TaskId = task.Id,
OwnerId = user.Id,
Hours = 4
};
var timeRegistrationRequest = new StringContent(JsonConvert.SerializeObject(timeRegistration), Encoding.UTF8, "application/json");
var response = await _client.PostAsync($"/api/v1/timeregistration?tenantId={timeRegistration.TenantId}", timeRegistrationRequest);
response.EnsureSuccessStatusCode();
return(JsonConvert.DeserializeObject <TimeRegistration>(await response.Content.ReadAsStringAsync()));
}
public async System.Threading.Tasks.Task UpdateTimeRegistration_When_Called_With_TimeRegistrationAndGuid_Returns_NoContentResult()
{
// Arrange
var id = 1;
var timeRegistration = new TimeRegistration()
{
Id = 1,
Date = new DateTime(2021, 2, 19, 12, 0, 0),
OwnerId = 1337,
TaskId = 1337,
TenantId = Guid.NewGuid(),
Hours = 5
};
var tenantId = Guid.NewGuid();
// Act
var actualResult = await sut.UpdateTimeRegistration(id, timeRegistration, tenantId);
// Assert
Assert.IsType <NoContentResult>(actualResult);
}
public async Task <bool> UpdateTimeRegistration(long id, TimeRegistration timeRegistration, Guid tenantId)
{
var foundTimeRegistration = await _context.TimeRegistrations.AsNoTracking().FirstOrDefaultAsync(t => t.Id == id);
if (foundTimeRegistration == null)
{
return(false);
}
try
{
_context.Entry(timeRegistration).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(true);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw;
}
}
public async System.Threading.Tasks.Task UpdateTimeRegistration_When_Called_With_TimeRegistrationAndGuid_Returns_True()
{
// Arrange
var id = 1;
var tenantId = Guid.NewGuid();
var timeRegistration = new TimeRegistration()
{
Id = 1,
Date = new DateTime(2021, 2, 19, 12, 0, 0),
OwnerId = 1337,
TaskId = 1337,
TenantId = tenantId,
Hours = 5
};
var expectedResult = true;
// Act
var actualResult = await sut.UpdateTimeRegistration(id, timeRegistration, tenantId);
// Assert
Assert.Equal(expectedResult, actualResult);
}
public async Task <TimeRegistration> CreateAsync(TimeRegistration timeRegistration, CancellationToken cancellationToken)
{
var timeRegistrationEntity = _mapper.Map <TimeRegistrationEntity>(timeRegistration);
var timeRegistrationEntities = await _dbContext
.TimeRegistrations
.AsNoTracking()
.ToListAsync();
if (timeRegistrationEntities.Count >= 30)
{
throw new Exception("This is a demo application, you can add no more than 30 registrations.");
}
timeRegistrationEntity.Project = null;
var newTimeRegistration = await _dbContext.TimeRegistrations.AddAsync(timeRegistrationEntity, cancellationToken);
await _dbContext.SaveChangesAsync(cancellationToken);
return(Mapper.Map <TimeRegistration>(newTimeRegistration.Entity));
}
public async System.Threading.Tasks.Task CreateTimeRegistration_Test()
{
// Arrange
var timeRegistration = new TimeRegistration()
{
Date = new DateTime(2021, 2, 19, 9, 0, 0),
TenantId = Guid.NewGuid(),
Hours = 4,
OwnerId = 1,
TaskId = 1
};
var timeRegistrationRequest = new StringContent(JsonConvert.SerializeObject(timeRegistration), Encoding.UTF8, "application/json");
var request = new HttpRequestMessage(HttpMethod.Post, $"/api/v1/timeregistration?tenantId={timeRegistration.TenantId}");
request.Content = timeRegistrationRequest;
// Act
var response = await _client.SendAsync(request);
// Assert
response.EnsureSuccessStatusCode();
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
}
public async Task Create(TimeRegistration create)
{
using SqlCommand command = new SqlCommand()
{
CommandText = "proc_Insert_registration",
CommandType = CommandType.StoredProcedure,
Connection = GetDatabase.SqlConnection
};
command.Parameters.AddWithValue("@time", create.RegistrationDateTime);
command.Parameters.AddWithValue("@projectID", create.ProjectID);
try
{
await GetDatabase.OpenConn;
await command.ExecuteNonQueryAsync();
}
finally
{
await GetDatabase.CloseConn;
await Task.CompletedTask;
}
}
public TimeRegistrationService_UnitTest()
{
timeRegistration = new TimeRegistration()
{
Id = 1,
Date = new DateTime(2021, 2, 19, 9, 0, 0),
TenantId = Guid.NewGuid(),
TaskId = 1,
OwnerId = 1,
Hours = 4
};
timeRegistrations = new List <TimeRegistration>()
{
timeRegistration
};
var mockTimeRegistrationRepository = new Mock <ITimeRegistrationRepository>();
mockTimeRegistrationRepository.Setup(repository => repository.CreateTimeRegistration(It.IsAny <TimeRegistration>(), It.IsAny <Guid>())).ReturnsAsync(true);
mockTimeRegistrationRepository.Setup(repository => repository.DeleteTimeRegistration(It.IsAny <long>(), It.IsAny <Guid>())).ReturnsAsync(true);
mockTimeRegistrationRepository.Setup(repository => repository.GetTimeRegistration(It.IsAny <long>(), It.IsAny <Guid>())).ReturnsAsync(timeRegistration);
mockTimeRegistrationRepository.Setup(repository => repository.GetTimeRegistrationsForTask(It.IsAny <long>(), It.IsAny <Guid>())).ReturnsAsync(timeRegistrations);
mockTimeRegistrationRepository.Setup(repository => repository.UpdateTimeRegistration(It.IsAny <long>(), It.IsAny <TimeRegistration>(), It.IsAny <Guid>())).ReturnsAsync(true);
sut = new TimeRegistrationService(mockTimeRegistrationRepository.Object);
}
protected override void Because()
{
_timeregistrationHandler.AsDynamic().Handle(new ProjectDetailsChanged(_projectId, "Proj 2", "123") { Version = 2 });
_timeregistration = _timeregistrationRepository.GetById(_timeregistrationId);
}
protected override void Because()
{
_timeregistrationHandler.AsDynamic().Handle(new TimeRegistrationRateRefreshed(_timeregistrationId, 70M) { Version = 2 });
_timeregistration = _timeregistrationRepository.GetById(_timeregistrationId);
}
public void InsertTimeRegistration(TimeRegistration tr)
{
_context.TimeRegistrations.Add(tr);
}
public async Task <bool> CreateTimeRegistration(TimeRegistration timeRegistration, Guid tenantId) => await _timeRegistrationRepository.CreateTimeRegistration(timeRegistration, tenantId);
protected override void Because()
{
_timeregistrationHandler.AsDynamic().Handle(new ClientDetailsChanged(_clientId, "ABC") { Version = 2 });
_timeregistration = _timeregistrationRepository.GetById(_timeregistrationId);
}
public async Task <bool> UpdateTimeRegistration(long id, TimeRegistration timeRegistration, Guid tenantId) => await _timeRegistrationRepository.UpdateTimeRegistration(id, timeRegistration, tenantId);
protected override void Because()
{
_timeregistrationHandler.AsDynamic().Handle(new TimeRegistrationCorrectedIncomeCleared(_timeregistrationId) { Version = 3 });
_timeregistration = _timeregistrationRepository.GetById(_timeregistrationId);
}
protected override void Because()
{
_timeregistrationHandler.AsDynamic().Handle(new TimeRegistrationDeleted(_timeregistrationId, DateTime.UtcNow) { Version = 2 });
_timeregistration = _timeregistrationRepository.GetById(_timeregistrationId);
}
public async Task <ActionResult> CreateTimeRegistration(TimeRegistration timeRegistration, Guid tenantId)
{
bool success = await _timeRegistrationService.CreateTimeRegistration(timeRegistration, tenantId);
return(CreatedAtAction(nameof(GetTimeRegistration), new { id = timeRegistration.Id }, timeRegistration));
}
protected void RegistrationWith(OrderNumber orderNumber, TimeRange range)
{
_registration = new TimeRegistration(orderNumber, range);
}
