private async Task WriteCrewsToLogAsync(IEnumerable <CrewDto> crews)
{
await Task.Run(() =>
{
using (StreamWriter writer = File.CreateText($"log_{DateTime.Now.ToString("MM-dd-yyyy_hh-mm-ss")}.csv"))
{
writer.WriteLine($"RemoteId;DepartureId;PilotId;PilotFirstName;PilotLastName;PilotBirthDate;PilotExperience;" +
$"st1-Id;st1-FirstName;st1-LastName;st1-BirthDate;" +
$"st2-Id;st2-FirstName;st2-LastName;st2-BirthDate;");
foreach (var c in crews)
{
string line = $"{c.Id};{c.DepartureId};";
var p = c.Pilots?.FirstOrDefault();
if (p != null)
{
line += $"{p.Id};{p.FirstName};{p.LastName};{p.BirthDate};{p.Experience};";
}
for (int i = 0; i < c.Stewardesses.Count; i++)
{
StewardessDto s = c.Stewardesses[i];
line += $"{s.Id};{s.FirstName};{s.LastName};{s.BirthDate};";
}
writer.WriteLine(line);
}
}
});
}
public void Update_When_StewardessModel_is_not_valid_Then_throws_ValidatorException()
{
var stewardess1 = new StewardessDto()
{
ID = -1,
Birthday = DateTime.Now.AddYears(-20),
FirstName = "Ksu",
LastName = "Black"
};
var stewardess2 = new StewardessDto()
{
Birthday = DateTime.Now.AddYears(-17),
FirstName = "Ksu",
LastName = "Black"
};
var stewardess3 = new StewardessDto()
{
Birthday = DateTime.Now.AddYears(-20),
LastName = "Black"
};
Assert.Throws <FluentValidation.ValidationException>(() => service.Update(stewardess1, 1));
Assert.Throws <FluentValidation.ValidationException>(() => service.Update(stewardess2, 1));
Assert.Throws <FluentValidation.ValidationException>(() => service.Update(stewardess3, 1));
}
public void Update_Valid()
{
//arange
StewardessesService service = new StewardessesService(unitOfWork, mapper, validator);
var expected = new Stewardess
{
Id = 1, CrewId = 1, FirstName = "Ivan", LastName = "Ivanov", Birthday = new DateTime(1987, 1, 24)
};
var DtoToMake = new StewardessDto
{
Id = 1, CrewId = 1, FirstName = "Ivan", LastName = "Ivanov", Birthday = new DateTime(1987, 1, 24)
};
//act
service.Update(DtoToMake);
var actual = (unitOfWork.Set <Stewardess>() as FakeRpository <Stewardess>).updatedItem;
//assert
Assert.AreEqual(expected.Id, actual.Id);
Assert.AreEqual(expected.CrewId, actual.CrewId);
Assert.AreEqual(expected.FirstName, actual.FirstName);
Assert.AreEqual(expected.LastName, actual.LastName);
Assert.AreEqual(expected.Birthday, actual.Birthday);
}
public async Task Update(StewardessDto item)
{
var updItem = _mapper.Map <StewardessDto, Stewardess>(item);
await _unitOfWork.Repository <Stewardess>().Update(updItem);
await _unitOfWork.SaveAsync();
}
public async Task Create(StewardessDto item)
{
var newItem = _mapper.Map <StewardessDto, Stewardess>(item);
await _unitOfWork.Repository <Stewardess>().Create(newItem);
await _unitOfWork.SaveAsync();
}
public async Task <IActionResult> Get(int id)
{
StewardessDto Stewardess = await service.GetById(id);
if (Stewardess == null)
{
return(NotFound());
}
return(Ok(Stewardess));
}
public Stewardess MapStewadress(StewardessDto value)
{
return(new Stewardess
{
Id = value.ID,
Name = value.FirstName,
LastName = value.LastName,
Birthday = value.Birthday
});
}
public async Task Update_WhenStewardessNull_ThenReturnExeption()
{
var Stewardesss = new IFakeRepository <Stewardess>();
var context = new IFakeUnitOfFactory();
StewardessDto StewardessDto = null;
StewardessService service = new StewardessService(context);
StewardessDto StewardessDtoSaved = await service.Update(StewardessDto);
}
public StewardessDto Create(StewardessDto stewardessDto)
{
var stewardess = mapper.Map <StewardessDto, Stewardess>(stewardessDto);
stewardess.Id = Guid.NewGuid();
db.StewardessRepositiry.Create(stewardess);
return(mapper.Map <Stewardess, StewardessDto>(stewardess));
}
public StewardessDto Update(Guid id, StewardessDto stewardessDto)
{
var stewardess = mapper.Map <StewardessDto, Stewardess>(stewardessDto);
stewardess.Id = id;
db.StewardessRepositiry.Update(stewardess);
return(mapper.Map <Stewardess, StewardessDto>(stewardess));
}
public IActionResult Get(int id)
{
StewardessDto Stewardess = service.GetById(id);
if (Stewardess == null)
{
return(NotFound());
}
return(Ok(Stewardess));
}
public async Task <IActionResult> Post([FromBody] StewardessDto entity)
{
var result = await _stewardessesSrvice.AddAsync(entity);
if (result == null)
{
return(NotFound());
}
return(Ok(result));
}
public async Task <IActionResult> Put(int id, [FromBody] StewardessDto entity)
{
var result = await _stewardessesSrvice.UpdateAsync(entity, id);
if (result == null)
{
return(NotFound());
}
return(Ok(result));
}
public void OnSelectedItem(object sender, RoutedEventArgs e)
{
SelectedItem = GetSelected(sender, e);
if (SelectedItem != null)
{
TextId.Text = SelectedItem.Id.ToString();
TextName.Text = SelectedItem.Name;
TextSurname.Text = SelectedItem.Surname.ToString();
TextDeteOfBirth.Text = SelectedItem.DateOfBirth.ToString();
}
}
public IActionResult Delete([FromBody] StewardessDto stewadress)
{
try
{
service.Delete(stewadress);
return(NoContent());
}
catch (Exception ex)
{
return(NotFound(ex));
}
}
public StewardessView()
{
this.InitializeComponent();
_stewardessService = new StewardessService();
StewardessDtos = new ObservableCollection <StewardessDto>();
SelectedItem = new StewardessDto();
AirplaneTypesList.ItemsSource = StewardessDtos;
HideDetailFields();
HideAddAndSaveButtons();
}
public int Create(StewardessDto Stewadress)
{
var validationResult = validator.Validate(Stewadress);
if (validationResult.IsValid)
{
return(unit.Stewadresses.Create(mapper.MapStewadress(Stewadress)));
}
else
{
throw new ValidationException(validationResult.Errors);
}
}
public async Task <IActionResult> Update([FromBody] StewardessDto stewardess)
{
if (ModelState.IsValid)
{
await _service.Update(stewardess);
return(Ok(stewardess));
}
else
{
return(new BadRequestObjectResult(ModelState));
}
}
public async Task <IActionResult> Post([FromBody] StewardessDto stewardessDto)
{
try
{
var stewardessToReturn = await _stewardessService.AddEntityAsync(stewardessDto);
return(CreatedAtRoute("GetStewardess", new { id = stewardessToReturn.Id }, stewardessToReturn));
}
catch (BadRequestException)
{
return(BadRequest());
}
}
public void Create_WhenDtoIsEmpty_ThenThrowValidExeption()
{
// Arrange
var dto = new StewardessDto()
{
};
var service = new StewardessService(unitOfWorkFake, mapper, validator);
// Act
// Assert
Assert.Throws <ValidationException>(() => service.Create(dto));
}
public IActionResult Post([FromBody] StewardessDto value)
{
try
{
return(Ok(service.Create(value)));
}
catch (ValidationException e)
{
return(BadRequest(e.Message));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public void Create_When_StewardessModel_is_valid_Then_return_id()
{
var expectedStewardess = new StewardessDto()
{
Birthday = DateTime.Now.AddYears(-20),
FirstName = "Ksu",
LastName = "Black"
};
int id = service.Create(expectedStewardess);
var actualStewardess = service.Get(id);
Assert.AreEqual(expectedStewardess.FirstName, actualStewardess.FirstName);
Assert.AreEqual(expectedStewardess.LastName, actualStewardess.LastName);
Assert.AreEqual(expectedStewardess.Birthday, actualStewardess.Birthday);
}
public async Task <IActionResult> Post([FromBody] StewardessDto Stewardess)
{
if (Stewardess == null)
{
ModelState.AddModelError("", "Не указаны данные для стюардеси");
return(BadRequest(ModelState));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await service.Create(Stewardess);
return(Created("api/Stewardesses", Stewardess));
}
public async Task <IActionResult> Put(int id, [FromBody] StewardessDto Stewardess)
{
if (Stewardess == null)
{
ModelState.AddModelError("", "Не указаны данные для стюардеси");
return(BadRequest(ModelState));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await service.Update(Stewardess);
return(Ok(Stewardess));
}
public async Task Update_WhenValidStewardess_ThenReturnStewardess()
{
var Stewardesss = new IFakeRepository <Stewardess>();
var context = new IFakeUnitOfFactory();
StewardessDto StewardessDto = new StewardessDto()
{
Id = 154,
Name = "Nataly"
};
StewardessService service = new StewardessService(context);
StewardessDto StewardessDtoSaved = await service.Update(StewardessDto);
Assert.AreEqual(StewardessDto.Name, StewardessDtoSaved.Name);
Assert.AreEqual(StewardessDto.Id, StewardessDtoSaved.Id);
}
public void Update_When_StewardessModel_is_valid_Then_Stewardess_changed()
{
var expectedStewardess = new StewardessDto()
{
Birthday = DateTime.Now.AddYears(-20),
FirstName = "Ksu",
LastName = "Black"
};
var id = 1;
service.Update(expectedStewardess, id);
var actualStewardess = service.Get(id);
Assert.AreEqual(expectedStewardess.FirstName, actualStewardess.FirstName);
Assert.AreEqual(expectedStewardess.LastName, actualStewardess.LastName);
Assert.AreEqual(expectedStewardess.Birthday, actualStewardess.Birthday);
}
public void Update_UnValid()
{
//arange
StewardessesService service = new StewardessesService(unitOfWork, mapper, validator);
var DtoToMake = new StewardessDto
{
Id = 1, CrewId = 1, FirstName = "an", LastName = "ov", Birthday = new DateTime(1987, 1, 24)
};
//act
service.Update(DtoToMake);
var actual = (unitOfWork.Set <Stewardess>() as FakeRpository <Stewardess>).updatedItem;
//assert
Assert.IsNull(actual);
}
public async Task <IActionResult> Put(Guid id, [FromBody] StewardessDto stewardessDto)
{
try
{
stewardessDto.Id = id;
await _stewardessService.UpdateEntityAsync(stewardessDto);
return(NoContent());
}
catch (BadRequestException)
{
return(BadRequest());
}
catch (NotFoundException)
{
return(NotFound());
}
}
public StewardessDto Update(Guid id, StewardessDto stewardessDto)
{
var stewardess = mapper.Map <StewardessDto, Stewardess>(stewardessDto);
stewardess.Id = id;
var validationResult = validator.Validate(stewardess);
if (validationResult.IsValid)
{
db.StewardessRepositiry.Update(stewardess);
db.SaveChanges();
}
else
{
throw new ValidationException(validationResult.Errors);
}
return(mapper.Map <Stewardess, StewardessDto>(stewardess));
}
public IActionResult Put(int id, [FromBody] StewardessDto stewadress)
{
try
{
service.Update(stewadress, id);
return(Ok("success"));
}
catch (NotFoundException ex)
{
return(NotFound(ex));
}
catch (ValidationException e)
{
return(BadRequest(e.Message));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
