public List <CourierDto> GetNearestCouriers(PointDto pointDto, int count = 5)
{
using (var db = new CourierHelperDb(_connectionString))
{
var nearestPoints = db.ActivePointsRepo.Query
.Where(point => (point.Courier != null && point.Courier.Deleted == null) || point.Route != null)
.AsEnumerable()
.OrderBy(point => point.Coordinates.Distance(new Point(pointDto.Longitude, pointDto.Latitude)))
.ToList();
var couriers = nearestPoints
.Select(point =>
{
if (point.Courier != null)
{
return(point.Courier);
}
else
{
return(point.Route.Courier);
}
})
.Where(courier => courier.State != CourierState.NotAccessible)
.Distinct()
.OrderBy(courier => courier.Orders.Count())
.ThenBy(courier => courier.State)
.Take(count)
.ToList();
var couriersDto = Mapper.Map <List <CourierDto> >(couriers);
return(couriersDto);
}
}
public async Task <int> AddWarehouseAsync(WarehouseDto warehouseDto)
{
using (var db = new CourierHelperDb(_connectionString))
{
if (warehouseDto.Location == null)
{
throw new ArgumentException("Warehouse location is required!");
}
ActivePoint location = new ActivePoint
{
Coordinates = new Point(warehouseDto.Location.Longitude, warehouseDto.Location.Latitude)
};
Warehouse warehouse = new Warehouse
{
Location = location,
Address = warehouseDto.Address,
Name = warehouseDto.Name
};
db.WarehousesRepo.Create(warehouse);
await db.SaveAsync();
return(warehouse.Id);
}
}
public async Task <List <OrderDto> > SyncOrders(Guid courierId)
{
using (var db = new CourierHelperDb(_connectionString))
{
Courier courier = db.CouriersRepo.Get(courierId);
if (courier == null)
{
throw new Exception(); //todo: exception
}
List <Order> notSyncedOrders = courier.Orders.Where(o => o.Synced == null || o.Edited > o.Synced).ToList();
foreach (var order in notSyncedOrders)
{
order.Synced = DateTime.Now;
db.OrdersRepo.Update(order);
}
await db.SaveAsync();
List <OrderDto> notSyncedOrdersDto = Mapper.Map <List <OrderDto> >(notSyncedOrders);
return(notSyncedOrdersDto);
}
}
public async Task CompleteCurrentRoute(Guid courierId)
{
using (var db = new CourierHelperDb(_connectionString))
{
Courier courier = db.CouriersRepo.Get(courierId);
if (courier == null)
{
throw new ArgumentException($"Can`t find courier with id {courierId}");
}
var route = courier.Routes.FirstOrDefault(r => r.IsCurrent);
if (route == null)
{
throw new Exception(); //todo: exception
}
route.IsCurrent = false;
route.Completed = DateTime.Now;
db.RoutesRepo.Update(route);
await db.SaveAsync();
}
}
public async Task Update(WarehouseDto warehouseDto)
{
using (var db = new CourierHelperDb(_connectionString))
{
if (warehouseDto.Location == null)
{
throw new ArgumentException("Warehouse location is required!");
}
Warehouse warehouse = db.WarehousesRepo.Get(warehouseDto.Id);
if (warehouse == null)
{
throw new ArgumentOutOfRangeException(""); //todo: make better exception
}
warehouse.Location.Coordinates = new Point(warehouseDto.Location.Longitude, warehouseDto.Location.Latitude);
warehouse.Address = warehouseDto.Address;
warehouse.Name = warehouseDto.Name;
db.WarehousesRepo.Update(warehouse);
await db.SaveAsync();
}
}
public async Task ChangeCourierCurrentRouteAsync(Guid courierId, RouteDto newCurrentRouteDto)
{
using (var db = new CourierHelperDb(_connectionString))
{
Courier courier = db.CouriersRepo.Get(courierId);
if (courier == null)
{
throw new ArgumentException(); //todo: exception
}
Route currentRoute = courier.Routes.FirstOrDefault(r => r.IsCurrent);
foreach (var point in currentRoute.Points.ToList())
{
db.ActivePointsRepo.Delete(point);
}
foreach (var point in newCurrentRouteDto.Points)
{
currentRoute.Points.Add(new ActivePoint()
{
Coordinates = new Point(point.Longitude, point.Latitude)
});
}
db.RoutesRepo.Update(currentRoute);
await db.SaveAsync();
}
}
private void ChangeTrack(Courier courier, CourierHelperDb db)
{
if (courier.State > CourierState.Idle)
{
Track currentTrack = courier.Tracks.FirstOrDefault(t => t.IsCurrent);
ActivePoint newPoint = new ActivePoint
{
Coordinates = new Point(courier.Location.Coordinates.Longitude, courier.Location.Coordinates.Latitude)
};
if (currentTrack == null)
{
currentTrack = new Track {
IsCurrent = true
};
currentTrack.Points.Add(newPoint);
courier.Tracks.Add(currentTrack);
}
else
{
currentTrack.Points.Add(newPoint);
db.TracksRepo.Update(currentTrack);
}
}
}
public async Task DisableCourierAsync(Guid courierId)
{
using (var db = new CourierHelperDb(_connectionString))
{
db.CouriersRepo.Delete(courierId);
await db.SaveAsync();
}
}
public async Task DeleteOrder(long orderId)
{
using (var db = new CourierHelperDb(_connectionString))
{
db.OrdersRepo.Delete(orderId);
await db.SaveAsync();
}
}
public async Task UpdateCustomerAsync(CustomerDto customerDto)
{
using (var db = new CourierHelperDb(_connectionString))
{
Customer customer = Mapper.Map <Customer>(customerDto);
db.CustomersRepo.Update(customer);
await db.SaveAsync();
}
}
public List <CourierDto> GetAllCouriers()
{
using (var db = new CourierHelperDb(_connectionString))
{
List <Courier> couriers = db.CouriersRepo.GetAll().ToList();
List <CourierDto> couriersDto = Mapper.Map <List <CourierDto> >(couriers);
return(couriersDto);
}
}
public List <OrderDto> GetOrdersByState(OrderStateDto state)
{
using (var db = new CourierHelperDb(_connectionString))
{
List <Order> orders = db.OrdersRepo.Query.Where(o => o.State == (OrderState)state).ToList();
List <OrderDto> ordersDto = Mapper.Map <List <OrderDto> >(orders);
return(ordersDto);
}
}
public OrderDto GetOrderById(long orderId)
{
using (var db = new CourierHelperDb(_connectionString))
{
Order order = db.OrdersRepo.Get(orderId);
OrderDto orderDto = Mapper.Map <OrderDto>(order);
return(orderDto);
}
}
public List <WarehouseDto> GetAll()
{
using (var db = new CourierHelperDb(_connectionString))
{
List <Warehouse> warehouses = db.WarehousesRepo.GetAll().ToList();
List <WarehouseDto> warehousesDto = Mapper.Map <List <WarehouseDto> >(warehouses);
return(warehousesDto);
}
}
public CustomerDto GetCustomerById(Guid customerId)
{
using (var db = new CourierHelperDb(_connectionString))
{
Customer customer = db.CustomersRepo.Get(customerId);
CustomerDto customerDto = Mapper.Map <CustomerDto>(customer);
return(customerDto);
}
}
public WarehouseDto GetById(int warehouseId)
{
using (var db = new CourierHelperDb(_connectionString))
{
Warehouse warehouse = db.WarehousesRepo.Get(warehouseId);
WarehouseDto warehouseDto = Mapper.Map <WarehouseDto>(warehouse);
return(warehouseDto);
}
}
public List <OrderDto> GetUnassignedOrders()
{
using (var db = new CourierHelperDb(_connectionString))
{
var orders = db.OrdersRepo.Query
.Where(order => order.Deleted == null && order.State == OrderState.NotAssigned)
.ToList();
var ordersDto = Mapper.Map <List <OrderDto> >(orders);
return(ordersDto);
}
}
public List <RouteDto> GetCourierAllRoutes(Guid courierId)
{
using (var db = new CourierHelperDb(_connectionString))
{
Courier courier = db.CouriersRepo.Get(courierId);
if (courier == null)
{
throw new ArgumentOutOfRangeException(""); //todo: exception
}
List <Route> routes = courier.Routes.ToList();
List <RouteDto> routesDto = Mapper.Map <List <RouteDto> >(routes);
return(routesDto);
}
}
public RouteDto GetCourierCurrentRoute(Guid courierId)
{
using (var db = new CourierHelperDb(_connectionString))
{
Courier courier = db.CouriersRepo.Get(courierId);
if (courier == null)
{
throw new ArgumentOutOfRangeException(""); //todo: exception
}
Route currentRoute = courier.Routes.FirstOrDefault(route => route.IsCurrent);
RouteDto routeDto = Mapper.Map <RouteDto>(currentRoute);
return(routeDto);
}
}
public async Task ChangeCourierStateAsync(Guid courierId, CourierStateDto newState)
{
using (var db = new CourierHelperDb(_connectionString))
{
Courier courier = db.CouriersRepo.Get(courierId);
if (courier == null)
{
throw new ArgumentException($"Can`t find courier with id {courierId}");
}
courier.State = (CourierState)newState;
db.CouriersRepo.Update(courier);
await db.SaveAsync();
}
}
public List <OrderDto> GetCourierOrders(Guid courierId)
{
using (var db = new CourierHelperDb(_connectionString))
{
var courier = db.CouriersRepo.Get(courierId);
if (courier == null)
{
throw new ArgumentOutOfRangeException($"The courier with id {courierId} does not exist!");
}
var orders = courier.Orders.Where(o => o.Deleted == null).ToList();
var ordersDto = Mapper.Map <List <OrderDto> >(orders);
return(ordersDto);
}
}
public async Task AssignOrder(Guid courierId, long orderId)
{
using (var db = new CourierHelperDb(_connectionString))
{
Courier courier = db.CouriersRepo.Get(courierId);
Order order = db.OrdersRepo.Get(orderId);
if (courier == null || order == null)
{
throw new ArgumentOutOfRangeException(""); //todo: exception
}
courier.Orders.Add(order);
db.CouriersRepo.Update(courier);
await db.SaveAsync();
}
}
public async Task ChangeOrderStateAsync(OrderDto orderDto, OrderStateDto state)
{
using (var db = new CourierHelperDb(_connectionString))
{
Order order = db.OrdersRepo.Get(orderDto.Id);
if (order == null)
{
throw new ArgumentOutOfRangeException($"The order with id {orderDto.Id} does not exist!");
}
order.State = (OrderState)state;
db.OrdersRepo.Update(order);
await db.SaveAsync();
orderDto.State = state;
}
}
public async Task CompleteAsync(Guid courierId, long orderId)
{
using (var db = new CourierHelperDb(_connectionString))
{
Courier courier = db.CouriersRepo.Get(courierId);
if (courier == null)
{
throw new Exception(); //todo: exception
}
Order order = courier.Orders.SingleOrDefault(o => o.Id == orderId);
if (order == null)
{
throw new Exception("The courier does not have this order");
}
Track currentTrack = courier.Tracks.Single(t => t.IsCurrent);
currentTrack.IsCurrent = false;
db.TracksRepo.Update(currentTrack);
order.State = OrderState.Completed;
order.Track = currentTrack;
db.OrdersRepo.Update(order);
if (!courier.Orders.Any(o => o.State == OrderState.Fulfillment))
{
Route currentRoute = courier.Routes.SingleOrDefault(r => r.IsCurrent);
currentRoute.IsCurrent = false;
currentRoute.Completed = DateTime.Now;
db.RoutesRepo.Update(currentRoute);
courier.State = CourierState.Idle;
db.CouriersRepo.Update(courier);
}
await db.SaveAsync();
}
}
public RouteDto GetCourieRemainingRoute(Guid courierId)
{
using (var db = new CourierHelperDb(_connectionString))
{
Courier courier = db.CouriersRepo.Get(courierId);
if (courier == null)
{
throw new ArgumentException(); //todo: exception
}
if (courier.State < CourierState.PerformsDelivery)
{
throw new Exception(); //todo: exception
}
Route currentRoute = courier.Routes.Single(r => r.IsCurrent);
return(null); //todo: add logic for getting remaining route
}
}
public async Task ChangeCourierLocationAsync(Guid courierId, PointDto newLocation)
{
using (var db = new CourierHelperDb(_connectionString))
{
Courier courier = db.CouriersRepo.Get(courierId);
if (courier == null)
{
throw new ArgumentException($"Can`t find courier with id {courierId}");
}
courier.Location.Coordinates = new Point(newLocation.Longitude, newLocation.Latitude);
SetState(courier);
ChangeTrack(courier, db);
db.CouriersRepo.Update(courier);
await db.SaveAsync();
}
}
public async Task <Guid> AddRouteAsync(Guid courierId, RouteDto newCurrentRoute)
{
using (var db = new CourierHelperDb(_connectionString))
{
Courier courier = db.CouriersRepo.Get(courierId);
if (courier == null)
{
throw new ArgumentException(); //todo: exception
}
if (courier.Routes.Any(r => r.IsCurrent))
{
throw new Exception(); //todo: exception
}
Route route = new Route
{
Created = DateTime.Now,
Edited = DateTime.Now,
Synced = DateTime.Now,
IsCurrent = true,
Distance = newCurrentRoute.Distance
};
foreach (var point in newCurrentRoute.Points)
{
route.Points.Add(new ActivePoint()
{
Coordinates = new Point(point.Longitude, point.Latitude)
});
}
courier.Routes.Add(route);
await db.SaveAsync();
return(route.Id);
}
}
public PointDto GetOrderLocation(long orderId)
{
using (var db = new CourierHelperDb(_connectionString))
{
var order = db.OrdersRepo.Get(orderId);
if (order == null)
{
throw new ArgumentOutOfRangeException("The order with this id does not exist!");
}
Point orderPoint = order.Destination.Coordinates;
PointDto orderPointDto = Mapper.Map <PointDto>(orderPoint);
Point warehousePoint = order.Warehouse.Location.Coordinates;
PointDto warehousePointDto = Mapper.Map <PointDto>(warehousePoint);
orderPointDto.After = warehousePointDto;
return(orderPointDto);
}
}
public async Task <RouteDto> SyncRoute(Guid courierId)
{
using (var db = new CourierHelperDb(_connectionString))
{
Courier courier = db.CouriersRepo.Get(courierId);
if (courier == null)
{
throw new Exception(); //todo: exception
}
Route notSyncedRoute = courier.Routes.Single(r => r.IsCurrent && (r.Synced == null || r.Edited > r.Synced));
notSyncedRoute.Synced = DateTime.Now;
db.RoutesRepo.Update(notSyncedRoute);
await db.SaveAsync();
RouteDto notSyncedRouteDto = Mapper.Map <RouteDto>(notSyncedRoute);
return(notSyncedRouteDto);
}
}
public async Task <Guid> AddCourierAsync(CourierDto courierDto)
{
if (string.IsNullOrWhiteSpace(courierDto.PhoneNumber))
{
throw new ArgumentException("Phone number is required"); //todo: better exception
}
using (var db = new CourierHelperDb(_connectionString))
{
Courier courier = new Courier
{
FirstName = courierDto.FirstName,
LastName = courierDto.LastName,
MiddleName = courierDto.MiddleName,
Email = courierDto.Email,
PhoneNumber = courierDto.PhoneNumber,
State = (CourierState)courierDto.State
};
if (courierDto.Location != null)
{
ActivePoint location = new ActivePoint
{
Coordinates = new Point(courierDto.Location.Longitude, courierDto.Location.Latitude)
};
courier.Location = location;
}
db.CouriersRepo.Create(courier);
await db.SaveAsync();
courierDto.Id = courier.Id;
return(courier.Id);
}
}
