public ActionResult Create(RoutePostModel model)
{
var routeModel = _mapper.Map <RouteModel>(model);
_routeService.Create(routeModel);
return(new EmptyResult());
}
public IActionResult Create(RouteDto routeDto)
{
log.Info(nameof(RoutesController.Create));
try
{
if (ModelState.IsValid)
{
routeService.Create(routeDto);
return(RedirectToAction(nameof(Index)));
}
var stationNames = stationService.GetAll();
ViewData["StationId"] = new SelectList(stationNames, "Id", "Name", routeDto.Id);
return(View(routeDto));
}
catch (Exception e)
{
log.Error(e);
return(BadRequest());
}
}
public RouteResponse Create(CreateRouteRequest routeRequest)
{
var domain = routeRequest.To <Route>();
var createdRoute = _routeService.Create(domain);
AddPlace(new CreateRoutePlaceRequest
{
RouteId = createdRoute.Id,
PlaceId = routeRequest.SourceId,
SequenceNumber = 1
});
AddPlace(new CreateRoutePlaceRequest
{
RouteId = createdRoute.Id,
PlaceId = routeRequest.DestinationId,
SequenceNumber = 2
});
var routeResponse = createdRoute.To <RouteResponse>();
routeResponse.Places = _routeService
.ReadPlaces(createdRoute.Id)
.Select(p => p.To <PlaceResponse>()).ToArray();
return(routeResponse);
}
public IActionResult Create([FromBody] RouteDTO routeDTO)
{
try
{
Route route = new Route();
route.RouteName = routeDTO.RouteName;
route.DateOfVisit = routeDTO.DateOfVisit;
route.isActive = routeDTO.isActive;
route.isRepeatable = routeDTO.isRepeatable;
route.SalesPerson = routeDTO.SalesPerson;
//productType.CreatedBy = User.Identity.Name;
var routeEntity = _routeService.Create(route);
var routes = _mapper.Map <RouteDTO>(routeEntity);
return(Ok(route));
}
catch (Exception ex)
{
Logger.Fatal(ex.Message);
Logger.Fatal(ex.Source);
Logger.Fatal(ex.StackTrace);
if (ex.InnerException != null)
{
Logger.Fatal(ex.InnerException.Message);
Logger.Fatal(ex.InnerException.Source);
Logger.Fatal(ex.InnerException.StackTrace);
}
return(null);
}
}
public async Task <ActionResult> Create([FromBody] RouteRequestDto dto)
{
var validator = new RouteValidator();
var result = await validator.ValidateAsync(dto);
if (!result.IsValid)
{
return(BadRequest(result.Errors));
}
return(Ok(await _service.Create(dto)));
}
public async Task <IActionResult> Create([FromBody] RouteModel route)
{
var result = await _routeService.Create(route);
if (result == Guid.Empty)
{
return(BadRequest("Route not created"));
}
return(Ok(result));
}
public void CreateRoute([Required] string origin, [Required] string destiny, [FromBody] ShipsToRequestModel entity)
{
WarehouseResponse originWarehouse, destinyWarehouse;
ValidateRequest(origin, destiny, entity, out originWarehouse, out destinyWarehouse);
if (_service.GetDirectRoute(originWarehouse.Id, destinyWarehouse.Id).Any())
{
throw new HttpRequestException(_errorHandler.GetErrorMessage(ErrorMessagesEnum.EntityDuplicate));
}
var request = new ShipsToRequest
{
Cost = entity.Cost,
Time = entity.Time,
Origin = originWarehouse,
Destiny = destinyWarehouse
};
_service.Create(request);
}
public void Initialize(string file)
{
var initialRouteList = routeReader.ReadFile(file);
routeService.Create(initialRouteList);
while (true)
{
try
{
var route = userInterface.GetRoute();
var bestRoute = bestRouteService.CalcBestRoute(route);
userInterface.PrintBestRoute(bestRoute);
}
catch (Exception exception)
{
userInterface.PrintException(exception);
}
}
}
public IActionResult PostRoute(RouteDto routeDto)
{
log.Info(nameof(RoutesController.PostRoute));
try
{
if (routeDto == null)
{
return(BadRequest());
}
routeService.Create(routeDto);
return(Ok(routeDto));
}
catch (Exception e)
{
log.Error(e);
return(BadRequest());
}
}
public ActionResult Create(Route svm)
{
if (ModelState.IsValid)
{
if (svm.RouteId == 0)
{
svm.CreatedDate = DateTime.Now;
svm.ModifiedDate = DateTime.Now;
svm.CreatedBy = User.Identity.Name;
svm.ModifiedBy = User.Identity.Name;
_RouteService.Create(svm);
try
{
_unitOfWork.Save();
}
catch (Exception ex)
{
string message = _exception.HandleException(ex);
ModelState.AddModelError("", message);
return(View("Create", svm));
}
LogActivity.LogActivityDetail(LogVm.Map(new ActiivtyLogViewModel
{
DocTypeId = new DocumentTypeService(_unitOfWork).FindByName(MasterDocTypeConstants.Route).DocumentTypeId,
DocId = svm.RouteId,
ActivityType = (int)ActivityTypeContants.Added,
}));
return(RedirectToAction("Edit", new { id = svm.RouteId }).Success("Data saved Successfully"));
}
else
{
List <LogTypeViewModel> LogList = new List <LogTypeViewModel>();
Route temp = _RouteService.Find(svm.RouteId);
Route ExRec = Mapper.Map <Route>(temp);
temp.RouteName = svm.RouteName;
temp.IsActive = svm.IsActive;
temp.ModifiedDate = DateTime.Now;
temp.ModifiedBy = User.Identity.Name;
_RouteService.Update(temp);
LogList.Add(new LogTypeViewModel
{
ExObj = ExRec,
Obj = temp,
});
XElement Modifications = new ModificationsCheckService().CheckChanges(LogList);
try
{
_unitOfWork.Save();
}
catch (Exception ex)
{
string message = _exception.HandleException(ex);
ModelState.AddModelError("", message);
return(View("Create", svm));
}
LogActivity.LogActivityDetail(LogVm.Map(new ActiivtyLogViewModel
{
DocTypeId = new DocumentTypeService(_unitOfWork).FindByName(MasterDocTypeConstants.Route).DocumentTypeId,
DocId = temp.RouteId,
ActivityType = (int)ActivityTypeContants.Modified,
xEModifications = Modifications,
}));
return(RedirectToAction("Index").Success("Data saved successfully"));
}
}
PrepareViewBag(svm);
return(View("Create", svm));
}
public void Post([FromBody] RoutePostModel route)
{
User addedBy = usersService.GetCurrentUser(HttpContext);
routeService.Create(route, addedBy);
}