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 <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 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();
}
}
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 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 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 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 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 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);
}
}
public async Task <long> AddOrderAsync(OrderDto orderDto)
{
if (orderDto.WarehouseId <= 0)
{
throw new ArgumentOutOfRangeException("Order must have related warehouse");
}
if (orderDto.Receiver == null)
{
throw new ArgumentNullException("Order receiver not set. Order must have receiver");
}
if (orderDto.Sender == null)
{
throw new ArgumentNullException("Order sender not set. Each order must have information about sender");
}
if (orderDto.Destination == null)
{
throw new ArgumentNullException("Order destination not set. Each order must have destination point");
}
using (var db = new CourierHelperDb(_connectionString))
{
Warehouse warehouse = db.WarehousesRepo.Query.FirstOrDefault(w => w.Id == orderDto.WarehouseId);
if (warehouse == null)
{
throw new ArgumentOutOfRangeException($"The warehouse warehouse with id {orderDto.WarehouseId}");
}
Customer sender = db.CustomersRepo.Query.FirstOrDefault(c => c.Id == orderDto.Sender.Id);
if (sender == null)
{
sender = Mapper.Map <Customer>(orderDto.Sender);
db.CustomersRepo.Create(sender);
}
else
{
sender.Email = orderDto.Sender.Email;
sender.FirstName = orderDto.Sender.FirstName;
sender.MiddleName = orderDto.Sender.MiddleName;
sender.PhoneNumber = orderDto.Sender.PhoneNumber;
db.CustomersRepo.Update(sender);
}
Customer receiver = db.CustomersRepo.Query.FirstOrDefault(c => c.Id == orderDto.Receiver.Id);
if (receiver == null)
{
receiver = Mapper.Map <Customer>(orderDto.Receiver);
db.CustomersRepo.Create(sender);
}
else
{
receiver.Email = orderDto.Receiver.Email;
receiver.FirstName = orderDto.Receiver.FirstName;
receiver.MiddleName = orderDto.Receiver.MiddleName;
receiver.PhoneNumber = orderDto.Receiver.PhoneNumber;
db.CustomersRepo.Update(receiver);
}
Order order = new Order
{
State = OrderState.NotAssigned,
Receiver = receiver,
Sender = sender,
Warehouse = warehouse,
Destination = new ActivePoint {
Coordinates = new Point(orderDto.Destination.Longitude, orderDto.Destination.Latitude)
}
};
db.OrdersRepo.Create(order);
await db.SaveAsync();
return(order.Id);
}
}
