/// <summary>
/// Specifies a new route for this cargo.
/// </summary>
/// <param name="routeSpec">route specification.</param>
public virtual void SpecifyNewRoute(RouteSpecification routeSpec)
{
Validate.NotNull(routeSpec, "Route specification is required");
routeSpecification = routeSpec;
// Handling consistency within the Cargo aggregate synchronously
delivery = delivery.UpdateOnRouting(routeSpecification, itinerary);
}
public bool SameValueAs(RouteSpecification other)
{
return(other != null && new EqualsBuilder().
Append(origin, other.origin).
Append(destination, other.destination).
Append(arrivalDeadline, other.arrivalDeadline).
IsEquals());
}
internal static Delivery DerivedFrom(RouteSpecification routeSpecification, Itinerary itinerary,
HandlingHistory handlingHistory)
{
Validate.NotNull(routeSpecification, "Route specification is required");
Validate.NotNull(handlingHistory, "Delivery history is required");
HandlingEvent lastEvent = handlingHistory.MostRecentlyCompletedEvent();
return(new Delivery(lastEvent, itinerary, routeSpecification));
}
public Cargo(TrackingId trackingId, RouteSpecification routeSpecification)
{
Validate.NotNull(trackingId, "Tracking ID is required");
Validate.NotNull(routeSpecification, "Route specification is required");
this.trackingId = trackingId;
// Cargo origin never changes, even if the route specification changes.
// However, at creation, cargo orgin can be derived from the initial route specification.
origin = routeSpecification.Origin;
this.routeSpecification = routeSpecification;
delivery = Delivery.DerivedFrom(this.routeSpecification, itinerary, HandlingHistory.EMPTY);
}
private RoutingStatus CalculateRoutingStatus(Itinerary itinerary, RouteSpecification routeSpecification)
{
if (itinerary == null)
{
return(RoutingStatus.NOT_ROUTED);
}
if (routeSpecification.IsSatisfiedBy(itinerary))
{
return(RoutingStatus.ROUTED);
}
return(RoutingStatus.MISROUTED);
}
/// <summary>
/// Internal constructor.
/// </summary>
/// <param name="lastEvent">last event</param>
/// <param name="itinerary">itinerary</param>
/// <param name="routeSpecification">route specification</param>
private Delivery(HandlingEvent lastEvent, Itinerary itinerary, RouteSpecification routeSpecification)
{
NO_ACTIVITY = null;
calculatedAt = DateTime.Now;
this.lastEvent = lastEvent;
misdirected = CalculateMisdirectionStatus(itinerary);
routingStatus = CalculateRoutingStatus(itinerary, routeSpecification);
transportStatus = CalculateTransportStatus();
lastKnownLocation = CalculateLastKnownLocation();
currentVoyage = CalculateCurrentVoyage();
eta = CalculateEta(itinerary);
nextExpectedActivity = CalculateNextExpectedActivity(routeSpecification, itinerary);
isUnloadedAtDestination = CalculateUnloadedAtDestination(routeSpecification);
}
private bool CalculateUnloadedAtDestination(RouteSpecification routeSpecification)
{
return(lastEvent != null &&
HandlingType.UNLOAD.SameValueAs(lastEvent.Type) &&
routeSpecification.Destination.SameIdentityAs(lastEvent.Location));
}
private HandlingActivity CalculateNextExpectedActivity(RouteSpecification routeSpecification,
Itinerary itinerary)
{
if (!IsOnTrack())
{
return(NO_ACTIVITY);
}
if (lastEvent == null)
{
return(new HandlingActivity(HandlingType.RECEIVE, routeSpecification.Origin));
}
if (lastEvent.Type == HandlingType.LOAD)
{
foreach (Leg leg in itinerary.Legs)
{
if (leg.LoadLocation.SameIdentityAs(lastEvent.Location))
{
return(new HandlingActivity(HandlingType.UNLOAD, leg.UnloadLocation,
leg.Voyage));
}
}
return(NO_ACTIVITY);
}
if (lastEvent.Type == HandlingType.UNLOAD)
{
for (IEnumerator <Leg> it = itinerary.Legs.GetEnumerator(); it.MoveNext();)
{
Leg leg = it.Current;
if (leg.UnloadLocation.SameIdentityAs(lastEvent.Location))
{
if (it.MoveNext())
{
Leg nextLeg = it.Current;
return(new HandlingActivity(HandlingType.LOAD, nextLeg.LoadLocation,
nextLeg.Voyage));
}
return(new HandlingActivity(HandlingType.CLAIM, leg.UnloadLocation));
}
}
return(NO_ACTIVITY);
}
if (lastEvent.Type == HandlingType.RECEIVE)
{
IEnumerator <Leg> enumerator = itinerary.Legs.GetEnumerator();
enumerator.MoveNext();
var firstLeg = enumerator.Current;
return(new HandlingActivity(HandlingType.LOAD, firstLeg.LoadLocation, firstLeg.Voyage));
}
if (lastEvent.Type == HandlingType.CLAIM)
{
//DO nothing
}
return(NO_ACTIVITY);
}
/// <summary>
/// Creates a new delivery snapshot to reflect changes in routing, i.e.
/// when the route specification or the itinerary has changed
/// but no additional handling of the cargo has been performed.
/// </summary>
/// <param name="routeSpecification">route specification</param>
/// <param name="itinerary">itinerary itinerary</param>
/// <returns>An up to date delivery</returns>
internal Delivery UpdateOnRouting(RouteSpecification routeSpecification, Itinerary itinerary)
{
Validate.NotNull(routeSpecification, "Route specification is required");
return(new Delivery(lastEvent, itinerary, routeSpecification));
}
