public CartState(CartState cartState)
{
this.i = cartState.i;
this.j = cartState.j;
this.Direction = cartState.Direction;
this.LastTurn = cartState.LastTurn;
}
private void CartIntersectionTest(
CartDirection initialDirection,
CartDirection newDirection,
int iteration)
{
int dx = 0;
int dy = 0;
switch (newDirection)
{
case CartDirection.West:
dx = -1;
break;
case CartDirection.East:
dx = 1;
break;
case CartDirection.North:
dy = -1;
break;
case CartDirection.South:
dy = 1;
break;
}
for (int i = 0; i < 3; ++i)
{
var c = new CartState(2, 2, initialDirection, iteration + (i * 3)).Move(TrackCell.Intersection);
Assert.AreEqual(2 + dx, c.X, $"X ({i})");
Assert.AreEqual(2 + dy, c.Y, $"Y ({i})");
Assert.AreEqual(newDirection, c.Direction, $"Direction ({i})");
Assert.AreEqual(iteration + (i * 3) + 1, c.IntersectionsEncountered, "IntersectionsEncountered");
}
}
public static CartResponse FromCartState(CartState cartStatus)
{
return(new CartResponse(
lines: cartStatus.Lines.Select(line => CartLineResponse.FromCartLine(line)).ToList().AsReadOnly(),
isConfirmed: cartStatus.IsConfirmed
));
}
private void CheckoutWithTokenizedPayment(TokenizedPaymentInput tokenizedPaymentInput, Checkout checkout, ApplePayEventHandlerCompletion callback)
{
CartState.CheckoutWithTokenizedPayment(tokenizedPaymentInput, (ShopifyError error) => {
if (error == null)
{
callback(null);
}
else
{
ApplePayEventResponse response = new ApplePayEventResponse(ApplePayAuthorizationStatus.Failure);
// Check to see if this is a recoverable user error
if (error.Type == ShopifyError.ErrorType.UserError)
{
var userErrors = CartState.UserErrors;
var status = GetUpdateRequestStatusFromCheckoutUserErrors(userErrors);
if (status.AuthorizationStatus != ApplePayAuthorizationStatus.Failure)
{
var summaryItems = GetSummaryItemsFromCheckout(CartState.CurrentCheckout);
response = new ApplePayEventResponse(status.AuthorizationStatus, summaryItems, GetShippingMethods(), status.Errors);
}
}
callback(response);
}
});
}
private void RespondToUpdateAddressSuccessForMessage(NativeMessage message)
{
var shippingMethods = GetShippingMethods();
if (shippingMethods.Count > 0)
{
// Set the first shipping method as the default
CartState.SetShippingLine(shippingMethods[0].Identifier, (ShopifyError error) => {
if (error == null)
{
var summaryItems = GetSummaryItemsFromCheckout(CartState.CurrentCheckout);
message.Respond(new ApplePayEventResponse(ApplePayAuthorizationStatus.Success, summaryItems, shippingMethods).ToJsonString());
}
else
{
message.Respond(new ApplePayEventResponse(ApplePayAuthorizationStatus.Failure).ToJsonString());
}
});
}
else
{
// Since there are no shipping methods available, it means that the shipping address that was set is unserviceable
var summaryItems = GetSummaryItemsFromCheckout(CartState.CurrentCheckout);
var payErrors = new List <ApplePayError>();
payErrors.Add(new ApplePayShippingAddressUnservicableError("Shipping address is in an unserviceable area"));
message.Respond(new ApplePayEventResponse(ApplePayAuthorizationStatus.InvalidShippingPostalAddress, summaryItems, shippingMethods, payErrors).ToJsonString());
}
}
public async Task RemoveOne()
{
using var mocker = AutoMock.GetStrict();
await using var handler = mocker.Create <RemoveItemFromCartEventHandler>();
const string oldKey = "oneKey";
var state = new CartState
{
Items = new Dictionary <string, int>
{
{ oldKey, 100 }
}
};
var evt = new RemoveItemFromCartEvent
{
SkuId = oldKey,
Count = 10
};
await handler.HandleEvent(state, evt, default);
state.Items.Count.Should().Be(1);
var(key, value) = state.Items.Single();
key.Should().Be(oldKey);
value.Should().Be(90);
}
/// <summary>
/// Callback which is invoked when the user confirms the checkout after
/// reviewing the confirmation screen.
/// </summary>
/// <param name="serializedMessage">
/// A <see cref="ShippingMethod"> object represented as a JSON string
/// containing the selected shipping method.
/// </param>
public void OnConfirmCheckout(string serializedMessage)
{
var checkout = CartState.CurrentCheckout;
var message = NativeMessage.CreateFromJSON(serializedMessage);
var amount = checkout.totalPrice();
var payment = new NativePayment(message.Content);
var tokenizedPaymentInput = new TokenizedPaymentInput(
amount: amount,
billingAddress: payment.BillingAddress,
idempotencyKey: payment.TransactionIdentifier,
paymentData: payment.PaymentData,
identifier: payment.Identifier,
type: "android_pay"
);
CartState.SetEmailAddress(payment.Email, (ShopifyError error) => {
if (error == null)
{
PerformCheckout(tokenizedPaymentInput, message);
}
else
{
RespondError(message, error);
OnFailure(error);
}
});
}
void ChangeState(CartState state)
{
this.Log($"CartAgent changing state to {state}");
State = state;
if (state == CartState.Market)
{
Cart.CompanyReached -= OnCompanyReached;
Cart.MarketReached += OnMarketReached;
CollectSaleItems();
Travel.TravelTo(Locator.Market.Location);
}
else if (state == CartState.Company)
{
Cart.CompanyReached += OnCompanyReached;
Cart.MarketReached -= OnMarketReached;
Travel.TravelTo(Cart.Company.Location);
}
else if (state == CartState.WaitingForResupply)
{
foreach (var exchange in Locator.Market.Location.Exchanges)
{
exchange.Inventory.Added += OnMarketResupplied;
}
}
}
public ListCartsModel()
{
listCarts = new List <CartModel>();
startDate = DateTime.Now;
endDate = DateTime.Now;
state = new CartState();
listState = new List <CartState>();
}
public CartActor(IOptionsMonitor <ActorSystemOptions> options)
{
persistenceId = options.CurrentValue.PersistenceId;
cartState = new CartState();
ConfigureRecoverableEvents();
//TODO: should we rely on Become or just have one single state and validate commands depending on the value of a "Status" field?
Empty();
}
public void CartMovingEastOnEastWestTrack()
{
var c = new CartState(2, 2, CartDirection.East, 0).Move(TrackCell.EastWest);
Assert.AreEqual(3, c.X, "X");
Assert.AreEqual(2, c.Y, "Y");
Assert.AreEqual(CartDirection.East, c.Direction, "Direction");
Assert.AreEqual(0, c.IntersectionsEncountered, "IntersectionsEncountered");
}
public void SetNextLoop(CinemachinePath pathLink, CinemachinePath path, int swap, int start)
{
nextPathLink = pathLink;
nextPath = path;
currentSwitchPoint = swap;
nextStartPoint = start;
state = CartState.Linked;
CalculatePathLink();
}
public void CartMovingNorthOnNorthWestSouthEastTrack()
{
var c = new CartState(2, 2, CartDirection.North, 0).Move(TrackCell.NorthWestSouthEast);
Assert.AreEqual(1, c.X, "X");
Assert.AreEqual(2, c.Y, "Y");
Assert.AreEqual(CartDirection.West, c.Direction, "Direction");
Assert.AreEqual(0, c.IntersectionsEncountered, "IntersectionsEncountered");
}
public void CalculateTotalWithProducts()
{
var state = new CartState(new Cart());
var product = TestProducts.Cars.First();
const int count = 2;
state.Products.Add(product, count);
Assert.Equal(product.Price * count, state.Total);
}
public AndroidNativeCheckout(CartState cartState)
{
CartState = cartState;
const bool testing = true; // TODO parametrize for 3rd-party devs
#if !SHOPIFY_MONO_UNIT_TEST
AndroidPayCheckoutSession = new AndroidJavaObject(
ANDROID_CLASS_NAME,
GlobalGameObject.Name,
testing
);
#endif
}
private void SetFinalCheckoutFieldsForPayment(NativePayment payment, Checkout checkout, ApplePayEventHandlerCompletion callback)
{
ShippingFields?shippingFields = null;
if (checkout.requiresShipping())
{
shippingFields = new ShippingFields(payment.ShippingAddress, payment.ShippingIdentifier);
}
CartState.SetFinalCheckoutFields(payment.Email, shippingFields, (ShopifyError error) => {
if (error == null)
{
callback(null);
}
else
{
ApplePayEventResponse response = new ApplePayEventResponse(ApplePayAuthorizationStatus.Failure);
// Check to see if this is a recoverable user error
if (error.Type == ShopifyError.ErrorType.UserError)
{
var userErrors = CartState.UserErrors;
var status = GetUpdateRequestStatusFromShippingUserErrors(userErrors);
var summaryItems = GetSummaryItemsFromCheckout(CartState.CurrentCheckout);
if (status.AuthorizationStatus == ApplePayAuthorizationStatus.InvalidShippingPostalAddress)
{
response =
new ApplePayEventResponse(
authorizationStatus: status.AuthorizationStatus,
summaryItems: summaryItems,
errors: status.Errors
);
}
else if (status.AuthorizationStatus == ApplePayAuthorizationStatus.InvalidShippingContact)
{
response =
new ApplePayEventResponse(
status.AuthorizationStatus,
summaryItems,
GetShippingMethods(),
status.Errors
);
}
}
callback(response);
}
});
}
/// <summary>
/// Updates the shipping line and responds to Android plugin with the update status.
/// </summary>
/// <param name="shippingMethod">
/// A <see cref="ShippingMethod"> object that will be used to update the shipping line.
/// </param>
/// <param name="message">
/// A <see cref="NativeMessage"> object used to respond to the Android plugin side
/// about the shipping line update.
/// </param>
private void UpdateShippingLine(ShippingMethod shippingMethod, NativeMessage message)
{
CartState.SetShippingLine(shippingMethod.Identifier, (ShopifyError error) => {
if (error == null)
{
message.Respond(GetAndroidPayEventResponse().ToJsonString());
}
else
{
RespondError(message, error);
OnFailure(error);
}
});
}
public async Task RemoveKeyNotFoundAtFirstTime()
{
using var mocker = AutoMock.GetStrict();
await using var handler = mocker.Create <RemoveItemFromCartEventHandler>();
var state = new CartState();
var evt = new RemoveItemFromCartEvent
{
SkuId = "skuId1",
Count = 10
};
await handler.HandleEvent(state, evt, default);
state.Items.Should().BeNull();
}
public void UpdateSummaryItemsForShippingIdentifier(string serializedMessage)
{
var message = NativeMessage.CreateFromJSON(serializedMessage);
CartState.SetShippingLine(message.Content, (ShopifyError error) => {
if (error == null)
{
var summaryItems = GetSummaryItemsFromCheckout(CartState.CurrentCheckout);
message.Respond(new ApplePayEventResponse(ApplePayAuthorizationStatus.Success, summaryItems).ToJsonString());
}
else
{
message.Respond(new ApplePayEventResponse(ApplePayAuthorizationStatus.Failure).ToJsonString());
}
});
}
/// <summary>
/// Updates the cart state by sending the checkout token.
/// </summary>
/// <param name="tokenizedPaymentInput">
/// A <see cref="TokenizedPaymentInput"> containing all information
/// needed to complete the checkout.
/// </param>
/// <param name="message">
/// A <see cref="NativeMessage"> object to call back to the Android plugin
/// when the checkout is successful or failed.
/// </param>
private void PerformCheckout(TokenizedPaymentInput tokenizedPaymentInput, NativeMessage message)
{
CartState.CheckoutWithTokenizedPayment(tokenizedPaymentInput, (ShopifyError error) => {
if (error == null)
{
AndroidPayCheckoutResponse.Status status = AndroidPayCheckoutResponse.Status.Success;
message.Respond(new AndroidPayCheckoutResponse(status).ToJsonString());
OnSuccess();
}
else
{
AndroidPayCheckoutResponse.Status status = AndroidPayCheckoutResponse.Status.Failure;
message.Respond(new AndroidPayCheckoutResponse(status).ToJsonString());
OnFailure(error);
}
});
}
public void CalculateTotalWithProductsAndDiscounts()
{
var state = new CartState(new Cart());
var product = TestProducts.Cars.First();
const int count = 2;
state.Products.Add(product, count);
var cartDiscount = new CartDiscount(50);
var productDiscount = new ProductDiscount(product, 50);
state.CartDiscounts.Add(cartDiscount);
state.ProductDiscounts.Add(product, productDiscount);
Assert.Equal(product.Price * count / 4, state.Total);
}
public void UpdateSummaryItemsForShippingContact(string serializedMessage)
{
var message = NativeMessage.CreateFromJSON(serializedMessage);
var contentDictionary = (Dictionary <string, object>)Json.Deserialize(message.Content);
var mailingAddressInput = new MailingAddressInput(contentDictionary);
CartState.SetShippingAddress(mailingAddressInput, (ShopifyError error) => {
if (error == null)
{
RespondToUpdateAddressSuccessForMessage(message);
}
else
{
RespondToUpdateAddressErrorForMessage(message, error);
}
});
}
public async Task AddFirstOne()
{
using var mocker = AutoMock.GetStrict();
await using var handler = mocker.Create <AddItemToCartEventHandler>();
var state = new CartState();
var evt = new AddItemToCartEvent
{
SkuId = "skuId1",
Count = 10
};
await handler.HandleEvent(state, evt, default);
state.Items.Count.Should().Be(1);
var(key, value) = state.Items.Single();
key.Should().Be(evt.SkuId);
value.Should().Be(evt.Count);
}
/// <summary>
/// Callback which is invoked from the Android plugin when the shipping address
/// becomes available on the Android Pay side. This method also gets called when the
/// user explicitly changes their shipping address to a different one.
/// </summary>
/// <param name="serializedMessage">
/// A <see cref="MailinAddressInput"> object represented as a JSON string
/// containing the shipping address.
/// </param>
public void OnUpdateShippingAddress(string serializedMessage)
{
var message = NativeMessage.CreateFromJSON(serializedMessage);
var contentDictionary = (Dictionary <string, object>)Json.Deserialize(message.Content);
var mailingAddressInput = new MailingAddressInput(contentDictionary);
CartState.SetShippingAddress(mailingAddressInput, (ShopifyError error) => {
if (error == null)
{
UpdateShippingLineWithDefault(message);
}
else
{
RespondError(message, error);
OnFailure(error);
}
});
}
public async Task RemoveSuccess()
{
using var mocker = AutoMock.GetStrict();
await using var handler = mocker.Create <RemoveAllItemsFromCartEventHandler>();
const string oldKey = "oneKey";
var state = new CartState
{
Items = new Dictionary <string, int>
{
{ oldKey, 100 }
}
};
var evt = new RemoveAllItemsFromCartEvent();
await handler.HandleEvent(state, evt, default);
state.Items.Should().BeNull();
}
// Update is called once per frame
void Update()
{
float cart_pos = cart.m_Path.ToNativePathUnits(cart.m_Position, CinemachinePathBase.PositionUnits.Distance);
if (state == CartState.Linked && Mathf.Abs(cart_pos - currentSwitchPoint) < 0.05)
{
cart.m_Path = nextPathLink;
cart.m_Position = 0;
currentSwitchPoint = waypoints.Length - 1;
state = CartState.Onlink;
}
else if (state == CartState.Onlink && Mathf.Abs(currentSwitchPoint - cart_pos) < 0.05)
{
cart.m_Path = nextPath;
state = CartState.Unlinked;
cart.m_Position = cart.m_Path.FromPathNativeUnits(nextStartPoint, CinemachinePathBase.PositionUnits.Distance);
currentSwitchPoint = 0;
}
}
public static string GetPrintableCart(CartState cartState, string label = "cart")
{
string itemsInCart = Messages.ShowCartTitle + label + ":" + Environment.NewLine;
foreach (var item in cartState.Items)
{
if (item.Count > 0)
{
itemsInCart += $"* **{Messages.Number}**: {item.No} {Environment.NewLine}";
itemsInCart += $"**{Messages.Description}**: {item.Description} {Environment.NewLine}";
itemsInCart += $"**{Messages.Count}**: {item.Count} {item.Base_Unit_of_Measure} {Environment.NewLine}";
itemsInCart += $"**{Messages.UnitPrice}**: {item.Unit_Price} {Environment.NewLine} {Environment.NewLine}";
}
}
itemsInCart += $"{Environment.NewLine} _________________________________ ";
itemsInCart += $"\n\n {Environment.NewLine} {Messages.ShowCartFullPrice} **{GetFullPrice(cartState.Items)}**";
return(itemsInCart);
}
private static CartState ChangeDirection(CartState cartState, char roadType)
{
var newCartState = new CartState(cartState);
if (roadType == '+')
{
string stateOnCross = "" + cartState.Direction + cartState.LastTurn;
var newStateOnCross = _crosses[stateOnCross];
newCartState.Direction = newStateOnCross[0];
newCartState.LastTurn = newStateOnCross[1];
}
else
{
string stateOnRoad = "" + cartState.Direction + roadType;
newCartState.Direction = _roads[stateOnRoad];
if (newCartState.Direction == '*')
{
throw new Exception("Wrong stateOnRoad " + stateOnRoad);
}
}
return(newCartState);
}
public async Task AddOneKeyFound()
{
using var mocker = AutoMock.GetStrict();
await using var handler = mocker.Create <AddItemToCartEventHandler>();
const string skuId = "skuId1";
var state = new CartState
{
Items = new Dictionary <string, int>
{
{ skuId, 60 }
}
};
var evt = new AddItemToCartEvent
{
SkuId = skuId,
Count = 10
};
await handler.HandleEvent(state, evt, default);
var(key, value) = state.Items.Single();
key.Should().Be(skuId);
value.Should().Be(70);
}
public iOSNativeCheckout(CartState cartState)
{
CartState = cartState;
}
