public bool AddHoliday(HolidayDto dto)
{
try
{
if (dto == null)
{
_logger.Warn("Parameter passed is null");
return(false);
}
var holiday = new Holidays()
{
HolidaysId = dto.Id,
Name = dto.Name,
HolidayDate = dto.HolidayDate
};
_context.Holiday.Add(holiday);
_context.SaveChanges();
_logger.Info($"Holiday {dto.Name} on {dto.HolidayDate} has been successfully created");
return(true);
}
catch (Exception e)
{
_logger.Error(e);
return(false);
}
}
public async Task Should_Save_HolidayDates_Corrently()
{
// arrange
var loaderOffices = await _officeDataLoader.LoadValueAtMostAsync(10);
var office = loaderOffices.FirstOrDefault <OfficeDtos>();
// act
var holidays = office.HolidayDates;
var holidaysList = holidays.ToList <HolidayDto>();
var prevList = holidaysList.Count();
HolidayDto holidayDto = Craft_Holiday_Date(office.Codigo);
holidaysList.Add(holidayDto);
office.HolidayDates = holidaysList;
var result = await _officeDataSaver.SaveAsync(office);
Assert.IsTrue(result);
var entity = await _officeDataLoader.LoadValueAsync(office.Codigo);
var value = entity.HolidayDates.FirstOrDefault <HolidayDto>(x => (
(x.FESTIVO == holidayDto.FESTIVO) &&
(x.OFICINA == holidayDto.OFICINA) && (x.PARTE_DIA == holidayDto.PARTE_DIA) &&
(x.HORA_DESDE == holidayDto.HORA_DESDE) &&
(x.HORA_HASTA == holidayDto.HORA_HASTA)));
var nextList = entity.HolidayDates.Count();
Assert.Greater(nextList, prevList);
Assert.NotNull(value);
}
public bool UpdateHoliday(HolidayDto dto)
{
try
{
if (dto == null)
{
_logger.Warn("Parameter passed is null");
return(false);
}
var holiday = _context.Holiday.FirstOrDefault(x => x.HolidaysId == dto.Id);
if (holiday == null)
{
_logger.Warn($"Holiday ID {dto.Id} not found in database");
return(false);
}
holiday.Name = dto.Name;
holiday.HolidayDate = dto.HolidayDate;
_context.Entry(holiday).State = EntityState.Modified;
_context.SaveChanges();
_logger.Info($"Holiday {dto.Name} on {dto.HolidayDate} has been updated");
return(true);
}
catch (Exception e)
{
_logger.Error(e);
return(false);
}
}
private void OnSelectedDaysCommand(object obj)
{
var dictionary = obj as IDictionary <HolidayCalendar.Status, object>;
var holidays = dictionary[HolidayCalendar.Status.CurrentHolidays];
var changedValue = dictionary[HolidayCalendar.Status.ChangedValue] as Tuple <DateTime, bool>;
var holidayDto = new HolidayDto();
CreateHolidayItem(ref holidayDto, changedValue.Item1, changedValue.Item2, !changedValue.Item2);
_lastSelectedDay = holidayDto;
if (_holidaysDates.Contains(holidayDto, new HolidayDateComparer()))
{
var holidayList = _holidaysDates.ToList();
holidayList.Remove(holidayDto);
if (!holidayDto.IsDeleted)
{
holidayList.Add(holidayDto);
}
_holidaysDates = holidayList;
}
else
{
_holidaysDates = _holidaysDates.Union(new List <HolidayDto>()
{
holidayDto
});
}
}
public HolidayDto GetHoliday(string id)
{
if (id == null)
{
_logger.Warn("null parameter passed");
return(null);
}
var holiday = _context.Holiday.FirstOrDefault(x => x.HolidaysId == id);
if (holiday == null)
{
_logger.Warn($"Holiday ID {id} not found in database");
return(null);
}
var dto = new HolidayDto()
{
Id = holiday.HolidaysId,
Name = holiday.Name,
HolidayDate = holiday.HolidayDate
};
_logger.Info($"Holiday ID {id} found in database");
return(dto);
}
public async Task <ActionResult <HolidayDto> > Post([FromBody] HolidayDto holidayDto)
{
var holiday = _mapper.Map <Holiday>(holidayDto);
await _context.Holidays.AddAsync(holiday);
await _context.SaveChangesAsync();
var addedHolidayDto = _mapper.Map <HolidayDto>(holiday);
return(CreatedAtAction(nameof(Get), new { id = addedHolidayDto.Id }, addedHolidayDto));
}
public void SetToHoliday(HolidayDto holiday)
{
if (holiday.Date != Date)
{
throw new Exception(string.Format("Holiday {0} does not have same date as {1}", holiday.Description, Date.ToShortDateString()));
}
_holidayDesciption = holiday.Description;
OnPropertyChanged(() => HolidayDesciption);
OnPropertyChanged(() => IsHoliday);
OnPropertyChanged(() => IsWorkDay);
}
private void CreateHolidayItem(ref HolidayDto dto, DateTime time, bool isNew, bool isDeleted)
{
dto.PARTE_DIA = _currentPartOfDay;
dto.FESTIVO = time;
dto.OFICINA = DataObject.Codigo;
dto.HORA_DESDE = _holidayTimeSpanFrom;
dto.HORA_HASTA = _holidayTimeSpanTo;
dto.IsDirty = true;
dto.IsDeleted = isDeleted;
dto.IsNew = isNew;
dto.IsChanged = true;
}
public async Task UpdateHolidayAsync(HolidayDto holiday)
{
try
{
var h = this.mapper.Map <Holiday>(holiday);
this.dbContext.Holidays.Update(h);
await dbContext.SaveChangesAsync();
}
catch (Exception)
{
throw;
}
}
public void SetToHoliday_HolidayToSetFromHasDifferentDate_ThrowsException()
{
// Arrange
var holiday = new HolidayDto {
Date = new DateTime(2013, 1, 1), Description = "buuh"
};
var dateItem = new ForecastRegistrationDateColumn(new DateTime(2013, 1, 2));
// Act
var error = Assert.Throws <Exception>(() => dateItem.SetToHoliday(holiday));
// Assert
Assert.That(error.Message, Is.EqualTo("Holiday buuh does not have same date as 02-01-2013"));
}
/// <summary>
/// HolidayDto. This craft an holiday data transfer object.
/// </summary>
/// <returns></returns>
private HolidayDto Craft_Holiday_Date(string oficina)
{
HolidayDto holidayDto = new HolidayDto();
holidayDto.FESTIVO = new DateTime(2018, 12, 24);
holidayDto.HORA_DESDE = new TimeSpan(14, 0, 0);
holidayDto.HORA_HASTA = new TimeSpan(20, 0, 0);
holidayDto.PARTE_DIA = 1;
holidayDto.OFICINA = oficina;
holidayDto.IsDirty = true;
holidayDto.IsNew = true;
holidayDto.IsValid = true;
return(holidayDto);
}
public async Task postShouldBadRequestWhenDataIsInvalid()
{
// Arrange
var newHolidayDto = new HolidayDto(null, DateTime.Now, "new_holiday", null);
var putData = "{'Id':null,'DateTime':'2020-09-06T14:03:08.87279-03:00'}";
var payload = new StringContent(putData, Encoding.UTF8, "application/json");
// Act
var response = await _client.PostAsync($"/holiday", payload);
// Assert
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
public void SetToHoliday_HolidayHasSameDateAsDateItem_HolidayDescriptionGetValue()
{
// Arrange
var holiday = new HolidayDto {
Date = new DateTime(2013, 1, 1), Description = "buuh"
};
var dateItem = new ForecastRegistrationDateColumn(new DateTime(2013, 1, 1));
// Act
dateItem.SetToHoliday(holiday);
// Assert
Assert.That(dateItem.IsHoliday, Is.True);
Assert.That(dateItem.HolidayDesciption, Is.EqualTo("buuh"));
}
public IHoliday CreateHoliday(HolidayDto holidayDto)
{
return(holidayDto.Type switch
{
HolidayType.ParticularDayOfMonth =>
new DayOfMonthHoliday(
holidayDto.ApplicableMonth.Value,
holidayDto.ApplicableDay.Value,
holidayDto.OccurenceInMonth.Value),
var x when x == HolidayType.Fixed || x == HolidayType.RollsToMonday =>
new FixedHoliday(
x == HolidayType.RollsToMonday,
holidayDto.Date.Value),
_ => throw new InvalidOperationException($"Unknown holiday type {holidayDto.Type}")
});
public async Task <string> CreateHolidayAsync(HolidayDto holiday)
{
try
{
var holidayModel = this.mapper.Map <Holiday>(holiday);
await dbContext.Holidays.AddAsync(holidayModel).ConfigureAwait(false);
await dbContext.SaveChangesAsync().ConfigureAwait(false);
return(holiday.Id.ToString());
}
catch (Exception)
{
throw;
}
}
public async Task <IActionResult> Post([FromBody] HolidayDto holiday)
{
try
{
if (holiday == null)
{
return(BadRequest());
}
var holidayId = await this.holidaysService.CreateHolidayAsync(holiday);
return(!string.IsNullOrWhiteSpace(holidayId) ? Ok(holidayId) : (IActionResult)NotFound());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
throw;
}
}
public async Task <ActionResult> Put(int id, [FromBody] HolidayDto holidayDto)
{
if (id != holidayDto.Id)
{
return(BadRequest());
}
if (!_context.Holidays.Any(e => e.Id == id))
{
return(NotFound());
}
var holiday = _mapper.Map <Holiday>(holidayDto);
_context.Entry(holiday).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(NoContent());
}
public async Task postShouldCreateNewHoliday()
{
// Arrange
var newHolidayDto = new HolidayDto(null, DateTime.Now, "new_holiday", null);
var putData = JsonConvert.SerializeObject(newHolidayDto);
var payload = new StringContent(putData, Encoding.UTF8, "application/json");
// Act
var response = await _client.PostAsync($"/holiday", payload);
// Assert
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
var addedHolidayDto = JsonConvert.DeserializeObject <HolidayDto>(await response.Content.ReadAsStringAsync());
var holidayFromDb = await _context.FindAsync <Holiday>(addedHolidayDto.Id);
Assert.NotNull(holidayFromDb);
Assert.Equal(addedHolidayDto.Name, holidayFromDb.Name);
var x = response.Headers.Location.AbsolutePath; // /Holiday/765
}
public void HolidayFactory_ReturnsCorrectObject_WithRollsToMondayHolidayDto()
{
// arrange
var dto = new HolidayDto
{
Type = HolidayType.RollsToMonday,
Date = new DateTime(2020, 5, 5),
};
var sut = new HolidayFactory();
// act
var result = sut.CreateHoliday(dto);
// assert
Assert.IsType <FixedHoliday>(result);
var typedResult = result as FixedHoliday;
Assert.Equal(new DateTime(2020, 5, 5), typedResult.Date);
Assert.True(typedResult.RollsToNextMonday);
}
private ForecastDateColumns CreateDateHeaders()
{
var dates = GenereateDatesForMonth(4, 2013);
var result = new ForecastDateColumns();
foreach (var date in dates)
{
var newItem = new ForecastRegistrationDateColumn(date);
// Set a couple of days to be holiday
if (date.Day == 2 || date.Day == 3)
{
var holiday = new HolidayDto {
Date = date, Description = "Holiday"
};
newItem.SetToHoliday(holiday);
}
result.Add(newItem);
}
return(result);
}
public void HolidayFactory_ReturnsCorrectObject_WithParticularDayOfMonthHolidayDto()
{
// arrange
var dto = new HolidayDto
{
Type = HolidayType.ParticularDayOfMonth,
ApplicableDay = DayOfWeek.Monday,
ApplicableMonth = MonthOfYear.October,
OccurenceInMonth = 3,
};
var sut = new HolidayFactory();
// act
var result = sut.CreateHoliday(dto);
// assert
Assert.IsType <DayOfMonthHoliday>(result);
var typedResult = result as DayOfMonthHoliday;
Assert.Equal(3, typedResult.OccurenceInMonth);
Assert.Equal(DayOfWeek.Monday, typedResult.ApplicableDay);
Assert.Equal(MonthOfYear.October, typedResult.ApplicableMonth);
}
public JsonResult Update(HolidayDto dto)
{
OperationResult oper = _holidayContract.Update(dto);
return(Json(oper));
}
public JsonResult Create(HolidayDto dto)
{
OperationResult oper = _holidayContract.Insert(dto);
return(Json(oper));
}
public EditHolidayViewModel(HolidayDto dto)
{
Name = dto.Name;
Id = dto.Id;
HolidayDate = dto.HolidayDate;
}
