public async Task <IServiceResponse <bool> > AddRoute(RouteDTO route)
{
return(await HandleApiOperationAsync(async() => {
await _routeService.AddRoute(route);
return new ServiceResponse <bool>(true);
}));
}
//[ValidateAntiForgeryToken]
public async Task <IActionResult> AddRoute([FromBody] Route route, [FromQuery] string userId)
{
var response = new SingleModelResponse <Route>()
as ISingleModelResponse <Route>;
try
{
if (route == null && userId == null)
{
throw new Exception("Your whole request is messed up. Route and UserId missing");
}
else if (route == null)
{
throw new Exception("Route is missing");
}
else if (userId == null)
{
throw new Exception("User ID is missing");
}
response.Model = await Task.Run(() =>
{
route.UserID = userId;
Route newRoute = _context.AddRoute(route);
return(newRoute);
});
}
catch (Exception ex)
{
response.DidError = true;
response.ErrorMessage = ex.Message;
}
return(response.ToHttpResponse());
}
public EditRouteViewModel MapEditModelToDomain(EditRouteViewModel model, IPrincipal user)
{
model.DateEntered = DateTime.Now;
DodgingBranches.Models.Route routeToAdd = MapViewModelToDomain(model);
_routeService.AddRoute(routeToAdd);
return(model);
}
public IActionResult AddRoute(CreatedRoute createdRoute)
{
if (createdRoute.DepartureTime > createdRoute.ArrivalTime)
{
return(BadRequest());
}
int idOfNewElement = _routes.AddRoute(createdRoute);
Route route = createdRoute.ToRoute();
route.RouteId = idOfNewElement;
return(Created(HttpContext.Request.Scheme + "//" + HttpContext.Request.Host + HttpContext.Request.Path + "/" + idOfNewElement, route));
}
public IActionResult AddRouteFromSearchResult(RouteSearchViewModel routeSearchViewModel)
{
try
{
var userName = User.Identity.Name;
var routeId = _routeService.AddRoute(routeSearchViewModel, userName);
return(Ok(routeId));
}
catch (NotFoundException)
{
return(BadRequest("Cannot Create Route for this customer"));
}
catch (Exception ex)
{
return(BadRequest(ex.GetRootException().Message));
}
}
public IActionResult AddRoute(Route route, string userId)
{
Route newRoute = route;
if (ModelState.IsValid)
{
route.UserID = userId;
_context.AddRoute(route);
_context.SaveRoute();
return(Ok(route.RouteId));
}
else
{
var errors = ModelState.Values.SelectMany(v => v.Errors);
Debug.WriteLine("Errors found: " + errors + "\nEnd Errors found");
return(BadRequest(ModelState));
}
}
public IActionResult Post([FromBody] RouteDto routeDto)
{
try {
if (ModelState.IsValid)
{
return(new JsonResult(new ApiResponse {
Success = true, Data = _service.AddRoute(routeDto)
}));
}
var errors = ModelState.Keys
.SelectMany(key => ModelState[key].Errors.Select(x => new { Property = key, Error = x.ErrorMessage })).ToList();
return(new JsonResult(new ApiResponse {
Success = false, Data = errors
}));
} catch (Exception ex) {
return(new JsonResult(new ApiResponse {
Success = false, Data = ex.Message
}));
}
}
private bool AddRoute(RouteModel routeModel)
{
var editWindow = new EditRouteWindow();
var ctx = (EditRouteViewModel)editWindow.DataContext;
ctx.Route = routeModel;
ctx.Airports = _airportService.GetAllAirports();
ctx.Carriers = _carrierService.GetAllCarriers();
if (editWindow.ShowDialog() != true)
{
return(false);
}
var errs = GetModelErrors(ctx.Route);
if (errs != string.Empty)
{
ShowError(errs, "Error! Saving cancelled. ");
return(false);
}
_routeService.AddRoute(routeModel);
return(true);
}
public IActionResult OnPost()
{
if (ModelState.IsValid)
{
Route route = new Route();
route.UserId = Convert.ToInt32(HttpContext.Session.GetInt32("UserID"));
route.Start = Request.Form["AddStart"];
route.Goal = Request.Form["AddEnd"];
route.Day = Convert.ToInt32(Request.Form["Day"]);
route.Arrival = Convert.ToDateTime(Request.Form["Arrival"]);
route.Space = Convert.ToInt32(Request.Form["Space"]);
_routeService.AddRoute(route);
int id = _routeService.GetAllRoutes().Last().RouteId;
return(RedirectToPage("Route", new { id = id }));
}
return(Page());
}
public async Task <IActionResult> Create(RouteCreateViewModel model)
{
// Create Route
Route route = new Route
{
Note = model.Note,
RouteID = model.RouteID,
GripColour = model.GripColor,
Type = model.Type
};
_routeService.AddRoute(route, model.Date, model.RouteDifficultyID);
// Create Section Relation
_routeService.AddRouteToSections(route, model.RouteSectionID.ToList());
//Find all the users by id in model.Builders, in parallel, then discard missing results
IEnumerable <ApplicationUser> builders =
(
await Task.WhenAll
(
model.Builders
.Distinct()
.Select(userId => _userService.FindByIdAsync(userId))
)
)
.Where(user => user != null);
_routeService.AddBuildersToRoute(route, builders.ToList());
// Add the image(s) and imagepaths to the database, and the videourl
string[] relativeImagePaths = await UploadImages();
_routeService.AddAttachment(route, model.VideoUrl, relativeImagePaths);
return(RedirectToAction(nameof(List), "Route"));
}
public NewRouteConfirmationViewModel()
{
routeService = (App.Current as App).Container.GetService <IRouteService>();
stopService = (App.Current as App).Container.GetService <IStopService>();
CreateRouteCommand = new RelayCommand(() =>
{
List <DateTime> datesForRoute = GetDatesSetForRoute();
if (!string.IsNullOrEmpty(RouteName) &&
stopService.Stops.Count > 0 &&
datesForRoute.Count > 0)
{
RouteModel routeToAdd = new RouteModel()
{
RouteName = this.RouteName,
Stops = new System.Collections.ObjectModel.ObservableCollection <StopModel>(stopService.Stops),
DatesForCurrentRoute = new List <DateTime>(datesForRoute)
};
// Add route to list of routes
routeService.AddRoute(routeToAdd);
// Cleanup
CleanupRouteCreation();
// Navigate to route page
NavigationService.Navigate(typeof(RoutesPage));
}
});
DateChangedCommand = new RelayCommand <CalendarDatePicker>((param) =>
{
selectedDate = param.Date;
});
}
public bool AddRoute(Line route)
{
return(routeService.AddRoute(route));
}
public IHttpActionResult AddRoute(UpdateRouteModel route)
{
return(Ok(_service.AddRoute(route)));
}
