/// <summary>
/// Determines whether this Spot instance can be placed within the requested
/// break or container.
/// </summary>
/// <param name="spot">The spot.</param>
/// <param name="progSmoothBreaks">The prog smooth breaks.</param>
/// <param name="breakPositionRules">The break position rules.</param>
/// <param name="respectSpotTime">if set to <c>true</c>, respect spot time.</param>
/// <param name="validBreaksForSpotTime">The valid breaks for spot time.</param>
/// <param name="isRestrictedSpotTime">if set to <c>true</c>, is restricted spot time.</param>
/// <param name="progSmoothBreak">The prog smooth break.</param>
/// <returns>
/// <c>true</c> if this Spot instance can be placed within the break or container requested; otherwise, <c>false</c>.
/// </returns>
public static bool CanSpotBePlacedInRequestedBreakOrContainer(
Spot spot,
IReadOnlyList <SmoothBreak> progSmoothBreaks,
SpotPositionRules breakPositionRules,
bool respectSpotTime,
IOrderedEnumerable <SmoothBreak> validBreaksForSpotTime,
bool isRestrictedSpotTime,
SmoothBreak progSmoothBreak)
{
var canAddSpotService = CanAddSpotService.Factory(progSmoothBreak);
string spotBreakOrContainerRequest = spot.BreakRequest;
if (ContainerReference.TryParse(spotBreakOrContainerRequest, out ContainerReference cr))
{
spotBreakOrContainerRequest = cr.ToString();
}
if (canAddSpotService.CanAddSpotWithBreakRequest(spotBreakOrContainerRequest, progSmoothBreaks, breakPositionRules))
{
return(true);
}
else if (IsBreakWithinSpotTimeRestriction(respectSpotTime, isRestrictedSpotTime, validBreaksForSpotTime, progSmoothBreak))
{
return(true);
}
return(false);
}
public void InvalidContainerReferenceValueThrows(string value)
{
// Arrange
// Act
Action act = () => { ContainerReference labrat = value; };
// Assert
_ = act.Should().Throw <ArgumentException>(null);
}
public void AssigningAStringToAContainerReference(string value, string expected)
{
// Arrange
// Act
ContainerReference result = value;
// Assert
_ = result.ToString().Should().BeEquivalentTo(expected, becauseArgs: null);
}
public void TryParse_BreakExternalReferenceIsNotContainer_ReturnsFalse(string breakExternalReference)
{
// Arrange
// Act
bool result = ContainerReference.TryParse(breakExternalReference, out ContainerReference _);
// Assert
_ = result.Should().BeFalse(null);
}
public void TryParse_BreakExternalReferenceIsContainer_ReturnsTrue(string breakExternalReference)
{
// Arrange
// Act
bool result = ContainerReference.TryParse(breakExternalReference, out ContainerReference cr);
// Assert
_ = result.Should().BeTrue(null);
_ = cr.ToString().Should().Be("break-1", null);
}
public void PositionProperty(string value, int expectedValue)
{
// Arrange
ContainerReference labrat = value;
// Act
var result = labrat.ContainerNumber;
// Assert
_ = result.Should().Be(expectedValue, null);
}
public void StringToContainerReference_InequalityOperator(string value)
{
// Arrange
ContainerReference subject = value;
// Act
bool result = subject != "break-99-98";
// Assert
_ = result.Should().BeTrue(becauseArgs: null);
}
public void AssigningContainerReferenceToAString(string value, string expected)
{
// Arrange
ContainerReference subject = value;
// Act
string result = subject;
// Assert
_ = result.Should().BeEquivalentTo(expected, becauseArgs: null);
}
public void ContainerReferenceToString_EqualityMethod(string value, string expected)
{
// Arrange
ContainerReference subject = value;
// Act
bool result = subject.Equals(expected);
// Assert
_ = result.Should().BeTrue(becauseArgs: null);
}
public IContainerReference From(MapCoordinate mc)
{
if (mapCache.TryGet(mc, out IContainerReference retval))
{
return(retval);
}
var r = new ContainerReference <MapCoordinate>(ContainerReferenceType.Map, mc, ContainerType.Unlimited);
mapCache.Add(mc, r);
return(r);
}
public void AssignmentIsNewInstance(string value)
{
// Arrange
ContainerReference left = value;
ContainerReference right = value;
// Act
/* Empty */
// Assert
_ = left.Should().NotBeSameAs(right, becauseArgs: null);
}
public static Recommendation InContainer(
this Recommendation recommendation,
ContainerReference value
)
{
ContainerReference expected = recommendation.ExternalBreakNo;
_ = expected.Should()
.Be(value, becauseArgs: null);
return(recommendation);
}
public IContainerReference From(IItem item)
{
var key = Tuple.Create(item.Id, item.ItemType.Container);
if (itemCache.TryGet(key, out IContainerReference retval))
{
return(retval);
}
var r = new ContainerReference <int>(ContainerReferenceType.Item, item.Id, item.ItemType.Container);
itemCache.Add(key, r);
return(r);
}
public bool Equals(ContainerReference <T> other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(entityId.Equals(other.entityId) && ReferenceType == other.ReferenceType);
}
public void ContainerReferenceToStringAsObject_EqualityMethod(
string left,
string right
)
{
// Arrange
ContainerReference subjectLeft = left;
object subjectRight = right;
// Act
bool result = subjectLeft.Equals(subjectRight);
// Assert
_ = result.Should().BeTrue(becauseArgs: null);
}
/// <inheritdoc/>
public override bool CanAddSpotWithBreakRequest(
string spotPositionRequest,
IReadOnlyList <SmoothBreak> programmeBreaks,
SpotPositionRules breakPositionRules)
{
if (String.IsNullOrWhiteSpace(spotPositionRequest))
{
return(true);
}
if (ContainerReference.TryParse(
_smoothBreak.TheBreak.ExternalBreakRef,
out ContainerReference breakContainerReference))
{
if (breakContainerReference.Equals(spotPositionRequest))
{
return(true);
}
}
if (!Int32.TryParse(spotPositionRequest, out int requestedContainerNumber))
{
return(false);
}
// Note: this should never happen but it's better to check to stop
// index out of range exceptions.
if (programmeBreaks.Count == 0)
{
return(false);
}
// All smooth breaks have a link back to their smooth programme, so
// just use the first one.
var breakContainer = programmeBreaks[0].SmoothProgramme.BreakContainers;
requestedContainerNumber = GetActualBreakPositionFromRelativePosition(
requestedContainerNumber,
breakContainer.Count);
return(CanAddSpotAtBreakPosition(
requestedContainerNumber,
breakContainerReference.ContainerNumber,
breakPositionRules));
}
public void AddContainer(StoreObjectReference container)
{
bool inList = false;
foreach (ContainerReference reference in containersInStorage)
{
if (reference.container.objectID == container.objectID)
{
reference.quantity++;
inList = true;
}
}
if (!inList)
{
ContainerReference newReference = new ContainerReference(container);
containersInStorage.Add(newReference);
}
}
public ContainerReference_s(ContainerReference reference)
{
containerID = reference.container.objectID;
containerSubID = reference.container.subID;
quantity = reference.quantity;
}
public static bool IsContainerReference(BreakExternalReference breakExternalReference) => ContainerReference.TryParse(breakExternalReference, out var _);
