public async Task <Result <BikeResponse> > UpdateBikeAsync(UpdateBikeCommand request)
{
var bikeResult = await _bikeRepository.GetBikeAsync(request.Id);
BikeResponse bikeInDb = new BikeResponse();
bikeResult.Match(s => bikeInDb = s,
f => new Result <BikeResponse>(f));
if (bikeResult.IsFaulted)
{
return(bikeResult);
}
// validation if bike is being added to the specific HomeBase ...
if (request.HomeBaseId is not null && bikeInDb.HomeBaseId != request.HomeBaseId)
{
if (!_homeBaseService.CheckIfExistsAsync(request.HomeBaseId))
{
return(new Result <BikeResponse>(new BadRequestException(Error.HomeBaseNotFound)));
}
if (!await _homeBaseService.CheckIfFreeSlotsAsync(request.HomeBaseId))
{
return(new Result <BikeResponse>(new BadRequestException(Error.HomeBaseFull)));
}
}
return(await _bikeRepository.UpdateBikeAsync(request));
}
public ActionResult <BikeResponse> GetBike(int bikeId)
{
var bikeFromDb = _context.Bikes.Find(bikeId);
if (bikeFromDb == null)
{
return(NotFound($"Bicycle with Id = {bikeId} doesn't exist."));
}
var bikeResponse = new BikeResponse
{
BikeId = bikeFromDb.BikeId,
FrameNumber = bikeFromDb.FrameNumber,
BikeTypeId = bikeFromDb.BikeTypeId
};
return(Ok(bikeResponse));
}
public async Task <ActionResult <BikeResponse> > AddBike([FromBody] AddBikeRequest request)
{
var bike = new Bike
{
FrameNumber = request.FrameNumber,
BikeTypeId = request.BikeTypeId
};
_context.Bikes.Add(bike);
await _context.SaveChangesAsync();
var bikeResponse = new BikeResponse
{
FrameNumber = bike.FrameNumber,
BikeId = bike.BikeId,
BikeTypeId = bike.BikeTypeId
};
return(CreatedAtRoute(nameof(GetBike), new { bikeId = bikeResponse.BikeId }, bikeResponse));
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
_consumer.Received += (async(sender, e) =>
{
using (var scope = _serviceProvider.CreateScope())
{
var decodedMessage = DecodeMessage(e);
if (decodedMessage.MessageType == "HomeBaseResponse")
{
var service = scope.ServiceProvider.GetRequiredService <IHomeBaseService>();
var decodedBase = DecodeHomeBase(e);
var homeBaseResponse = decodedBase.Message;
var homeBase = _mapper.Map <HomeBaseResponse, HomeBase>(homeBaseResponse);
switch (decodedMessage.Method)
{
case nameof(ApiMethod.POST):
{
await service.AddHomeBaseAsync(homeBase);
break;
}
case nameof(ApiMethod.DELETE):
{
await service.DeleteHomeBaseAsync(homeBase);
break;
}
case nameof(ApiMethod.PUT):
{
await service.UpdateHomeBaseAsync(homeBase);
break;
}
}
}
if (decodedMessage.MessageType == "Bike")
{
var service = scope.ServiceProvider.GetRequiredService <IBikeService>();
var decodedBike = DecodeBike(e);
var bikeResponse = decodedBike.Message;
var bike = _mapper.Map <BikeResponse, Bike>(bikeResponse);
switch (decodedMessage.Method)
{
case nameof(ApiMethod.POST):
{
await service.AddBikeAsync(_mapper.Map <AddBikeCommand>(bike));
break;
}
case nameof(ApiMethod.DELETE):
{
await service.DeleteBikeAsync(bike.Id);
break;
}
case nameof(ApiMethod.PUT):
{
var bikeInDb = await service.GetBikeAsync(bike.Id);
BikeResponse bikeToUpdate = new BikeResponse();
bikeInDb.IfSucc(b =>
{
b.State = bike.State;
bikeToUpdate = b;
});
if (bikeInDb.IsFaulted)
{
return;
}
await service.UpdateBikeAsync(_mapper.Map <UpdateBikeCommand>(bikeToUpdate));
break;
}
}
}
}
});
await Task.CompletedTask;
}
