public async Task UpdateCarPosition(long userId, decimal latitude, decimal longitude)
{
var driver = GetDriverByUserId(userId);
var car = _dataStore.GetAll <Schedule>()
.Where(x => x.DriverId == driver.Id)
.Where(x => x.Date == DateTime.Today)
.Select(x => x.Car)
.FirstOrDefault();
if (car == null)
{
await Task.FromResult(0);
return;
}
if (car.Position != null)
{
await _positionService.UpdateAsync(car.Position.Id, latitude, longitude);
}
else
{
car.Position = await _positionService.CreateAsync(latitude, longitude);
await _dataStore.SaveChangesAsync();
}
}
public async Task <IActionResult> CreateAsync(PositionAddOrEditDto model)
{
var result = new ReturnData <bool>();
result.Obj = await _service.CreateAsync(model);
return(Ok(result));
}
public async Task <GetPositionResponse> Handle(CreatePositionCommand request,
CancellationToken cancellationToken)
{
var mappedPosition = _mapper.Map <CreatePositionCommand, Position>(request);
var created = await _positionService.CreateAsync(mappedPosition, cancellationToken);
return(_mapper.Map <Position, GetPositionResponse>(created));
}
public async Task <IActionResult> Create([FromBody] CreatePositionViewModel vm)
{
var result = await _services.CreateAsync(_mapper.Map <DirectoryDTO>(vm));
if (result.IsValid)
{
await _systemAuditService.AuditAsync(User.GetEmail(), _accessor.GetIp(), Operations.Insert, Tables.Position);
return(CreatedAtRoute("GetPosition", new { version = "1.0", controller = "Position", id = result.Result }, vm));
}
return(UnprocessableEntity(result.ErrorsList));
}
public async Task <IActionResult> Create(PositionViewModel vm)
{
if (ModelState.IsValid)
{
var result = await _services.CreateAsync(_mapper.Map <DirectoryDTO>(vm));
return(result.IsValid
? RedirectToAction("Index")
: _oops.OutPutError("Position", "Index", result.ErrorsList));
}
return(View(vm));
}
public async Task <ActionResult <PositionDTO> > CreateAsync([FromBody] PositionCreateDTO model)
{
try
{
return(Ok(await positionService.CreateAsync(model)));
}
catch (NotFoundException e)
{
return(NotFound(new { Id = e.Key, e.Message }));
}
catch (ValidationException e)
{
return(BadRequest(e.ValidationErrors));
}
}
public async Task <IActionResult> Create([FromBody] Position dto)
{
Position createdDto = await _service.CreateAsync(dto, ModelState.AddModelError);
if (createdDto == null)
{
return(BadRequest(ModelState));
}
return(CreatedAtAction(
nameof(Get),
new { id = createdDto.ID },
createdDto
));
}
public async Task <IActionResult> Create([FromBody] CreatePositionViewModel vm)
{
if (ModelState.IsValid)
{
var result = await _services.CreateAsync(_mapper.Map <DirectoryDTO>(vm));
if (result.IsValid)
{
await _systemAuditService.AuditAsync(User.GetEmail(), _accessor.GetIp(), Operations.Insert, Tables.Position);
return(Ok(result));
}
return(BadRequest(result));
}
return(BadRequest());
}
public async Task <IActionResult> Create(CreatePositionViewModel vm)
{
if (ModelState.IsValid)
{
var result = await _services.CreateAsync(_mapper.Map <DirectoryDTO>(vm));
if (result.IsValid)
{
await _systemAuditService.AuditAsync(User.GetEmail(), _accessor.GetIp(), Operations.Insert, Tables.Position);
return(RedirectToAction("Index"));
}
TempData["ErrorsList"] = result.ErrorsList;
}
return(View(vm));
}
public async Task <IActionResult> Create(PositionCreateViewModel model)
{
if (ModelState.IsValid)
{
var position = new PositionJob()
{
Id = model.Id,
PositionJobCode = model.PositionJobCode,
PositionJobName = model.PositionJobName,
InsuranceMoney = model.InsuranceMoney,
Status = true
};
await _positionService.CreateAsync(position);
return(RedirectToAction(nameof(Index)));
}
return(View());
}
public async Task <IActionResult> Create([FromBody] PositionCreateModel value)
{
if (value == null)
{
return(NotFound());
}
var userDto = mapper.Map <PositionDto>(value);
var result = await positionService.CreateAsync(userDto);
if (result.IsSuccess)
{
return(Ok());
}
else
{
return(new JsonResult(result.GetErrorString()));
}
}
public async Task <IActionResult> Create(AddPositionDto model)
{
var result = await _service.CreateAsync(model);
return(Ok(result));
}
public async Task <PositionBindingModel> CreatePosition([FromBody] PositionBindingModel newPosition)
{
await _positionService.CreateAsync(PositionAdapter.ToModel(newPosition));
return(newPosition);
}
public async Task <IActionResult> CreateAsync(CreatePositionViewModel model)
{
await _positionService.CreateAsync(model);
return(Ok());
}
