public void CreateSimpleProduct()
{
IProduct simpleProduct = new SimpleProduct("Iogurte", 2.40);
Assert.AreEqual("Iogurte", simpleProduct.Name);
Assert.AreEqual(2.40, simpleProduct.Price);
}
internal List <SimpleProduct> GetChildProducts(int connectorID, int productID, ProductHelper productHelper)
{
lock (_childProducts)
{
if (_childProducts.Count == 0)
{
LoadChildProducts();
}
}
List <ChildProductData> filteredItems;
if (_childProducts.ContainsKey(productID))
{
filteredItems = _childProducts[productID];
}
else
{
return(null);
}
var result = new List <SimpleProduct>();
foreach (var product in filteredItems)
{
var p = new SimpleProduct();
productHelper.FillProductWithBaseAttributes(p, product, connectorID, true, true);
result.Add(p);
}
return(result);
}
public Program()
{
ISimpleProduct product = new SimpleProduct();
product.SetName("printer");
Console.WriteLine(product.GetName());
}
public void AppliesDiscountInTheSimpleProduct()
{
IProduct p = new SimpleProduct("Product 1", 4.00);
//Applies 50% discount in the product p
DiscountProduct dicountProduct = new DiscountProduct(p, 50.0 / 100.0);
Assert.AreEqual(2, dicountProduct.Price); //because 4.00/2 = 2.00
}
public void Init()
{
Television = new SimpleProduct("television", 40.00M);
Stand = new SimpleProduct("stand", 20.00M);
House = new SimpleProduct("stand", 5000.00M);
InitiatedAt = new DateTime(2019, 1, 1);
Subject = new Activity(InitiatedAt);
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
if (value is string)
{
SimpleProduct product;
if (SimpleProduct.TryParse((string)value, out product))
{
return(product);
}
}
return(base.ConvertFrom(context, culture, value));
}
public virtual async Task <Response <SimpleProduct> > PutSimpleProductAsync(SimpleProduct simpleBodyProduct = null, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("ServiceClient.PutSimpleProduct");
scope.Start();
try
{
return(await RestClient.PutSimpleProductAsync(simpleBodyProduct, cancellationToken).ConfigureAwait(false));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual Response <SimpleProduct> PutSimpleProduct(SimpleProduct simpleBodyProduct = null, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("ServiceClient.PutSimpleProduct");
scope.Start();
try
{
return(RestClient.PutSimpleProduct(simpleBodyProduct, cancellationToken));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
private List <ProductBase> ProcessProducts(int connectorID, IEnumerable <ProductData> products, List <string> includes)
{
var counter = 0;
var result = new List <ProductBase>();
var start = DateTime.Now;
foreach (var product in products)
{
counter++;
ProductBase p;
if (product.IsConfigurable)
{
p = new ConfigurableProduct();
((ConfigurableProduct)p).ChildProducts = ChildProductHelper.GetChildProducts(connectorID, product.ProductID, this);
}
else
{
p = new SimpleProduct();
if (includes.Contains("prices"))
{
((SimpleProduct)p).Prices = PriceHelper.GetProductPrices(connectorID, product.ProductID);
}
if (includes.Contains("stock"))
{
((SimpleProduct)p).Stock = StockHelper.GetProductStocks(connectorID, product.ProductID);
}
}
FillProductWithBaseAttributes(p, product, connectorID, true, true);
result.Add(p);
if (counter % 100 == 0)
{
System.Diagnostics.Debug.WriteLine("{0} Processed {1} products", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), counter);
}
}
var end = DateTime.Now;
System.Diagnostics.Debug.WriteLine("Total processingtime: {0} seconds", end.Subtract(start).TotalSeconds);
return(result);
}
/// <summary>
/// Processes the create cart lines request.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="request">The request.</param>
/// <param name="transaction">Current transaction.</param>
/// <param name="returnTransaction">Return transaction.</param>
/// <param name="productByRecordId">The mapping of products by record identifier.</param>
private static void ProcessCreateCartLinesRequest(RequestContext context, SaveCartLinesRequest request, SalesTransaction transaction, SalesTransaction returnTransaction, IDictionary <long, SimpleProduct> productByRecordId)
{
// Create the new cart lines.
var salesLines = new List <SalesLine>();
foreach (CartLine cartLine in request.CartLines)
{
var salesLine = new SalesLine();
if (!cartLine.LineData.IsReturnByReceipt)
{
// Creates a sales line base on the cart line
salesLine.CopyPropertiesFrom(cartLine.LineData);
// Set ItemId and VariantInventDimId of the sales line, if the cart line is constructed from listing.
if (cartLine.LineData.IsProductLine)
{
long id = cartLine.LineData.ProductId;
SimpleProduct product = productByRecordId[id];
salesLine.ItemId = product.ItemId;
salesLine.ProductId = id;
salesLine.InventoryDimensionId = product.InventoryDimensionId;
salesLine.Variant = ProductVariant.ConvertFrom(product);
}
}
else
{
// Creates a sales line base on the retuned sales line
var returnedSalesLine = CartWorkflowHelper.GetSalesLineByNumber(returnTransaction, cartLine.LineData.ReturnLineNumber);
CartWorkflowHelper.SetSalesLineBasedOnReturnedSalesLine(salesLine, returnedSalesLine, returnTransaction, cartLine.LineData.Quantity);
// Calculate required reason code lines for return transaction.
ReasonCodesWorkflowHelper.CalculateRequiredReasonCodesOnSalesLine(context, transaction, salesLine, ReasonCodeSourceType.ReturnItem);
}
// Assign sales line Id. Using format 'N' to remove dashes from the GUID.
salesLine.LineId = Guid.NewGuid().ToString("N");
// Add sales lines to collection.
salesLines.Add(salesLine);
}
// Set default attributes from order header.
CartWorkflowHelper.SetDefaultDataOnSalesLines(context, transaction, salesLines);
// Add sales lines to transation.
transaction.SalesLines.AddRange(salesLines);
}
private void ValidateTransactiondata(KitTransaction kitTransaction)
{
ThrowIf.Null(kitTransaction.KitTransactionLines, "kitTransaction.KitTransactionLines");
if (!kitTransaction.KitTransactionLines.Any())
{
throw new DataValidationException(DataValidationErrors.Microsoft_Dynamics_Commerce_Runtime_RequiredValueNotFound, "Transaction does not contain any kit transaction line.");
}
// Validate transaction contains a valid kit variant
foreach (KitTransactionLine kitline in kitTransaction.KitTransactionLines)
{
if (string.IsNullOrWhiteSpace(kitline.InventoryDimensionId))
{
throw new DataValidationException(DataValidationErrors.Microsoft_Dynamics_Commerce_Runtime_RequiredValueNotFound, "InventoryDimensionId is not set for the Kit line transaction.");
}
var productLookupClauses = new List <ProductLookupClause> {
new ProductLookupClause(kitline.ItemId, kitline.InventoryDimensionId)
};
var request = new GetProductsServiceRequest(this.Context.GetChannelConfiguration().RecordId, productLookupClauses, QueryResultSettings.AllRecords);
var results = this.Context.Runtime.Execute <GetProductsServiceResponse>(request, this.Context).Products.Results;
if (results == null)
{
throw new DataValidationException(DataValidationErrors.Microsoft_Dynamics_Commerce_Runtime_UnableToFindListing, string.Format("Kit with itemId {0} and inventoryDimensionId {1} is not found.", kitline.ItemId, kitline.InventoryDimensionId));
}
if (results.HasMultiple())
{
throw new DataValidationException(DataValidationErrors.Microsoft_Dynamics_Commerce_Runtime_MultipleItemsForItemId, string.Format("ItemId {0} and inventoryDimensionId {1} returned multiple kit records. The ids do not represent a single kit product.", kitline.ItemId, kitline.InventoryDimensionId));
}
SimpleProduct product = results.Single();
if (product.ProductType != ProductType.KitVariant)
{
throw new DataValidationException(DataValidationErrors.Microsoft_Dynamics_Commerce_Runtime_RequiredValueNotFound, string.Format("ItemId {0} is not a kit product.", kitline.ItemId));
}
if (!product.Behavior.IsKitDisassemblyAllowed)
{
throw new DataValidationException(DataValidationErrors.Microsoft_Dynamics_Commerce_Runtime_RequiredValueNotFound, string.Format("Kit product '{0}' is not allowed to be disassembled at a register.", kitline.ItemId));
}
}
}
public Task PutModelFlattenCustomBase() => Test(async(host, pipeline) =>
{
var value = new SimpleProduct("123")
{
Description = "product description",
MaxProductDisplayName = "max name",
Capacity = "Large",
OdataValue = "http://foo",
GenericValue = "https://generic"
};
var result = await new ServiceClient(ClientDiagnostics, pipeline, host).PutSimpleProductAsync(value);
Assert.AreEqual("123", result.Value.ProductId);
Assert.AreEqual("product description", result.Value.Description);
Assert.AreEqual("max name", result.Value.MaxProductDisplayName);
Assert.AreEqual("Large", result.Value.Capacity);
Assert.AreEqual("http://foo", result.Value.OdataValue);
Assert.AreEqual("https://generic", result.Value.GenericValue);
});
public async Task <IEnumerable <SimpleProduct> > GetSimpleProducts(IEnumerable <long> productIds)
{
if (productIds == null)
{
throw new ArgumentNullException(nameof(productIds));
}
ManagerFactory managerFactory = Utilities.GetManagerFactory(this.EcommerceContext);
IProductManager productManager = managerFactory.GetManager <IProductManager>();
long channelId = await Utilities.GetChannelId(this.EcommerceContext);
var distinctProductIds = productIds.Distinct();
Task <SimpleProduct>[] simpleProductTasks = new Task <SimpleProduct> [distinctProductIds.Count()];
// Enable batching when batching bug is fixed. Currently, batching fails if the server returns a no-content response.
//// managerFactory.Context.BeginBatch();
int index = 0;
foreach (long productId in distinctProductIds)
{
simpleProductTasks[index++] = productManager.GetById(productId, channelId);
}
//// await managerFactory.Context.ExecuteBatchAsync();
Collection <SimpleProduct> simpleProducts = new Collection <SimpleProduct>();
foreach (Task <SimpleProduct> simpleProductTask in simpleProductTasks)
{
SimpleProduct simpleProduct = await simpleProductTask;
if (simpleProduct != null)
{
simpleProducts.Add(simpleProduct);
}
}
IEnumerable <ProductCatalog> productCatalogs = await this.GetProductCatalogs(Utilities.DefaultQuerySettings);
simpleProducts = await DataAugmenter.GetAugmentedSimpleProducts(this.EcommerceContext, simpleProducts, productCatalogs);
return(simpleProducts);
}
private void buildProducts()
{
//Simple product construction
Ram4gb = new SimpleProduct("RAM 4GB", 750, "KingStone");
Ram8gb = new SimpleProduct("RAM 8GB", 1000, "KingStone");
Disk500gb = new SimpleProduct("HDD 500GB", 1500, "ACME");
Disk1tb = new SimpleProduct("HDD 1TB", 2000, "ACME");
CpuAMD = new SimpleProduct("AMD phenon", 4000, "AMD");
CpuIntel = new SimpleProduct("Intel i7", 4500, "Intel");
SmallCabinete = new SimpleProduct("Small cabinet", 2000, "ExCom");
BigCabinete = new SimpleProduct("Big Cabinet", 2200, "ExCom");
Monitor20inch = new SimpleProduct("Display 20'", 1500, "HP");
Monitor30inch = new SimpleProduct("Display 30'", 2000, "HP");
SimpleMouse = new SimpleProduct("Simple mouse", 150, "Genius");
GammerMouse = new SimpleProduct("Gammer mouse", 750, "Alien");
//Gammer pc with 8gb ram,HDD 1tb, Intel i7 processor
//large cabinet,display 30' and one gammer mouse.
GammerPC = new CompositeProduct("Gammer PC");
GammerPC.AddProduct(Ram8gb);
GammerPC.AddProduct(Disk1tb);
GammerPC.AddProduct(CpuIntel);
GammerPC.AddProduct(BigCabinete);
GammerPC.AddProduct(Monitor30inch);
GammerPC.AddProduct(GammerMouse);
//Home PC with RAM 4gb, HDD 500gb, AMD Phenon processor
//small Cabinet, dsplay 20' and simple mouse.
HomePC = new CompositeProduct("Home PC");
HomePC.AddProduct(Ram4gb);//
HomePC.AddProduct(Disk500gb);
HomePC.AddProduct(CpuAMD);
HomePC.AddProduct(SmallCabinete);
HomePC.AddProduct(Monitor20inch);
HomePC.AddProduct(SimpleMouse);
//Package consisting of two packages, Gammer PC + Home PC
Pc2x1 = new CompositeProduct("Pack PC Gammer + Home PC");
Pc2x1.AddProduct(GammerPC);
Pc2x1.AddProduct(HomePC);
}
static void Main(string[] args)
{
var ram = new SimpleProduct("Memoria RAM GigaBit Módulo de 16GB", 150000);
var processor = new SimpleProduct("Intel Core i7", 750000);
var videoCard = new SimpleProduct("nVidia GTX 1050", 1500000);
var keyBoard = new SimpleProduct("Keyboard generic 101 keys - Intel", 20000);
var mouse = new SimpleProduct("Mouse generic 3 buttons - Intel", 20000);
var computerGeneric = new CompositeProduct("Computer Gamer Generic");
computerGeneric.Add(ram);
computerGeneric.Add(processor);
computerGeneric.Add(videoCard);
computerGeneric.Add(keyBoard);
computerGeneric.Add(mouse);
Console.WriteLine($"Precio de {ram.Name} es: ${ram.GetPrice().ToString("N2")}");
Console.WriteLine($"Precio de {computerGeneric.Name} es: ${computerGeneric.GetPrice().ToString("N2")}");
Console.ReadLine();
}
/// <summary>
/// Retrieves the products ids (record ids) for reason codes that trigger upsell.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="reasonCodes">The reason codes.</param>
private static void SetProductIdsForUpsell(RequestContext context, IEnumerable <ReasonCode> reasonCodes)
{
IEnumerable <ReasonSubCode> itemSubCodes = reasonCodes.SelectMany(reasonCode => reasonCode.ReasonSubCodes)
.Where(subCode => subCode.TriggerFunctionType == TriggerFunctionType.Item);
if (itemSubCodes.IsNullOrEmpty())
{
return;
}
IEnumerable <ProductLookupClause> lookupClauses = itemSubCodes.Where(itemSubCode => !string.IsNullOrWhiteSpace(itemSubCode.TriggerCode)).Select(subCode => new ProductLookupClause(subCode.TriggerCode, inventDimId: null));
var productSearchRequest = new GetProductsServiceRequest(
context.GetPrincipal().ChannelId,
lookupClauses,
QueryResultSettings.AllRecords);
PagedResult <SimpleProduct> products = context.Execute <GetProductsServiceResponse>(productSearchRequest).Products;
foreach (ReasonSubCode itemSubCode in itemSubCodes)
{
if (string.IsNullOrWhiteSpace(itemSubCode.TriggerCode))
{
RetailLogger.Log.CrtServicesReasonCodeServiceUpsellSubCodeWithEmptyTriggerCode(itemSubCode.ReasonCodeId, itemSubCode.SubCodeId);
continue;
}
SimpleProduct product = products.Results.FirstOrDefault(p => string.Equals(p.ItemId, itemSubCode.TriggerCode, StringComparison.OrdinalIgnoreCase));
if (product != null)
{
itemSubCode.ProductId = product.RecordId;
}
else
{
RetailLogger.Log.CrtServicesReasonCodeServiceProductNotFoundForTriggeredUpsell(itemSubCode.ReasonCodeId, itemSubCode.SubCodeId, itemSubCode.TriggerCode);
}
}
}
//
// Constructor. Initialises the product database.
//
public ProductController() : base()
{
// our products will be stored in a dictionary
products = new ProductDictionaryAdapter();
// add some test products to the database
SimpleProduct bookByOtero = new SimpleProduct(1, "Software Engineering Design book", 80.00M, 0.25M);
SimpleProduct bookByMillett = new SimpleProduct(2, "Professional ASP.NET Design Patterns book", 50.00M, 0.50M);
SimpleProduct notesFromLectures = new SimpleProduct(3, "Lecture slides", 10.00M, 0.00M);
SimpleProduct notesFromLabs = new SimpleProduct(4, "Printed lab notes", 10.00M, 0.10M);
products.Insert(bookByOtero);
products.Insert(bookByMillett);
products.Insert(notesFromLectures);
products.Insert(notesFromLabs);
// create some product packages
CompositeProduct bookPack = new CompositeProduct(10, "Textbook pack", bookByOtero, bookByMillett);
CompositeProduct notesPack = new CompositeProduct(11, "Notes pack", notesFromLectures, notesFromLabs);
products.Insert(bookPack);
products.Insert(notesPack);
}
public void Run()
{
//Productos simples
SimpleProduct ram4gb = new SimpleProduct("RAM 4GB", "Kingston", 750);
SimpleProduct ram8gb = new SimpleProduct("RAM 8GB", "Adata", 1000);
SimpleProduct disc500Gb = new SimpleProduct("Disco duro 500GB", "WesternDigital", 1500);
SimpleProduct disc1Tb = new SimpleProduct("Disco duro 1 TB", "Toshiba", 2000);
SimpleProduct cpuAMD = new SimpleProduct("Cpu AMD phenom", "AMD", 4000);
SimpleProduct cpuIntel = new SimpleProduct("Cpu Intel Lake", "Intel", 4500);
SimpleProduct bigGabinete = new SimpleProduct("Gabinete grande", "GabGRande", 2200);
SimpleProduct pequeGabinete = new SimpleProduct("Gabinete pequenio", "GabPequenio", 2000);
SimpleProduct monitor20inch = new SimpleProduct("Monitor 20 pulgadas", "DELL", 1500);
SimpleProduct monitor30inch = new SimpleProduct("Monitor 30 pulgadas", "HP", 2000);
SimpleProduct simpleMouse = new SimpleProduct("Mouse sencillo", "Loitech", 150);
SimpleProduct gamerMouse = new SimpleProduct("Mouse gamer", "Alien", 750);
SimpleProduct keyBoard = new SimpleProduct("Teclado", "Acme", 100);
//Producots compuestos
CompositeProduct keyBoardAndMouse = new CompositeProduct("KeyBoard & mouse ", 0);
keyBoardAndMouse.AddProduct(simpleMouse); //150
keyBoardAndMouse.AddProduct(keyBoard); //100
CompositeProduct package1 = new CompositeProduct("Desktop pc", 0);
package1.AddProduct(ram4gb); //750
package1.AddProduct(disc500Gb); //1500
package1.AddProduct(cpuIntel); //4500
package1.AddProduct(keyBoardAndMouse); //250
Orden orden = new Orden(1, "Alex");
orden.addProduct(package1);
orden.addProduct(pequeGabinete);
orden.printOreder();
}
/// <summary>
/// Put Simple Product with client flattening true on the model
/// <see href="http://tempuri.org" />
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='simpleBodyProduct'>
/// Simple body product to put
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <SimpleProduct> PutSimpleProductAsync(this IAutoRestResourceFlatteningTestService operations, SimpleProduct simpleBodyProduct = default(SimpleProduct), CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.PutSimpleProductWithHttpMessagesAsync(simpleBodyProduct, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public void Init()
{
Television = new SimpleProduct("television", new Money(40.00M, InitiatedAt));
Stand = new SimpleProduct("stand", new Money(20.00M, InitiatedAt));
House = new SimpleProduct("stand", new Money(5000.00M, InitiatedAt));
}
/// <summary>
/// Put Simple Product with client flattening true on the model
/// <see href="http://tempuri.org" />
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='simpleBodyProduct'>
/// Simple body product to put
/// </param>
public static SimpleProduct PutSimpleProduct(this IAutoRestResourceFlatteningTestService operations, SimpleProduct simpleBodyProduct = default(SimpleProduct))
{
return(operations.PutSimpleProductAsync(simpleBodyProduct).GetAwaiter().GetResult());
}
/// <summary>
/// Put Simple Product with client flattening true on the model
/// <see href="http://tempuri.org" />
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='simpleBodyProduct'>
/// Simple body product to put
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async System.Threading.Tasks.Task<SimpleProduct> PutSimpleProductAsync(this IAutoRestResourceFlatteningTestService operations, SimpleProduct simpleBodyProduct = default(SimpleProduct), System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken))
{
using (var _result = await operations.PutSimpleProductWithHttpMessagesAsync(simpleBodyProduct, null, cancellationToken).ConfigureAwait(false))
{
return _result.Body;
}
}
/// <summary>
/// Put Simple Product with client flattening true on the model
/// <see href="http://tempuri.org" />
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='simpleBodyProduct'>
/// Simple body product to put
/// </param>
public static SimpleProduct PutSimpleProduct(this IAutoRestResourceFlatteningTestService operations, SimpleProduct simpleBodyProduct = default(SimpleProduct))
{
return System.Threading.Tasks.Task.Factory.StartNew(s => ((IAutoRestResourceFlatteningTestService)s).PutSimpleProductAsync(simpleBodyProduct), operations, System.Threading.CancellationToken.None, System.Threading.Tasks.TaskCreationOptions.None, System.Threading.Tasks.TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
}
public IHttpActionResult BindSimpleProductFromUri(SimpleProduct product)
{
Debugger.Break();
return(Ok());
}
/*
* HandlePosEvent is called from _ui_Notify event listener (above).
*
* Most messages are simply turned into .NET events. A few do more,
* especially:
* ADD_TO_BASKET : Updates our own Basket object with new items
* REMOVE_FROM_BASKET : Removes item from our own Basket
* BASKET_COMMITTED : Updates the Basket state; and fetches all the vouchers
*/
private void HandlePosEvent(PosEvent posEvent)
{
if (posEvent == null)
{
// Debug.Assert(false);
return;
}
if (_timeoutTimer != null)
{
_timeoutTimer.Enabled = false;
_timeoutTimer = null;
}
switch (posEvent.EventName)
{
case PosEventType.READY:
Ready?.Invoke(this, null);
_rollbackHandler.ProcessPendingRollbacks(_config.Url);
break;
case PosEventType.SHOW_GUI:
_ui.Show();
ShowGUI?.Invoke(this, null);
break;
case PosEventType.HIDE_GUI:
_ui.Hide();
HideGUI?.Invoke(this, null);
break;
case PosEventType.ADD_TO_BASKET:
var addedItem = (AddToBasketEvent)posEvent;
_basket.Id = addedItem.BasketId;
_basket.Items.Add(addedItem.BasketItem);
ItemAdded?.Invoke(this, addedItem.BasketItem);
break;
case PosEventType.BASKET_COMMITTED:
var basketCommittedEvent = (BasketCommittedEvent)posEvent;
// Check:
// (1) Incoming .BasketId is what we expect. This is just a sanity check, and should never fail.
// (2) basketCommittedEvent.Basket.Committed = TRUE
// (3) this.FailOnCommit = FALSE. This may be set to TRUE to test correct processing of a Commit failure.
if (_basket.Id == basketCommittedEvent.BasketId && basketCommittedEvent.Basket.Committed && !FailOnCommit)
{
_basket.Clear();
_basket.Id = basketCommittedEvent.BasketId;
foreach (var basketItem in basketCommittedEvent.Basket.basketItems)
{
_basket.Items.Add(basketItem); // Now with Touch ID, and Vouchers (we trust!)
if (basketItem is PurchaseBasketItem)
{
var purchase = (PurchaseBasketItem)basketItem;
if (purchase.Vouchers?.Count > 0)
{
GetVoucher(purchase.Vouchers[0].Link);
}
}
else if (basketItem is RefundBasketItem)
{
var refund = (RefundBasketItem)basketItem;
if (refund.RefundVoucher != null)
{
GetVoucher(refund.RefundVoucher.Link);
}
}
}
_basket.Committed = true;
BasketCommitted?.Invoke(this, _basket);
}
else
{
ProcessFailedCommit();
}
// _basket.Clear();
break;
case PosEventType.REMOVE_FROM_BASKET:
var removeFromBasketEvent = (RemoveFromBasketEvent)posEvent;
foreach (var basketItem in _basket.Items)
{
if (basketItem.Id == removeFromBasketEvent.BasketItemId)
{
_basket.Items.Remove(basketItem);
ItemRemoved?.Invoke(this, basketItem);
break;
}
}
break;
case PosEventType.PRINT_VOUCHER: // This is an "unexpected" ad hoc voucher...
var PrintVoucherEvent = (PrintVoucherEvent)posEvent;
VoucherAvailable?.Invoke(this, PrintVoucherEvent.Data);
break;
case PosEventType.VOUCHER_HTML: //...whereas this is the response to the BasketGetVoucherEvent message
var voucherHtmlEvent = (VoucherHtmlEvent)posEvent;
if (!string.IsNullOrEmpty(voucherHtmlEvent.VoucherHtml))
{
VoucherAvailable?.Invoke(this, voucherHtmlEvent.VoucherHtml);
}
break;
case PosEventType.START_DEVICE:
var startDeviceEvent = (StartDeviceEvent)posEvent;
StartDevice?.Invoke(this, startDeviceEvent.Device);
break;
case PosEventType.STOP_DEVICE:
var stopDeviceEvent = (StopDeviceEvent)posEvent;
StopDevice?.Invoke(this, stopDeviceEvent.Device);
break;
case PosEventType.DISPLAY_MESSAGE:
var displayMessageEvent = (DisplayMessageEvent)posEvent;
DisplayMessage?.Invoke(this, displayMessageEvent.Message);
break;
case PosEventType.SIMPLE_PRODUCT:
var simpleProductEvent = (SimpleProductEvent)posEvent;
SimpleProduct?.Invoke(this, new SimpleProductInfo(simpleProductEvent));
break;
case PosEventType.SYNC_BASKET:
var synBasketEvent = (SyncBasketEvent)posEvent;
SyncBasket?.Invoke(this, null);
break;
case PosEventType.ERROR:
var errorEvent = (ErrorEvent)posEvent;
if (errorEvent.Method == "BasketCommitBasket")
{
ProcessFailedCommit();
}
Error?.Invoke(this, errorEvent.Reason);
break;
default:
Debug.Assert(false); // Unknown PosEventType
break;
}
}
/// <summary>
/// Put Simple Product with client flattening true on the model
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='simpleBodyProduct'>
/// Simple body product to put
/// </param>
public static SimpleProduct PutSimpleProduct(this IAutoRestResourceFlatteningTestService operations, SimpleProduct simpleBodyProduct = default(SimpleProduct))
{
return(Task.Factory.StartNew(s => ((IAutoRestResourceFlatteningTestService)s).PutSimpleProductAsync(simpleBodyProduct), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
