public void GetShiftsFromSchedule_ReturnsProperList()
{
// Arrange
var sched = new ScheduleDTO("hello", "test", "company");
var shift1 = new ShiftDTO("1", "test", "user", DateTime.Now, 1, 2);
var shift2 = new ShiftDTO("2", "test", "user", DateTime.Now, 1, 2);
var shift3 = new ShiftDTO("3", "test", "user", DateTime.Now, 1, 2);
var shift4 = new ShiftDTO("4", "test", "user", DateTime.Now, 1, 2);
var dtos = new List <ShiftDTO>()
{
shift1, shift2, shift3, shift4
};
// Mock the interface and implementation
var mock = new Mock <IScheduleHandler>();
_mockHandler.Setup(x => x.GetShiftsFromSchedule("test")).Returns(dtos);
// Act
// I am using sched.scheduleId to check if it actually gets the id properly
var actual = _schedCol.GetShiftsFromSchedule(sched.ScheduleId);
// Assert
for (int i = 0; i < actual.Count; i++)
{
Assert.AreEqual(dtos[i].ScheduleId, actual[i].ScheduleId);
Assert.AreEqual(dtos[i].ShiftId, actual[i].ShiftId);
Assert.AreEqual(dtos[i].UserId, actual[i].UserId);
Assert.AreEqual(dtos[i].ShiftDate, actual[i].ShiftDate);
Assert.AreEqual(dtos[i].StartTime, actual[i].StartTime);
Assert.AreEqual(dtos[i].EndTime, actual[i].EndTime);
}
}
public void GettingShiftsFromValidUser_ReturnsListOfShift()
{
var userId = "24";
var shift1 = new ShiftDTO("1", "1", "24", DateTime.Now, 1, 2);
var shift2 = new ShiftDTO("2", "2", "24", DateTime.Now, 1, 2);
var shift3 = new ShiftDTO("3", "3", "24", DateTime.Now, 1, 2);
List <ShiftDTO> correctDtos = new List <ShiftDTO> {
shift1, shift2, shift3
};
// Mock the interface and its implementation
var mock = new Mock <IShiftHandler>();
_mockHandler.Setup(x => x.GetShiftsFromUser(userId)).Returns(correctDtos);
// Act
var actual = _collection.GetShiftsFromUser("24");
// Assert
for (int i = 0; i < correctDtos.Count; i++)
{
Assert.AreEqual(correctDtos[i].ScheduleId, actual[i].ScheduleId);
Assert.AreEqual(correctDtos[i].ShiftId, actual[i].ShiftId);
Assert.AreEqual(correctDtos[i].UserId, actual[i].UserId);
Assert.AreEqual(correctDtos[i].ShiftDate, actual[i].ShiftDate);
Assert.AreEqual(correctDtos[i].StartTime, actual[i].StartTime);
Assert.AreEqual(correctDtos[i].EndTime, actual[i].EndTime);
}
}
public void GettingAllShifts_ReturnsEveryShift()
{
var shift1 = new ShiftDTO("1", "1", "1,", DateTime.Today, 1, 2);
var shift2 = new ShiftDTO("2", "1", "2,", DateTime.Today, 1, 2);
var shift3 = new ShiftDTO("3", "3", "3,", DateTime.Today, 1, 2);
var shift4 = new ShiftDTO("4", "3", "4,", DateTime.Today, 1, 2);
List <ShiftDTO> allShiftDtos = new List <ShiftDTO> {
shift1, shift2, shift3, shift4
};
List <ShiftDTO> allShiftsFromSchedule1 = new List <ShiftDTO> {
shift1, shift2
};
// Mock the interface and implementation
var mock = new Mock <IShiftHandler>();
_mockHandler.Setup(x => x.GetAll()).Returns(allShiftDtos);
// Act
var actual = _collection.GetAll();
// Assert
// Assert that obtained list is every shift, not just from one schedule
for (int i = 0; i < allShiftDtos.Count; i++)
{
Assert.AreEqual(allShiftDtos[i].ScheduleId, actual[i].ScheduleId);
Assert.AreEqual(allShiftDtos[i].ShiftId, actual[i].ShiftId);
Assert.AreEqual(allShiftDtos[i].UserId, actual[i].UserId);
Assert.AreEqual(allShiftDtos[i].ShiftDate, actual[i].ShiftDate);
Assert.AreEqual(allShiftDtos[i].StartTime, actual[i].StartTime);
Assert.AreEqual(allShiftDtos[i].EndTime, actual[i].EndTime);
}
}
public List <ShiftDTO> GetTodaysShifts(string id, DateTime date)
{
List <ShiftDTO> dtos = new List <ShiftDTO>();
List <ScheduleDTO> scheduleDtos = GetSchedulesFromCompany(id);
using (ConnectionString connectionString = new ConnectionString())
{
SqlCommand getTodayShifts = new SqlCommand("SELECT * FROM Shift WHERE Date = @Date", connectionString.SqlConnection);
getTodayShifts.Parameters.AddWithValue("@Date", date.Date);
connectionString.Open();
var reader = getTodayShifts.ExecuteReader();
while (reader.Read())
{
foreach (ScheduleDTO sched in scheduleDtos)
{
if (sched.ScheduleId == reader.GetString(1))
{
ShiftDTO dto = new ShiftDTO(shiftId: reader.GetString(0), scheduleId: reader.GetString(1), userId: reader.GetString(5), shiftDate: reader.GetDateTime(4), reader.GetInt32(2), reader.GetInt32(3));
dtos.Add(dto);
}
else
{
break;
}
}
}
connectionString.Dispose();
return(dtos);
}
}
private int DecreaseMaxHours(ShiftDTO shift)
{
int hours = 0;
int NrOfHours = shift.EndTime.Hours - shift.StartTime.Hours;
return(hours);
}
public ActionResult <Api <ShiftDTO> > New(ShiftEntity newEntity)
{
ShiftDTO dto = _shiftService.Save(newEntity);
Api <ShiftDTO> result = new Api <ShiftDTO>(200, dto, "Add Success");
return(Ok(result));
}
public ActionResult ShiftCreateClose(ShiftDetailViewModel data)
{
ShiftDetailViewModel sdvm = new ShiftDetailViewModel();
if (!ModelState.IsValid)
{
return(View("Shift/Create", sdvm));
}
ShiftDTO res = new ShiftDTO();
res.ShiftName = data.ShiftName;
res.ShiftDelayAllow = data.ShiftDelayAllow;
res.ShiftStatus = data.ShiftStatus;
ShiftDTO result = _shifService.InsertShift(res);
ShiftDayDTO detail = new ShiftDayDTO();
foreach (var item in data.ShiftDay)
{
detail.DayNumber = item.DayNumber + 1;
detail.DayName = item.DayName;
detail.DayShiftId = result.ShiftId;
detail.DayStartTime = item.DayStartTime;
detail.DayEndTime = item.DayEndTime;
detail.DayWeekend = item.DayWeekend;
TimeSpan a = item.DayEndTime.Value.Subtract(item.DayStartTime.Value);
double b = a.TotalMinutes;
detail.DayWorkingMinute = Convert.ToInt32(b);
ShiftDayDTO resultDetail = _shiftDayService.InsertShiftDayDetail(detail);
ViewBag.Success = "New Office Type created successfully";
}
ViewBag.Success = "Shift " + result.ShiftName + " has been created";
return(RedirectToAction("Shift"));
}
public ShiftModel GetShift(int id)
{
ShiftDTO dto = Context.GetShift(id);
var modeltransfer = new ShiftModel(dto.Id, dto.StartTime, dto.EndTime, dto.Date, dto.Details, dto.NrOfBar, dto.NrOfEvent, dto.NrOfIets);
return(modeltransfer);
}
public bool AddShift(ShiftDTO newShift)
{
bool add = true;
foreach (ShiftDTO shift in this.Shifts)
{
// Als de shift niet in een bestaande shift valt wordt hij toegevoegd.
// Een shift valt niet binnen een bestaande shift als ->
// de start datum tijd na een de shift valt.
// de eind datum tijd voor de shift valt.
// if start of old shift is before end of new shift -> overlap
if (shift.StartMoment.CompareTo(newShift.EndMoment) == 1)
{
add = false;
break;
}
// if end of old shift is before start of new shift -> overlap
if (shift.EndMoment.CompareTo(newShift.StartMoment) == 1)
{
add = false;
break;
}
}
if (add)
{
this.Shifts.Add(newShift);
}
return(add);
}
public ShiftDTO GetShift(int id)
{
var shift = new ShiftDTO();
using (SqlConnection connection = new SqlConnection(_connectionstring))
{
connection.Open();
SqlCommand command = new SqlCommand("GetShift", connection);
command.CommandType = CommandType.StoredProcedure;
command.Parameters.Add(new SqlParameter("@Id", id));
command.ExecuteNonQuery();
var reader = command.ExecuteReader();
while (reader.Read())
{
shift.Id = (int)reader["Id"];
shift.Date = (DateTime)reader["Date"];
shift.StartTime = (TimeSpan)reader["StartTime"];
shift.EndTime = (TimeSpan)reader["EndTime"];
shift.Details = (string)reader["Details"];
shift.NrOfBar = (int)reader["NrOfBar"];
shift.NrOfEvent = (int)reader["NrOfEvent"];
shift.NrOfIets = (int)reader["NrOfOther"];
}
}
return(shift);
}
public HttpResponseMessage PutShift(Guid id, ShiftDTO shiftDTO)
{
var businessLocId = db.Shifts.Find(id).Roster.BusinessLocation.Id;
if (ClaimsAuthorization.CheckAccess("Put", "BusinessLocationId", businessLocId.ToString()))
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
if (id != shiftDTO.Id)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Id provided does not match object."));
}
try
{
var shift = MapperFacade.MapperConfiguration.Map <ShiftDTO, Shift>(shiftDTO, db.Shifts.Single(s => s.Id == id));
//If an already published shift is being edited need to send notifications for any changes to employee as a cancel notification
if (shift.IsPublished)
{
//Notify employee that the shift is being taken from as a cancellation
if (shift.Employee != null && shift.Employee.UserProfile != null && shift.Employee.Id != shiftDTO.EmployeeId)
{
MessagingService.ShiftCancelled(shift.Employee.UserProfile.Email, shift.Employee.UserProfile.FirstName, shift.InternalLocation.BusinessLocation.Name, shift.StartTime, shift.FinishTime);
}
}
//If the employee assigned to the shift has changed, need to notify them that they have a shift broadcast
var employeeAdded = (shiftDTO.EmployeeId != null && (shift.Employee == null || shift.Employee.Id != shiftDTO.EmployeeId));
shift.Employee = db.Employees.Find(shiftDTO.EmployeeId);
//Notify the employee they have been added to a published shift
if (shift.IsPublished && employeeAdded && shift.Employee.UserProfile != null)
{
MessagingService.ShiftBroadcast(shift.Employee.UserProfile.Email, shift.Employee.UserProfile.FirstName);
}
shift.InternalLocation = db.InternalLocations.Find(shiftDTO.InternalLocationId);
shift.Role = db.Roles.Find(shiftDTO.RoleId);
db.Entry(shift).State = EntityState.Modified;
db.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, ex));
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
else
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.Unauthorized));
}
}
public ShiftDTO InsertShift(ShiftDTO data)
{
Shift dataToInsert = new Shift();
dataToInsert = ShiftRequestFormatter.ConvertRespondentInfoFromDTO(data);
ShiftDTO res = ShiftRequestFormatter.ConvertRespondentInfoToDTO(_unitOfWork.ShiftRepository.Create(dataToInsert));
return(res);
}
public int UpdateShift(ShiftDTO res)
{
Shift dataToUpdate = new Shift();
dataToUpdate = ShiftRequestFormatter.ConvertRespondentInfoFromDTO(res);
var result = _unitOfWork.ShiftRepository.Update(dataToUpdate);
_unitOfWork.Save();
return(result);
}
public ShiftModel(ShiftDTO dto)
{
Id = dto.Id;
StartTime = dto.StartTime;
EndTime = dto.EndTime;
Date = dto.Date;
Description = dto.Details;
NrOfBar = dto.NrOfBar;
NrOfEvent = dto.NrOfEvent;
NrOfExtra = dto.NrOfIets;
}
public void InsertLidShift(ShiftDTO shift)
{
string sql = "INSERT INTO `lid-dienst-combo` (lidID, dienstID) VALUES(@lidid, @dienstid);";
List <KeyValuePair <string, string> > parameters = new List <KeyValuePair <string, string> >();
parameters.Add(new KeyValuePair <string, string>("lidid", shift.Members.ID.ToString()));
parameters.Add(new KeyValuePair <string, string>("dienstid", shift.ID.ToString()));
ExecuteQuery(sql, parameters);
}
public List <ShiftDTO> GetAllShiftsForClub(string month)
{
string query = "SELECT * FROM dienst WHERE MONTH(startMoment) = @month";
List <KeyValuePair <string, string> > parameters = new List <KeyValuePair <string, string> >();
// parameters.Add(new KeyValuePair<string, string>("id", id.ToString()));
parameters.Add(new KeyValuePair <string, string>("month", month));
DataSet results = ExecuteQuery(query, parameters);
List <ShiftDTO> shifts = new List <ShiftDTO>();
if (results != null)
{
for (int i = 0; i < results.Tables[0].Rows.Count; i++)
{
ShiftDTO shift = DataSetParser.DataSetToShift(results, i);
if (shift.ID != 0)
{
// Get members ID
query = "SELECT lidID FROM `lid-dienst-combo` WHERE dienstID=@id";
parameters.Clear();
parameters.Add(new KeyValuePair <string, string>("id", shift.ID.ToString()));
DataSet res = ExecuteQuery(query, parameters);
if (res.Tables[0].Rows.Count != 0)
{
int memberId = (int)res.Tables[0].Rows[0][0];
// Get actual member
query = "SELECT * FROM leden WHERE id = @id";
parameters.Clear();
parameters.Add(new KeyValuePair <string, string>("id", memberId.ToString()));
DataSet member = ExecuteQuery(query, parameters);
// Add member to shift
shift.Members = DataSetParser.DataSetToMember(member, 0);
}
}
shifts.Add(shift);
}
}
return(shifts);
}
public void UpdateShift(ShiftDTO shift)
{
string sql = "update dienst set StartMoment=@startmoment, EindMoment=@eindmoment, Soort=@soort where ID=@id ";
List <KeyValuePair <string, string> > parameters = new List <KeyValuePair <string, string> >();
parameters.Add(new KeyValuePair <string, string>("id", shift.ID.ToString()));
parameters.Add(new KeyValuePair <string, string>("startmoment", shift.StartMoment.ToString("yyyy-MM-dd hh:mm:ss")));
parameters.Add(new KeyValuePair <string, string>("eindmoment", shift.EndMoment.ToString("yyyy-MM-dd hh:mm:ss")));
parameters.Add(new KeyValuePair <string, string>("soort", ((int)shift.EventType).ToString()));
ExecuteQuery(sql, parameters);
}
public void InsertShift(ShiftDTO shift)
{
string sql = "INSERT INTO dienst (naam,startMoment,eindMoment,soort,maxLeden) VALUES(@name,@sMom,@eMom,@type,@maxMem);";
List <KeyValuePair <string, string> > parameters = new List <KeyValuePair <string, string> >();
parameters.Add(new KeyValuePair <string, string>("name", shift.Name.ToString()));
parameters.Add(new KeyValuePair <string, string>("sMom", shift.StartMoment.ToString("yyyy-MM-dd hh:mm:ss")));
parameters.Add(new KeyValuePair <string, string>("eMom", shift.EndMoment.ToString("yyyy-MM-dd hh:mm:ss")));
parameters.Add(new KeyValuePair <string, string>("type", ((int)shift.EventType).ToString()));
parameters.Add(new KeyValuePair <string, string>("maxMem", shift.MaxMemberCount.ToString()));
DataSet result = ExecuteQuery(sql, parameters);
}
public void UpdateSchedule(ShiftDTO shift)
{
string sql = "UPDATE [dienst] SET ID=@id, Naam=@name, startMoment=@sMom, eindMoment=@eMom, soort=@type, maxLeden=@maxMem; UPDATE [schema-dienst-combo] SET dienstID=@id; UPDATE [lid-dienst-combo] SET dienstID=@id";
List <KeyValuePair <string, string> > parameters = new List <KeyValuePair <string, string> >();
parameters.Add(new KeyValuePair <string, string>("ID", shift.ID.ToString()));
parameters.Add(new KeyValuePair <string, string>("name", shift.Name.ToString()));
parameters.Add(new KeyValuePair <string, string>("sMom", shift.StartMoment.ToString()));
parameters.Add(new KeyValuePair <string, string>("eMom", shift.EndMoment.ToString()));
parameters.Add(new KeyValuePair <string, string>("type", shift.EventType.ToString()));
parameters.Add(new KeyValuePair <string, string>("maxMem", shift.MaxMemberCount.ToString()));
ExecuteQuery(sql, parameters);
}
public static ShiftOutput MapFromShiftDTOToShiftOutput(ShiftDTO shiftDTO)
{
ShiftOutput shiftOutput = new ShiftOutput
{
Earning = shiftDTO.ShiftEarning,
TotalHoursWorked = shiftDTO.TotalHoursWorked,
BreakHours = shiftDTO.BreakHours,
NormalHoursWorked = shiftDTO.NormalHoursWorked,
After6PmHoursWorked = shiftDTO.After6PmHoursWorked,
OvertimeHoursWorked = shiftDTO.OvertimeHoursWorked
};
return(shiftOutput);
}
public void DeletingValidEntity_ReturnsTrue()
{
// Arrange
var shift = new ShiftDTO("1234", "1", "1", DateTime.MaxValue, 1, 2);
// Mock the interface and the implementation
_mockHandler.Setup(x => x.Delete(shift.ShiftId)).Returns(true);
// Act
var actual = _collection.Delete("1234");
// Assert
Assert.AreEqual(true, actual);
}
public async Task <ActionResult <Shift> > PostShift([FromBody] ShiftDTO shiftDto)
{
Shift shift = new Shift
{
Name = shiftDto.Name,
StartTime = new TimeSpan(shiftDto.Hours, shiftDto.Minutes, shiftDto.Seconds),
EndTime = new TimeSpan(shiftDto.HoursEnd, shiftDto.MinutesEnd, shiftDto.SecondsEnd)
};
_context.shifts.Add(shift);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetShift", new { id = shift.ShiftId }, shift));
}
public ActionResult ShiftEdit(int id)
{
ShiftDetailViewModel resById = new ShiftDetailViewModel();
ShiftDTO getParentDetails = _shifService.GetShiftById(id);
resById.ShiftId = getParentDetails.ShiftId;
resById.ShiftName = getParentDetails.ShiftName;
resById.ShiftDelayAllow = getParentDetails.ShiftDelayAllow;
resById.ShiftStatus = getParentDetails.ShiftStatus;
List <ShiftDayDTO> getDetails = _shiftDayService.GetShiftByParentId(getParentDetails.ShiftId);
resById.ShiftDay = getDetails;
return(View(resById));
}
public void AddShift(ShiftModel newShift)
{
var dtotransfer = new ShiftDTO()
{
Id = newShift.Id,
Details = newShift.Description,
Date = newShift.Date,
EndTime = newShift.EndTime,
NrOfBar = newShift.NrOfBar,
NrOfEvent = newShift.NrOfEvent,
NrOfIets = newShift.NrOfExtra
};
Context.AddShift(dtotransfer);
}
public static Shift ConvertRespondentInfoFromDTO(ShiftDTO shiftDTO)
{
Mapper.CreateMap <ShiftDTO, Shift>().ConvertUsing(
m =>
{
return(new Shift
{
ShiftId = m.ShiftId,
ShiftName = m.ShiftName,
ShiftStatus = m.ShiftStatus,
ShiftDelayAllow = m.ShiftDelayAllow
});
});
return(Mapper.Map <ShiftDTO, Shift>(shiftDTO));
}
public void UpdateShift(ShiftModel model)
{
ShiftDTO dto = new ShiftDTO()
{
Id = model.Id,
Date = model.Date,
Details = model.Description,
EndTime = model.EndTime,
NrOfBar = model.NrOfBar,
NrOfEvent = model.NrOfEvent,
NrOfIets = model.NrOfExtra,
StartTime = model.StartTime
};
Context.ChangeShift(dto);;
}
public IActionResult Edit(int id)
{
ShiftDTO shift = this.shiftRetRepository.GetByID(id);
ShiftDetailViewModel model = new ShiftDetailViewModel()
{
ID = shift.ID,
Name = shift.Name,
StartMoment = shift.StartMoment,
EndMoment = shift.EndMoment,
EventType = shift.EventType,
MaxMemberCount = shift.MaxMemberCount
};
return(View(model));
}
public ShiftDTO FindShiftById(int id)
{
string query = "Select * from dienst where id=@id";
List <KeyValuePair <string, string> > parameters = new List <KeyValuePair <string, string> >();
parameters.Add(new KeyValuePair <string, string>("id", id.ToString()));
DataSet results = ExecuteQuery(query, parameters);
ShiftDTO s = new ShiftDTO();
if (results != null && results.Tables[0].Rows.Count > 0)
{
s = DataSetParser.DataSetToShift(results, 0);
}
return(s);
}
public void ShiftDtoToModelTest()
{
// Arrange
var expected = new Shift("shiftId", "scheduleId", "Julian", DateTime.Today, 12, 23);
var dto = new ShiftDTO("shiftId", "scheduleId", "Julian", DateTime.Today, 12, 23);
// Act
var actual = ModelConverter.ConvertShiftDtoToModel(dto);
// Assert
Assert.AreEqual(expected.ShiftId, actual.ShiftId);
Assert.AreEqual(expected.UserId, actual.UserId);
Assert.AreEqual(expected.ScheduleId, actual.ScheduleId);
Assert.AreEqual(expected.ShiftDate, actual.ShiftDate);
Assert.AreEqual(expected.StartTime, actual.StartTime);
Assert.AreEqual(expected.EndTime, actual.EndTime);
}
public void GettingUserFromInvalidShift_ReturnsNull()
{
// Arrange
var correctId = "schlatt";
var shift = new ShiftDTO("shift", "schedule", "schlatt", DateTime.Today, 1, 2);
// Mock the interface and its implementation
var mock = new Mock <IShiftHandler>();
_mockHandler.Setup(x => x.GetUserFromShift(shift.ShiftId)).Returns(correctId);
// Act
var actual = _collection.GetUserFromShift("shift1");
// Assert
Assert.IsNull(actual);
}
