public static async Task <VehicleRegistered> Register(VehicleRegistrationRequest vehicleRegistrationRequest)
{
if (vehicleRegistrationRequest == null)
{
throw new AppArgumentException(nameof(vehicleRegistrationRequest));
}
if (vehicleRegistrationRequest.UserId == null ||
vehicleRegistrationRequest.UserId == Guid.Empty)
{
throw new AppArgumentException(nameof(vehicleRegistrationRequest.UserId));
}
if (string.IsNullOrWhiteSpace(vehicleRegistrationRequest.Plate))
{
throw new AppArgumentException(nameof(vehicleRegistrationRequest.Plate));
}
if (!await Context.UserGateway.Exists(vehicleRegistrationRequest.UserId.Value))
{
throw new AppNotFoundException(nameof(vehicleRegistrationRequest.UserId));
}
var entity = Entities.Vehicle.From(vehicleRegistrationRequest.UserId.Value, vehicleRegistrationRequest.Plate);
var created = await Context.VehicleGateway.RegisterKnownVehicle(entity);
return(VehicleMapper.CreateInsertedFrom(created));
}
public void MapInspectionToInspectionDTOTest()
{
UserDTO userDTO = this.CreateUser();
UserMapper userMapper = new UserMapper(new RoleDAOImp());
User user = userMapper.ToEntity(userDTO);
VehicleDTO vehicleDTO = new VehicleDTO();
VehicleMapper vehicleMapper = new VehicleMapper();
Vehicle vehicle = vehicleMapper.ToEntity(vehicleDTO);
InspectionMapper mapper = new InspectionMapper();
Inspection inspection = new Inspection();
inspection.Date = DateTime.Now;
inspection.IdLocation = new Location(Ports.FIRST_PORT);
inspection.IdUser = user;
inspection.Damages = new List <Damage>();
inspection.IdVehicle = vehicle;
InspectionDTO inspectionDTO = mapper.ToDTO(inspection);
Assert.AreEqual(inspectionDTO.Location, inspection.IdLocation.Name);
Assert.AreEqual(inspectionDTO.Id, inspection.Id);
Assert.AreEqual(inspectionDTO.Date, inspection.Date);
Assert.AreEqual(inspectionDTO.CreatorUserName, inspection.IdUser.UserName);
Assert.AreEqual(inspectionDTO.IdVehicle, inspection.IdVehicle.Vin);
foreach (DamageDTO damageDTO in inspectionDTO.Damages)
{
Assert.IsNotNull(inspection.Damages.Find(d => d.Description == damageDTO.Description));
}
}
public async Task <ActionResult <VehicleDto> > Create(CreatingVehicleDto obj)
{
var dto = VehicleMapper.toDTO(obj);
var vehicle = await _service.AddAsync(dto);
return(CreatedAtAction(nameof(GetGetById), new { Id = vehicle.Id }, vehicle));
}
public IActionResult UpdateVehicle([FromBody] VehicleDTO vehicleDTO)
{
_logger?.LogInformation($"Inicio del servicio: [PUT] https://localhost:5001/api/vehicles ");
try{
VehicleMapper vehicleMapper = MapperFactory.CreateVehicleMapper();
Entity entity = vehicleMapper.CreateEntity(vehicleDTO);
_logger?.LogInformation($" Se transformó de DTO a Entity ");
UpdateVehicleCommand command = CommandFactory.CreateUpdateVehicleCommand((Vehicle)entity);
_logger?.LogInformation($" Ejecución del comando ");
command.Execute();
if (command.GetResult())
{
return(Ok("La modificación fue realizada exitosamente"));
}
else
{
return(StatusCode(400));
}
} catch (VehicleNotFoundException ex) {
_logger?.LogWarning("Vehiculo con Id : " + ex.VehicleId + "no encontrado");
return(StatusCode(404, ex.Message + ex.VehicleId));
} catch (ModelNotFoundException ex) {
_logger?.LogWarning("Modelo con Id : " + ex.ModelId + "no encontrado");
return(StatusCode(404, ex.Message + ex.ModelId));
} catch (LocationNotFoundException ex) {
_logger?.LogWarning("Lugar no encontrado");
return(StatusCode(404, ex.Message));
} catch (InternalServerErrorException ex) {
_logger?.LogError("Error: " + ex.Ex.Message);
return(StatusCode(500, ex.Message));
} catch (Exception) {
_logger?.LogError("Error inesperado");
return(StatusCode(400));
}
}
public async Task Handle_CreateVehicleCommand_ReturnsMaybeHasNoValue_WhenThrowException()
{
var fakeCreateVehicleCommand = FakeCreateVehicleCommand();
var cursorMock = new Mock <IAsyncCursor <Vehicle> >();
cursorMock.Setup(c => c.Current).Returns(new List <Vehicle>());
vehicleCollectionMock
.Setup(vehicles => vehicles.FindAsync(
It.IsAny <FilterDefinition <Vehicle> >(),
It.IsAny <FindOptions <Vehicle> >(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(cursorMock.Object);
vehicleCollectionMock.Setup(ctx => ctx.InsertOneAsync(It.IsAny <Vehicle>(), null, default))
.ThrowsAsync(new Exception());
sparePartsDbContextMock.Setup(context => context.Vehicles)
.Returns(vehicleCollectionMock.Object);
var vehicleMapper = new VehicleMapper();
var createVehicleCommandHandler = new CreateVehicleCommandHandler(
sparePartsDbContextMock.Object,
loggerMock.Object,
sparePartsIntegrationEventServiceMock.Object,
clientSessionHandleMock.Object,
vehicleMapper);
var result = await createVehicleCommandHandler.Handle(fakeCreateVehicleCommand, default);
Assert.True(result.HasNoValue);
}
public IActionResult AddVehicle([FromBody] VehicleDTO vehicleDTO)
{
_logger?.LogInformation($"Inicio del servicio: [Post] https://localhost:5001/api/vehicles ");
try {
VehicleMapper vehicleMapper = MapperFactory.CreateVehicleMapper();
Entity entity = vehicleMapper.CreateEntity(vehicleDTO);
_logger?.LogInformation($" Se transformó de DTO a Entity ");
AddVehicleCommand command = CommandFactory.CreateAddVehicleCommand((Vehicle)entity);
_logger?.LogInformation($" Ejecución del comando ");
command.Execute();
return(Ok("ok " + command.GetResult()));
} catch (RequiredAttributeException ex) {
_logger?.LogWarning("Atributo requerido: " + ex.Message);
return(StatusCode(400, ex.Message));
} catch (ModelNotFoundException ex) {
_logger?.LogWarning("Modelo con Id : " + ex.ModelId + "no encontrado");
return(StatusCode(404, ex.Message + ex.ModelId));
} catch (LocationNotFoundException ex) {
_logger?.LogWarning("Lugar no encontrado");
return(StatusCode(404, ex.Message));
} catch (UniqueAttributeException ex) {
_logger?.LogWarning(ex.Message);
return(StatusCode(500, ex.Message));
}catch (InternalServerErrorException ex) {
_logger?.LogError("Error: " + ex.Ex.Message);
return(StatusCode(500, ex.Message));
} catch (Exception) {
_logger?.LogError("Error inesperado");
return(StatusCode(400));
}
}
public VehicleService(IVehicleRepository repo, IUnitOfWork unitOfWork)
{
this._repo = repo;
this.vehicleTypeService = new VehicleTypeService();
this._unitOfWork = unitOfWork;
_mapper = new VehicleMapper();
}
public CreateVehicleCommandHandler(ISparePartsDbContext sparePartsDbContext, ILogger logger, ISparePartsIntegrationEventService sparePartsIntegrationEventService, IClientSessionHandle clientSessionHandle, VehicleMapper vehicleMapper)
{
this.sparePartsDbContext = sparePartsDbContext;
this.logger = logger;
this.clientSessionHandle = clientSessionHandle;
this.sparePartsIntegrationEventService = sparePartsIntegrationEventService;
this.vehicleMapper = vehicleMapper;
}
public override Vehicle MapToVehicle(VehicleDTO vehicleDTO)
{
var mapper = new VehicleMapper();
var vehicleId = "210e1e7b45b69bde39f423be";
vehicleDTO.Id = vehicleId;
return(mapper.MapToVehicle(vehicleDTO));
}
public ActionResult CreateVehicle(VehicleModel obj)
{
var Userlist = UnitOfWork.Instance.UserRepository.GetAll().ToList();
int currentUser = Userlist.Where(s => String.Equals(s.User_windows_authent, User.Identity.Name, StringComparison.CurrentCultureIgnoreCase)).FirstOrDefault().Id;
Vehicle v = VehicleMapper.ToGlobal(obj);
v.Department_id = obj.IdDepartment;
v.User_id = currentUser;
UnitOfWork.Instance.VehicleRepository.Insert(v);
return(RedirectToAction("Vehicles"));
}
public async Task Post_NormalParameters_Sucess()
{
CreatingVehicleDto request = new CreatingVehicleDto("AA-12-BB", "A1B2C3D4E5F6G7H8I", "Miniautocarro", 1000);
var mock = new Mock <IVehicleService>();
mock.Setup(service => service.AddAsync(It.IsAny <VehicleDto>())).Returns(Task.FromResult(VehicleMapper.toDTO(request)));
VehiclesController controller = new VehiclesController(mock.Object);
var result = await controller.Create(request);
mock.Verify(service => service.AddAsync(It.IsAny <VehicleDto>()), Times.AtLeastOnce());
ActionResult <VehicleDto> VehicleDto = VehicleMapper.toDTO(request);
Assert.IsInstanceOfType(result, typeof(ActionResult <VehicleDto>));
}
public void testToDto()
{
string licensePlate = "66-99-HC";
string VIN = "12345678912345678";
String type = "Miniautocarro";
DateTime serviceAdmission = new DateTime(2020, 11, 15);
long serviceAdmissionMiliseconds = (long)(new TimeSpan(serviceAdmission.Subtract(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).Ticks)).TotalMilliseconds;
CreatingVehicleDto cvdto = new CreatingVehicleDto(licensePlate, VIN, type, serviceAdmissionMiliseconds);
VehicleDto vdto = VehicleMapper.toDTO(cvdto);
VehicleDto dto = new VehicleDto(licensePlate, VIN, type, serviceAdmission);
Assert.AreEqual(vdto.LicensePlate, dto.LicensePlate);
Assert.AreEqual(vdto.VIN, dto.VIN);
Assert.AreEqual(vdto.Type, dto.Type);
Assert.AreEqual(vdto.ServiceAdmission, dto.ServiceAdmission);
}
public ActionResult <VehicleDTO> GetVehicleById(int vehicleId)
{
_logger?.LogInformation($"Inicio del servicio: [GET] https://localhost:5001/api/vehicles/vehicleId ");
try {
GetVehicleByIdCommand command = CommandFactory.CreateGetVehicleByIdCommand(vehicleId);
_logger?.LogInformation($" Ejecución del comando ");
command.Execute();
VehicleMapper vehicleMapper = MapperFactory.CreateVehicleMapper();
return(Ok(vehicleMapper.CreateDTO(command.GetResult())));
} catch (VehicleNotFoundException ex) {
_logger?.LogWarning("Vehiculo con Id : " + ex.VehicleId + "no encontrado");
return(StatusCode(404, ex.Message + ex.VehicleId));
} catch (InternalServerErrorException ex) {
_logger?.LogError("Error: " + ex.Ex.Message);
return(StatusCode(500, ex.Message));
} catch (Exception) {
_logger?.LogError("Error inesperado");
return(StatusCode(400));
}
}
public ActionResult <List <Vehicle> > GetVehicles()
{
_logger?.LogInformation($"Inicio del servicio: [GET] https://localhost:5001/api/vehicles ");
try {
GetVehiclesCommand command =
CommandFactory.CreateGetVehiclesCommand();
_logger?.LogInformation($" Ejecución del comando ");
command.Execute();
VehicleMapper vehicleMapper = MapperFactory.CreateVehicleMapper();
return(Ok(command.GetResult()));
} catch (NotVehiclesAvailableException ex) {
_logger?.LogWarning(ex.Message);
return(StatusCode(404, ex.Message));
} catch (InternalServerErrorException ex) {
_logger?.LogError("Error: " + ex.Ex.Message);
return(StatusCode(500, ex.Message));
} catch (Exception) {
_logger?.LogError("Error inesperado");
return(StatusCode(400));
}
}
public void testToDomain()
{
string licensePlate = "66-99-HC";
string VIN = "12345678912345678";
String type = "Miniautocarro";
DateTime serviceAdmission = new DateTime(2020, 11, 15);
VehicleType vType = new VehicleType("Miniautocarro");
long serviceAdmissionMiliseconds = (long)(new TimeSpan(serviceAdmission.Subtract(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).Ticks)).TotalMilliseconds;
CreatingVehicleDto cvdto = new CreatingVehicleDto(licensePlate, VIN, type, serviceAdmissionMiliseconds);
Vehicle vMapper = VehicleMapper.toDomain(VehicleMapper.toDTO(cvdto));
Vehicle v = new Vehicle(licensePlate, VIN, vType, serviceAdmission);
Assert.AreEqual(vMapper.LicensePlate, v.LicensePlate);
Assert.AreEqual(vMapper.VIN, v.VIN);
Assert.AreEqual <String>(vMapper.Type.Value, v.Type.Value);
Assert.AreEqual(vMapper.ServiceAdmission, v.ServiceAdmission);
}
public async Task Post_NormalParameters_Sucess()
{
CreatingVehicleDto creatingVehicleDto = new CreatingVehicleDto("AA-12-BB", "A1B2C3D4E5F6G7H8I", "Miniautocarro", 1000);
VehicleDto VehicleDto = VehicleMapper.toDTO(creatingVehicleDto);
Vehicle Vehicle = VehicleMapper.toDomain(VehicleDto);
var mockRepository = new Mock <IVehicleRepository>();
mockRepository.Setup(repository => repository.AddAsync(It.IsAny <Vehicle>())).Returns(Task.FromResult(Vehicle));
var mockUnit = new Mock <IUnitOfWork>();
VehicleService VehicleService = new VehicleService(mockUnit.Object, mockRepository.Object);
VehiclesController controller = new VehiclesController(VehicleService);
var result = await controller.Create(creatingVehicleDto);
mockRepository.Verify(repository => repository.AddAsync(It.IsAny <Vehicle>()), Times.AtLeastOnce());
mockUnit.Verify(unit => unit.CommitAsync(), Times.AtLeastOnce());
Assert.IsInstanceOfType(result, typeof(ActionResult <VehicleDto>));
}
public void MapDamageToDamageDTOTest()
{
VehicleDTO vehicle = this.CreateVehicle();
DamageMapper mapper = new DamageMapper();
Base64Image base64Image = new Base64Image();
base64Image.Base64EncodedImage = Convert.ToBase64String(File.ReadAllBytes(@"..\..\Damage\attention.png"));
VehicleMapper vehicleMapper = new VehicleMapper();
Damage damage = new Damage();
damage.Description = "Daño en la puerta derecha";
damage.Images = new List <Base64Image>();
damage.Images.Add(base64Image);
DamageDTO damageDTO = mapper.ToDTO(damage);
Assert.AreEqual(damage.Description, damageDTO.Description);
foreach (Base64Image image in damage.Images)
{
Assert.IsNotNull(damageDTO.Images.Find(i => i.Base64EncodedImage == image.Base64EncodedImage));
}
}
public void DTOtoDomain()
{
var mapper = new VehicleMapper();
string registration = "AA11AA";
string vin = "123456789AAAAAAAA";
string entranceDate = "27/01/1978";
string vehicleType = "vehicleType1";
var vehicle = new Vehicle(registration, vin, entranceDate, vehicleType);
var expected = new VehicleDTO(
vehicle.Id.AsGuid(),
vehicle.registration.vehicleRegistration,
vehicle.vin.vin,
vehicle.entranceDate.vehicleEntranceDate,
vehicle.vehicleType.id);
var actual = mapper.DomainToDTO(vehicle);
}
public VehicleDAOImpl()
{
mapper = new VehicleMapper();
}
private void getVehicles()
{
_vehicleMapper = new VehicleMapper();
_vehicles = _vehicleMapper.GetVehicles(db);
}
public GetVehicleTechSpecificationsByManufacturerModelGenerationQueryHandler(ISparePartsDbContext sparePartsDbContext, VehicleMapper vehicleMapper)
{
this.sparePartsDbContext = sparePartsDbContext;
this.vehicleMapper = vehicleMapper;
}
public GetVehicleModlesByManufacturerQueryHandler(ISparePartsDbContext sparePartsDbContext, VehicleMapper vehicleMapper, ILogger logger)
{
this.sparePartsDbContext = sparePartsDbContext;
this.vehicleMapper = vehicleMapper;
this.logger = logger;
}
