public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResource vehicleResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// check whether current user sent a request
var currentUser = await userRepository.GetCurrentUser();
if (currentUser.Id != vehicleResource.IdentityId)
{
return(NotFound());
}
var vehicle = mapper.Map <Vehicle>(vehicleResource);
vehicle.LastUpdated = DateTime.Now;
await vehicleRepository.AddAsync(vehicle);
await uow.CommitAsync();
vehicle = await vehicleRepository.GetAsync(vehicle.VehicleId);
var vr = mapper.Map <VehicleResource>(vehicle);
return(Ok(vr));
}
public async Task AddAsync(VehicleModel model, Guid userID)
{
Validate(model);
if (model.Plate.Length != 8)
{
throw new CustomExceptions("Formato invalido de placa, deve ter no máximo 8 caracteres");
}
var company = await _userCompanyRepository.FirstOrDefaultAsync(x => x.UserID.Equals(userID.ToString()));
if (await _vehicleRepository.AnyAsync(x => x.CompanyID == company.CompanyID && x.Plate.Equals(model.Plate)))
{
throw new CustomExceptions("Placa já cadastrada");
}
await _vehicleRepository.AddAsync(new Vehicle
{
Color = model.Color,
CompanyID = company.CompanyID,
CreatedDate = DateTimeOffset.UtcNow,
ID = Guid.NewGuid(),
Make = model.Make,
Plate = model.Plate,
TypeID = model.TypeID,
Model = model.Model,
});
await _vehicleRepository.SaveChangeAsync();
}
public async Task StartAsyncService()
{
var vehicles = await _cooperlinkHttpService.GetLocationVehicle();
var lastVehice = await _vehicleRepository.LastDocumentAsync();
foreach (var vehicle in vehicles)
{
_logger.LogInformation($"Vehicle location at: {DateTimeOffset.Now}");
await _vehicleRepository.AddAsync(vehicle);
if (lastVehice != null && vehicle.LastLocation.LocationWithinRadius(_baseLocation, _radius, _distanceType))
{
_logger.LogCritical($"Vehicle within radius at: {DateTimeOffset.Now}");
if (vehicle.LastLocation.AllowedOpenGate(lastVehice.LastLocation, _baseLocation, _radius, _distanceType))
{
_brokerMqtt.PublishMessageDefaultTopic(_brokerMqttConfig.Payload);
_logger.LogCritical($"Open gate at: {DateTimeOffset.Now}");
}
if (vehicle.LastLocation.Ignition != lastVehice.LastLocation.Ignition)
{
_brokerMqtt.PublishMessage("vehicle/cb300", vehicle.LastLocation.Ignition == EIgnition.ON ? "IgnitionOn" : "IgnitionOff");
}
}
}
}
public async Task <IActionResult> AddVehicle(AddVehicleViewModel model)
{
try
{
var make = await _makeRepo.GetMakeAsync(model.Make);
if (make == null)
{
return(NotFound("Kunde inte hitta en tillverkare med namn: " + model.Make));
}
var vehicle = new Vehicle
{
RegistrationNumber = model.RegistrationNumber,
Make = make,
Model = model.Model,
ModelYear = model.ModelYear,
Mileage = model.Mileage,
FuelType = model.FuelType,
GearType = model.GearType
};
await _repo.AddAsync(vehicle);
if (await _repo.SaveAllChangesAsync())
{
return(StatusCode(201));
}
return(StatusCode(500, "Det gick inget vidare!"));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public async Task <IActionResult> CreateVehiclesAsync([FromBody] SaveVehicleResource vehicleResource)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var vehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.LastUpdate = DateTime.Now;
await repository.AddAsync(vehicle);
await unitOfWork.CompleteAsync();
vehicle = await repository.GetVehicleAsync(vehicle.Id);
var result = mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(result));
}
catch (Exception)
{
return(StatusCode(500, new { error = "Something Went Wrong" }));
}
}
public async Task HandleAsync(AddVehicleCommand command)
{
var owner = await _customerService.GetAsync(command.OwnerId)
.AnyContext();
if (owner == null)
{
throw new AccException("customer_not_found", $"Customer: '{command.OwnerId}' was not found");
}
var vehicle = new Vehicle(command.Id,
command.RegNr,
command.Color,
command.Brand,
command.Model,
command.Description,
command.OwnerId,
owner.Name);
await _vehicleRepository.AddAsync(vehicle)
.AnyContext();
var @event = new VehicleAddedEvent(vehicle.Id, vehicle.RegNr, vehicle.OwnerId);
await _busPublisher.PublishAsync(@event)
.AnyContext();
}
/// <summary>
/// Creates new vehicle
/// </summary>
/// <param name="vehicleViewModel"></param>
/// <param name="userId"></param>
/// <param name="ct"></param>
/// <returns></returns>
public async Task <VehicleViewModel> AddVehicleAsync(VehicleRequestViewModel vehicleViewModel, string userId, CancellationToken ct = default(CancellationToken))
{
var vehicle = new Vehicle
{
Plate = vehicleViewModel.Plate,
UserId = int.Parse(userId),
CreatedAt = DateTime.Now
};
vehicle = await _repository.AddAsync(vehicle, ct);
return(VehicleConverter.Convert(vehicle));
}
/// <summary>
/// Business logic for adding new vehicle
/// </summary>
/// <param name="vehicle">vehicle data</param>
/// <returns>True or false</returns>
public async Task <bool> AddVehicleAsync(VehicleRequest data)
{
// Check if vehicle exists by plate before adding
var vehicle = await _vehicleRepository.GetDetailAsync(v => v.Plate.Equals(data.Plate));
// Check if driver exists by DNI before adding
var driver = await _driverRepository.GetDetailAsync(d => d.Dni.Equals(data.Driver.Dni));
// If vehicle exists, or driver doesn't exist or driver has more than 10 vehicles, return error
if (vehicle != null || driver == null || driver.Vehicles.Count > 10)
{
return(false);
}
return(await _vehicleRepository.AddAsync(data));
}
public async Task <IActionResult> AddVehicle(Vehicle vehicle)
{
try
{
await _repo.AddAsync(vehicle);
if (await _repo.SaveAllChangesAsync())
{
return(StatusCode(201));
}
return(StatusCode(500, "Det gick inget vidare!"));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResource vehicleResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var vehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.LastUpdate = DateTime.Now;
await repository.AddAsync(vehicle);
await unitOfWork.CompleteAsync();
vehicle = await repository.GetVehicle(vehicle.Id);
return(base.Ok(mapper.Map <Vehicle, VehicleResource>(vehicle)));
}
public async Task<int> Post([FromBody]Vehicle vehicle)
{
vehicle.CarrierId = await _securityContext.GetCarrierId(User.Identity);
return await _vehicleRepository.AddAsync(vehicle);
}
protected override async Task CustomSeedAsync()
{
var rootPath = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
Console.WriteLine($"START Seeding MicroservicesTest.ApiGateway From :{rootPath}");
var CustomersJson = @"[
{
'Id': 'e43c5a9e-6bd9-4d89-bf1a-014e09868210',
'Name': 'Kalles Grustransporter AB',
'Address': 'Cementvägen 8, 111 11 Södertälje'
},
{
'Id': 'd6e2e016-9f07-4e08-b018-7d8d21fe73d1',
'Name': 'Johans Bulk AB',
'Address': 'Balkvägen 12, 222 22 Stockholm'
},
{
'Id': 'fd267078-3516-4332-a0ec-69c12ce862aa',
'Name': 'Haralds Värdetransporter AB',
'Address': 'Budgetvägen 1, 333 33 Uppsala '
}
]";
//File.ReadAllText(rootPath+@"\SeedData\CustomersData.json");
var Customers = JsonConvert.DeserializeObject <List <Customer> >(CustomersJson);
await Task.WhenAll(Customers.Select(x => _customerRepository
.AddAsync(new Customer(x.Id, x.Name, x.Address))));
var VehiclesJson = @"[
{
'CustomerId': 'e43c5a9e-6bd9-4d89-bf1a-014e09868210',
'VehicleId': 'YS2R4X20005399401',
'RegNo': 'ABC123',
'LatestStatus': false,
'LatestPingAt': null
},
{
'CustomerId': 'e43c5a9e-6bd9-4d89-bf1a-014e09868210',
'VehicleId': 'VLUR4X20009093588',
'RegNo': 'DEF456',
'LatestStatus': false,
'LatestPingAt': null
},
{
'CustomerId': 'e43c5a9e-6bd9-4d89-bf1a-014e09868210',
'VehicleId': 'VLUR4X20009048066',
'RegNo': 'GHI789',
'LatestStatus': false,
'LatestPingAt': null
},
{
'CustomerId': 'd6e2e016-9f07-4e08-b018-7d8d21fe73d1',
'VehicleId': 'YS2R4X20005388011',
'RegNo': 'JKL012 ',
'LatestStatus': false,
'LatestPingAt': null
},
{
'CustomerId': 'd6e2e016-9f07-4e08-b018-7d8d21fe73d1',
'VehicleId': 'YS2R4X20005387949',
'RegNo': 'MNO345',
'LatestStatus': false,
'LatestPingAt': null
},
{
'CustomerId': 'fd267078-3516-4332-a0ec-69c12ce862aa',
'VehicleId': 'YS2R4X20005387765',
'RegNo': 'PQR678 ',
'LatestStatus': false,
'LatestPingAt': null
},
{
'CustomerId': 'fd267078-3516-4332-a0ec-69c12ce862aa',
'VehicleId': 'YS2R4X20005387055',
'RegNo': 'STU901 ',
'LatestStatus': false,
'LatestPingAt': null
}
]
";
// File.ReadAllText(rootPath + @"\SeedData\VehiclesData.json");
var Vehicles = JsonConvert.DeserializeObject <List <Vehicle> >(VehiclesJson);
await Task.WhenAll(Vehicles.Select(x => _vehicleRepository
.AddAsync(new Vehicle(x.CustomerId, x.VehicleId, x.RegNo))));
Console.WriteLine($"END Seeding MicroservicesTest.ApiGateway");
}
public async Task AddAsync(Vehicle vehicle)
{
await _vehicleRepo.AddAsync(vehicle);
}
public async Task <int> AddVehicle(Vehicle vehicle, ApplicationDbContext dbContext)
{
vehicle.ID = Guid.NewGuid();
return(await VehicleRepository.AddAsync(vehicle, dbContext));
}
public async Task Handle(AddVehicleEvent notification, CancellationToken cancellationToken)
{
await vehicleRepository.AddAsync(notification.Vehicle);
}
public async Task <IActionResult> PostAsync([FromBody] SaveVehicle vehicle)
{
var vehicleResult = await _repository.AddAsync(vehicle);
return(Ok(vehicleResult));
}
