public async Task <ActionResult <DriverDto> > Create(CreatingDriverDto obj)
{
var dto = DriverMapper.toDTO(obj);
var driver = await _service.AddAsync(dto);
return(CreatedAtAction(nameof(GetGetById), new { Id = driver.Id }, driver));
}
public void MapDrivers_ThreeDrivers_FromValidData(DriverMapper mapper,
DriverCodeGenerator driverCodeGenerator,
string team, string status)
{
var code1 = driverCodeGenerator.Generate().Code;
var code2 = driverCodeGenerator.Generate().Code;
var code3 = driverCodeGenerator.Generate().Code;
var driverDtoCollection = new List <DriverDto>
{
new DriverDto(code1, "John", "Read"),
new DriverDto(code2, "Sarah", "Jones"),
new DriverDto(code3, "Paul", "Kim")
};
var raceResultDto = new List <RaceResultDto>
{
new RaceResultDto(code1, 1, team, status),
new RaceResultDto(code2, 2, team, status),
new RaceResultDto(code3, 3, team, status),
};
var drivers = mapper.ToDriver(driverDtoCollection, raceResultDto);
Assert.NotNull(drivers);
Assert.Equal(3, drivers.Count);
}
public SimpleTestContainer()
{
var domainEventPublisher = new SimpleEventPublisher();
var uoW = new MemoryCarRentalUoW(
new MemoryRepository <Driver>(),
new MemoryRepository <Car>(),
new MemoryRepository <Rental>(),
new MemoryRepository <Office>()
);
var freeMinutesPolicyFactory = new FreeMinutesPolicy();
var rentalFactory = new RentalFactory(domainEventPublisher);
var carMapper = new CarMapper();
var driverMapper = new DriverMapper();
var rentalMapper = new RentalMapper();
var officeMapper = new OfficeMapper();
DriverService = new DriverService(uoW, driverMapper, domainEventPublisher);
CarService = new CarService(uoW, carMapper, domainEventPublisher);
RentalService = new RentalService(uoW, rentalMapper, domainEventPublisher, rentalFactory, freeMinutesPolicyFactory);
FinishRentalService = new StopRentalService(uoW, domainEventPublisher);
OfficeService = new OfficeService(uoW, officeMapper, domainEventPublisher);
}
public void Edit(DriverModel driverModel)
{
try
{
Driver driver = dbContext.Drivers.Where(x => x.Id == driverModel.Id).FirstOrDefault();
if (driver == null)
{
base.HandleError(driverModel, CommonLayer.LookUps.ErrorType.Critical, null, Resources.NotFound);
return;
}
if (Validate(driverModel))
{
return;
}
DriverMapper.Map(dbContext, driverModel, driver);
base.SaveChanges();
driverModel.AddSuccess(Resources.DriverUpdatedSuccessfully, LookUps.SuccessType.Full);
}
catch (Exception ex)
{
base.HandleError(driverModel, CommonLayer.LookUps.ErrorType.Exception, ex);
base.UndoUpdates();
}
}
public DriverService(ICarRentalUnitOfWork unitOfWork,
DriverMapper driverMapper,
IDomainEventPublisher domainEventPublisher)
{
this._unitOfWork = unitOfWork;
this._driverMapper = driverMapper;
this._domainEventPublisher = domainEventPublisher;
}
public SimpleTestContainer()
{
// domain event publisher
var domainEventPublisher = new SimpleEventPublisher();
// infrastructure service
var emaildispatcher = new EmailDispatcher();
// event listeners
var driverCreatedEventListener = new DriverCreatedEventListener();
domainEventPublisher.Subscribe <DriverCreatedEvent>(driverCreatedEventListener);
//unitOfWork
var unitOfWork = new MemoryCarRentalUnitOfWork(
new MemoryRepository <Driver>(),
new MemoryRepository <Car>(),
new MemoryRepository <Rental>(),
new MemoryRepository <Scooter>());
// factories
var rentalFactory = new RentalFactory(domainEventPublisher);
var carFactory = new CarFactory(domainEventPublisher);
var freeMinutesFactory = new FreeMinutesFactory();
// mappers
var carMapper = new CarMapper();
var driverMapper = new DriverMapper();
var scooterMapper = new ScooterMapper();
var rentalMapper = new RentalMapper();
this.CarService = new CarService(
unitOfWork,
carMapper,
domainEventPublisher);
this.ScooterService = new ScooterService(
unitOfWork,
scooterMapper,
domainEventPublisher);
this.DriverService = new DriverService(
unitOfWork,
driverMapper,
domainEventPublisher);
this.RentalService = new RentalService(
unitOfWork,
rentalFactory,
rentalMapper,
freeMinutesFactory,
domainEventPublisher);
}
public async Task Post_NormalParameters_Sucess()
{
CreatingDriverDto request = new CreatingDriverDto("DriverA10", "lalala", 876263907, 14352011, 227012657, 927638614, 3495566307, new string[] { "Driver:1", "Driver:2", "Driver:3" }, 1128724707, 0);
var mock = new Mock <IDriverService>();
mock.Setup(service => service.AddAsync(It.IsAny <DriverDto>())).Returns(Task.FromResult(DriverMapper.toDTO(request)));
DriversController controller = new DriversController(mock.Object);
var result = await controller.Create(request);
mock.Verify(service => service.AddAsync(It.IsAny <DriverDto>()), Times.AtLeastOnce());
ActionResult <DriverDto> driverDto = DriverMapper.toDTO(request);
Assert.IsInstanceOfType(result, typeof(ActionResult <DriverDto>));
}
/// <summary>
/// Get all driver records
/// </summary>
/// <returns></returns>
public IEnumerable <Driver> GetAllDrivers()
{
var driverList = new List <Driver>();
using (var command = new SqlCommand("sp_GetAllDrivers", _connection))
{
command.CommandType = CommandType.StoredProcedure;
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var driver = DriverMapper.Map(reader);
driverList.Add(driver);
}
}
}
return(driverList);
}
public void MapToDriver_FromDto_ForSingleDriver(DriverMapper mapper, DriverCodeGenerator driverCodeGenerator, string team, string status)
{
var code = driverCodeGenerator.Generate().Code;
var drivers = new List <DriverDto> {
new DriverDto(code, "John", "Read")
};
var raceResultDto = new List <RaceResultDto>
{
new RaceResultDto(code, 1, team, status)
};
var driver = mapper.ToDriver(drivers, raceResultDto).Single();
Assert.Equal(new DriverCode(code), driver.DriverCode);
Assert.Equal(1, driver.FinishStatus.Position);
Assert.Equal(status, driver.FinishStatus.Status);
Assert.Equal(team, driver.Team);
Assert.NotNull(driver.Name);
}
/// <summary>
/// Get drivers by driver status
/// </summary>
/// <param name="driverStatus"></param>
/// <returns></returns>
public IEnumerable <Driver> GetAllDriversByDriverStatus(int driverStatus)
{
var driverList = new List <Driver>();
using (var command = new SqlCommand("sp_GetAllDriversByDriverStatus", _connection))
{
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddWithValue("@DriverStatus", driverStatus);
var driver = new Driver();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
driver = DriverMapper.Map(reader);
driverList.Add(driver);
}
}
return(driverList);
}
}
public void GetDriverModel(DriverModel driverModel)
{
try
{
Driver driver = dbContext.Drivers.Where(x => x.Id == driverModel.Id).FirstOrDefault();
if (driver == null)
{
base.HandleError(driverModel, CommonLayer.LookUps.ErrorType.Critical, null, Resources.NotFound);
}
else
{
DriverMapper.Map(dbContext, driver, driverModel);
}
}
catch (Exception ex)
{
base.HandleError(driverModel, CommonLayer.LookUps.ErrorType.Critical, ex);
}
}
public async Task Post_NormalParameters_Sucess()
{
CreatingDriverDto creatingDriverDto = new CreatingDriverDto("DriverA10", "lalala", 876263907, 14352011, 227012657, 927638614, 3495566307000, new string[] { "Driver:1", "Driver:2", "Driver:3" }, 1128724707, 0);
DriverDto driverDto = DriverMapper.toDTO(creatingDriverDto);
Driver driver = DriverMapper.toDomain(driverDto);
var mockRepository = new Mock <IDriverRepository>();
mockRepository.Setup(repository => repository.AddAsync(It.IsAny <Driver>())).Returns(Task.FromResult(driver));
var mockUnit = new Mock <IUnitOfWork>();
DriverService driverService = new DriverService(mockUnit.Object, mockRepository.Object);
DriversController controller = new DriversController(driverService);
var result = await controller.Create(creatingDriverDto);
mockRepository.Verify(repository => repository.AddAsync(It.IsAny <Driver>()), Times.AtLeastOnce());
mockUnit.Verify(unit => unit.CommitAsync(), Times.AtLeastOnce());
Assert.IsInstanceOfType(result, typeof(ActionResult <DriverDto>));
}
public void MapOneDriver_FromImbalancedInputData_WithRaceDataForTwoDrivers(DriverMapper mapper,
DriverCodeGenerator driverCodeGenerator,
string team, string status)
{
var code = driverCodeGenerator.Generate().Code;
var drivers = new List <DriverDto>
{
new DriverDto(code, "John", "Read"),
};
var raceResultDto = new List <RaceResultDto>
{
new RaceResultDto(code, 1, team, status),
new RaceResultDto(driverCodeGenerator.Generate().Code, 2, team, status),
};
var driver = mapper.ToDriver(drivers, raceResultDto).Single();
Assert.Equal(new DriverCode(code), driver.DriverCode);
Assert.Equal("John", driver.Name.FirstName);
Assert.Equal("Read", driver.Name.Surname);
}
public void DTOtoDomain()
{
var mapper = new DriverMapper();
string mecanographicNumber = "D-103";
string driverName = "Driver Teste";
string birthDate = "12/12/1971";
long citizenCardNumber = 11144477;
long driverNIF = 159951159;
string entranceDate = "27/01/1978";
string departureDate = "31/05/2020";
string numberDriverLicense = "P-1111111 1";
string dateDriverLicense = "12/10/2020";
var driverType = new DriverTypeId("driverType1");
List <DriverTypeId> listDriverTypes = new List <DriverTypeId>();
listDriverTypes.Add(driverType);
List <string> list = new List <string>();
list.Add(driverType.id);
var driver = new Driver(mecanographicNumber, driverName, birthDate, citizenCardNumber, driverNIF, entranceDate, departureDate, numberDriverLicense, dateDriverLicense, listDriverTypes);
var expected = new DriverDTO(
driver.Id.AsGuid(),
driver.mecanographicNumber.mecanographicNumber,
new CitizenCardDTO(driver.citizenCard.Id.AsGuid(), driver.citizenCard.driverName.driverName, driver.citizenCard.birthDate.date, driver.citizenCard.citizenCardNumber.citizenCardNumber, driver.citizenCard.driverNIF.nif),
driver.entranceDate.date,
driver.departureDate.date,
new LicenseDTO(driver.driverLicense.Id.AsGuid(), driver.driverLicense.numberDriverLicense.numberDriverLicense, driver.driverLicense.driverLicenseDate.date),
list);
var actual = mapper.DomainToDTO(driver, list);
Assert.Equal(actual, expected);
}
public void Create(DriverModel driverModel)
{
try
{
if (Validate(driverModel))
{
return;
}
using (var transaction = dbContext.Database.BeginTransaction())
{
try
{
Driver driver = new Driver();
DriverMapper.Map(dbContext, driverModel, driver);
driver.Id = Guid.NewGuid().ToString();
dbContext.Drivers.Add(driver);
base.SaveChanges();
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
throw ex;
}
driverModel.AddSuccess(Resources.DriverAddedSuccessfully, LookUps.SuccessType.Full);
}
}
catch (Exception ex)
{
base.HandleError(driverModel, CommonLayer.LookUps.ErrorType.Exception, ex);
base.UndoUpdates();
}
}
public TestContainer()
{
UnitOfWork = new MemoryCarRentalUnitOfWork();
var carFactory = new CarFactory();
var driverFactory = new DriverFactory();
_rentalFactory = new RentalFactory();
var rentalAreaFactory = new RentalAreaFactory();
var positionService = new PositionService(UnitOfWork);
var carMapper = new CarMapper();
var driverMapper = new DriverMapper();
_rentalMapper = new RentalMapper();
var rentalAreaMapper = new RentalAreaMapper();
CarService = new CarService(carFactory, UnitOfWork, carMapper);
DriverService = new DriverService(driverFactory, UnitOfWork, driverMapper);
RentalService = new RentalService(_rentalFactory, UnitOfWork, _rentalMapper, positionService);
RentalAreaService = new RentalAreaService(rentalAreaFactory, UnitOfWork, rentalAreaMapper);
}
public GenericListModel <DriverModel> GetDrivers(Select2Parameters <bool> select2Parameters)
{
GenericListModel <DriverModel> baseListModel = new GenericListModel <DriverModel>();
try
{
IQueryable <Driver> drivers = prepareSearch(select2Parameters.text);
drivers = drivers.OrderBy(x => x.CreatedAt);
baseListModel.Total = drivers.Count();
drivers = drivers.Skip(select2Parameters.start);
drivers = drivers.Take(select2Parameters.pageSize);
DriverMapper.Map(dbContext, drivers.ToList(), baseListModel.List);
}
catch (Exception ex)
{
base.HandleError(baseListModel, CommonLayer.LookUps.ErrorType.Critical, ex);
}
return(baseListModel);
}
public void testToDomain()
{
String mNumber = "12a45678b";
String name = "DriverTest";
DateTime birthDate = new DateTime(2000, 06, 14, 0, 0, 0, DateTimeKind.Utc);
int cardNumber = 12345678;
int NIF = 987654321;
int drivingLicense = 123456789;
DateTime drivingLicenseExpirationDate = new DateTime(2024, 05, 01, 0, 0, 0, DateTimeKind.Utc);
List <String> DriverTypes = new List <String> {
"Linguas", "Experiente"
};
DateTime EntryDateCompany = new DateTime(2018, 07, 01, 0, 0, 0, DateTimeKind.Utc);
DateTime DepartureDateCompany = new DateTime(2019, 01, 01, 0, 0, 0, DateTimeKind.Utc);
long birthDateMiliseconds = (long)(new TimeSpan(birthDate.Subtract(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).Ticks)).TotalMilliseconds;
long drivingLicenseExpirationDateMiliseconds = (long)(new TimeSpan(drivingLicenseExpirationDate.Subtract(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).Ticks)).TotalMilliseconds;
long EntryDateCompanyMiliseconds = (long)(new TimeSpan(EntryDateCompany.Subtract(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).Ticks)).TotalMilliseconds;
long DepartureDateCompanyMiliseconds = (long)(new TimeSpan(DepartureDateCompany.Subtract(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).Ticks)).TotalMilliseconds;
CreatingDriverDto cdto = new CreatingDriverDto(mNumber, name, birthDateMiliseconds, cardNumber, NIF, drivingLicense, drivingLicenseExpirationDateMiliseconds, DriverTypes.ToArray(), EntryDateCompanyMiliseconds, DepartureDateCompanyMiliseconds);
Driver domainMapper = DriverMapper.toDomain(DriverMapper.toDTO(cdto));
Driver d = new Driver(mNumber, name, birthDate, cardNumber, NIF, drivingLicense, drivingLicenseExpirationDate, DriverTypes, EntryDateCompany, DepartureDateCompany);
Assert.AreEqual(d.MechanographicNumber, domainMapper.MechanographicNumber);
Assert.AreEqual(d.Name, domainMapper.Name);
Assert.AreEqual(d.DateBirth, domainMapper.DateBirth);
Assert.AreEqual(d.CitizenCardNumber, domainMapper.CitizenCardNumber);
Assert.AreEqual(d.NIF, domainMapper.NIF);
Assert.AreEqual(d.DrivingLicenseNumber, domainMapper.DrivingLicenseNumber);
Assert.AreEqual(d.EntryDateCompany, domainMapper.EntryDateCompany);
Assert.AreEqual(d.DepartureDateCompany, domainMapper.DepartureDateCompany);
Assert.AreEqual(d.DrivingLicenseExpirationDate, domainMapper.DrivingLicenseExpirationDate);
}
public GenericListModel <DriverModel> GetSearchDriversList(DataTableSearchParameters <Nullable <bool> > dataTableSearchParameters)
{
GenericListModel <DriverModel> baseListModel = new GenericListModel <DriverModel>();
try
{
//if (!base.DriverHasPermision(baseListModel))
// return baseListModel;
IQueryable <Driver> drivers = prepareSearch(dataTableSearchParameters.search.value);
foreach (JQDTColumnOrder order in dataTableSearchParameters.order)
{
switch (order.column)
{
case 0:
if (order.dir == JQDTColumnOrderDirection.asc)
{
drivers = drivers.OrderBy(c => c.Name);
}
else
{
drivers = drivers.OrderByDescending(c => c.Name);
}
break;
case 1:
if (order.dir == JQDTColumnOrderDirection.asc)
{
drivers = drivers.OrderBy(c => c.StartDate);
}
else
{
drivers = drivers.OrderByDescending(c => c.StartDate);
}
break;
case 2:
if (order.dir == JQDTColumnOrderDirection.asc)
{
drivers = drivers.OrderBy(c => c.ContactNumber);
}
else
{
drivers = drivers.OrderByDescending(c => c.ContactNumber);
}
break;
}
}
baseListModel.Total = drivers.Count();
drivers = drivers.Skip(dataTableSearchParameters.start);
if (dataTableSearchParameters.length != -1)
{
drivers = drivers.Take(dataTableSearchParameters.length);
}
DriverMapper.Map(dbContext, drivers.ToList(), baseListModel.List);
}
catch (Exception ex)
{
base.HandleError(baseListModel, CommonLayer.LookUps.ErrorType.Critical, ex);
}
return(baseListModel);
}
public DriverCrud()
{
Mapper = new DriverMapper();
Dao = SqlDao.GetInstance();
}
public DriverService(IDriverRepository repo, IUnitOfWork unitOfWork)
{
this._repo = repo;
this._unitOfWork = unitOfWork;
this._mapper = new DriverMapper();
}
public DriverService(DriverFactory driverFactory, ICarRentalUnitOfWork unitOfWork, DriverMapper driverMapper)
{
_driverFactory = driverFactory;
_unitOfWork = unitOfWork;
_driverMapper = driverMapper;
}
public DriverService(ICarRentalUoW uoW, DriverMapper driverMapper, IDomainEventPublisher domainEventPublisher)
{
_uoW = uoW;
_driverMapper = driverMapper;
_domainEventPublisher = domainEventPublisher;
}
/// <summary>
/// Tries to load the driver.
/// </summary>
/// <param name="Driver">The driver.</param>
public bool TryLoadDriver(IDriver Driver)
{
//
// Tries to load the exploitable intel driver.
//
var IqvDriverMapper = new DriverMapper();
if (!IqvDriverMapper.Setup())
{
IqvDriverMapper.Dispose();
Log.Error(this, "Failed to setup the driver mapper.");
return(false);
}
//
// Tries to map our driver using the intel driver.
//
var WasDriverMapped = false;
if (this.Config != null)
{
WasDriverMapped = IqvDriverMapper.MapDriver(this.DriverBuffer, this.Config.FirstEventName, this.Config.SecondEventName, this.Config.MapAddress);
}
else
{
WasDriverMapped = IqvDriverMapper.MapDriver(this.DriverBuffer);
}
//
// If it failed to map the driver...
//
if (!WasDriverMapped)
{
Log.Error(this, "Failed to map the driver.");
return(false);
}
//
// Set the flags.
//
this.IsLoaded = true;
//
// Execute the handlers subscribed to the event.
//
if (this.OnLoaded != null)
{
try
{
this.OnLoaded.Invoke(this, EventArgs.Empty);
}
catch (Exception)
{
// ...
}
}
return(true);
}
