private static DiscountMethodType GetDiscountMethodType(PeriodicDiscountOfferType periodicDiscountType, int discountTypeFromDatabase) { DiscountMethodType discountMethod = DiscountMethodType.DealPrice; // ISNULL(pdmm.MIXANDMATCHDISCOUNTTYPE, ISNULL(pdmb.MULTIBUYDISCOUNTTYPE, pd.PERIODICDISCOUNTTYPE)) switch (periodicDiscountType) { case PeriodicDiscountOfferType.Offer: case PeriodicDiscountOfferType.Promotion: discountMethod = DiscountMethodType.LineSpecific; break; case PeriodicDiscountOfferType.MixAndMatch: case PeriodicDiscountOfferType.MultipleBuy: discountMethod = (DiscountMethodType)discountTypeFromDatabase; break; case PeriodicDiscountOfferType.Threshold: discountMethod = DiscountMethodType.LineSpecific; break; default: NetTracer.Warning("Unsupported discount type: {0}", discountTypeFromDatabase); break; } return(discountMethod); }
/// <summary> /// Load the device. /// </summary> /// <exception cref="IOException"></exception> public void Load() { if (LSRetailPosis.Settings.HardwareProfiles.PinPad.DeviceType != DeviceTypes.OPOS) { return; } NetTracer.Information("Peripheral [PinPad] - OPOS device loading: {0}", DeviceName ?? "<Undefined>"); oposPinpad = new OPOSPINPadClass(); // Open oposPinpad.Open(DeviceName); Peripherals.CheckResultCode(this, oposPinpad.ResultCode); // Claim oposPinpad.ClaimDevice(Peripherals.ClaimTimeOut); Peripherals.CheckResultCode(this, oposPinpad.ResultCode); // Configure/Enable oposPinpad.DataEvent += new _IOPOSPINPadEvents_DataEventEventHandler(posPinpad_DataEvent); oposPinpad.ErrorEvent += new _IOPOSPINPadEvents_ErrorEventEventHandler(posPinpad_ErrorEvent); oposPinpad.DeviceEnabled = true; IsActive = true; }
/// <summary> /// Initializes a new instance of the <see cref="SearchViewModel"/> class. /// </summary> /// <param name="searchType">Startup type of the search.</param> /// <param name="searchTerm">The search term.</param> public SearchViewModel(SearchType searchType, string searchTerm) { this.MinimumSearchTermLengh = MINIMUM_SEARCH_TERM_LENGTH; this.SearchTerms = searchTerm ?? string.Empty; this.SearchType = searchType; // If search type is category then search term is the "Category RecId" if (searchType == SearchType.Category) { Tuple <string, long> categoryDetail; if ((long.TryParse(SearchTerms, out this.searchCategoryId)) && (categoryDetail = itemData.GetCategoryDetails(searchCategoryId)) != null) { this.SearchTerms = categoryDetail.Item1; this.searchCategoryHierarchyId = categoryDetail.Item2; } else { NetTracer.Warning("SearchViewModel : Invalid category specified '{0}'", searchTerm); } } if (searchCategoryHierarchyId == 0) { this.searchCategoryHierarchyId = itemData.GetRetailProductHierarchy(); } }
/// <summary> /// Open the cash drawer. /// </summary> public void OpenDrawer() { if (FiscalPrinter.FiscalPrinter.Instance.FiscalPrinterEnabled()) { FiscalPrinter.FiscalPrinter.Instance.OpenDrawer(); return; } if (IsActive) { NetTracer.Information("Peripheral [CashDrawer] - Open drawer"); switch (this.DeviceType) { case DeviceTypes.OPOS: oposCashDrawer.OpenDrawer(); break; case DeviceTypes.Windows: using (SerialPort port = new SerialPort(this.DeviceName, 9600, Parity.None, 8, StopBits.One)) { port.Open(); port.Write(OPEN_DRAWER_SEQUENCE); } break; case DeviceTypes.Manual: // NoOp break; } } }
/// <summary> /// Process Linked InfoCodes for TenderLineItem /// </summary> /// <param name="posTransaction"></param> /// <param name="tenderLineItem"></param> /// <param name="storeId"></param> /// <param name="tableRefId"></param> /// <param name="infoCodeType"></param> public void ProcessLinkedInfoCodes(IPosTransaction posTransaction, ITenderLineItem tenderLineItem, string storeId, InfoCodeTableRefType tableRefId, InfoCodeType infoCodeType) { TenderLineItem lineItem = tenderLineItem as TenderLineItem; if (lineItem == null) { NetTracer.Warning("tenderLineItem parameter is null"); throw new ArgumentNullException("tenderLineItem"); } //Loop while a linkedInfoCode is found int i = 0; //Set as a stop for a infinite loop LinkedListNode <InfoCodeLineItem> infoCodeItem = lineItem.InfoCodeLines.Last; if (infoCodeItem != null) { while (!string.IsNullOrEmpty(infoCodeItem.Value.LinkedInfoCodeId) && (i < 10)) { ProcessInfoCode(posTransaction, 0, lineItem.Amount, storeId, lineItem.TenderTypeId, lineItem.CurrencyCode, tableRefId, infoCodeItem.Value.LinkedInfoCodeId, infoCodeItem.Value, infoCodeType); // This is to prevent an infinite loop when infocodes link to themselves.. if (infoCodeItem.Value.LinkedInfoCodeId == lineItem.InfoCodeLines.Last.Value.LinkedInfoCodeId) { break; } infoCodeItem = lineItem.InfoCodeLines.Last; i++; } } }
void ReaderController.ReaderStateChangedListener.onError(string message) { NetTracer.Warning(string.Format("An error occured : {0}", message)); // Restart the device to capture the swipe information again. this.StartReader(); }
void ReaderController.ReaderStateChangedListener.onDecodeCompleted(Dictionary <string, string> decodeData) { NetTracer.Information(string.Format("Entering onDecodeCompleted event...")); if (this.RamblerCardSwipeEvent != null) { // The card has been read and decoded. // Now parse the received data and send it to the subscriber lock (SyncLock) { if (!this.isCardReaderEnabled) { return; } try { RamblerMagneticStripeCardData ramblerCardData = new RamblerMagneticStripeCardData(); // Parse the received data and return card ramblerCardData.ParseCard(decodeData); // Notify the client with the rambler card data. this.NotifyCompleted(ramblerCardData); } catch { NetTracer.Warning(string.Format("The tracks information are not extracted correctly. Retrying again...")); // Restart the device to capture the swipe information again. this.StartReader(); } } } }
void ReaderController.ReaderStateChangedListener.onDecodeError(DecodeResult decodeResult) { NetTracer.Warning(string.Format("The decode error occured : {0}", decodeResult.ToString())); // Restart the device to capture the swipe information again. this.StartReader(); }
private bool ShowPinEntry(string strFormName, string optionalCardNumber) { bool success = false; try { if (this.DeviceIsConnected()) { if (!string.IsNullOrWhiteSpace(optionalCardNumber)) { this.fpe.SetVariableValue("cnum", optionalCardNumber); } this.fpe.GoToScreen(strFormName); success = true; } } catch (COMException ex) { NetTracer.Warning(ex, "L5300Terminal - FPE COM exception for PinPadFrm"); } return(success); }
/// <summary> /// Load the device. /// </summary> /// <exception cref="IOException"></exception> public void Load() { if (LSRetailPosis.Settings.HardwareProfiles.Scale.DeviceType != DeviceTypes.OPOS) { return; } NetTracer.Information("Peripheral [Scale] - OPOS device loading: {0}", DeviceName ?? "<Undefined>"); oposScale = new OPOSScaleClass(); // Open oposScale.Open(DeviceName); Peripherals.CheckResultCode(this, oposScale.ResultCode); // Claim oposScale.ClaimDevice(Peripherals.ClaimTimeOut); Peripherals.CheckResultCode(this, oposScale.ResultCode); // Enable/Configure oposScale.DataEvent += new _IOPOSScaleEvents_DataEventEventHandler(posScale_DataEvent); oposScale.ErrorEvent += new _IOPOSScaleEvents_ErrorEventEventHandler(posScale_ErrorEvent); oposScale.DeviceEnabled = true; oposScale.AsyncMode = true; oposScale.AutoDisable = true; oposScale.DataEventEnabled = true; oposScale.PowerNotify = (int)OPOS_Constants.OPOS_PN_ENABLED; IsActive = true; }
private bool ShowForm(string strFormName, IEnumerable <FormProperty> properties) { bool success = false; try { if (this.DeviceIsConnected()) { this.fpe.GoToScreen(strFormName); if (strFormName == "TransactionMsrFrm" && properties != null) { this.DisplayLines(properties.ToArray()); } success = true; } } catch (COMException ex) { NetTracer.Warning(ex, "L5300Terminal - FPE COM exception"); } return(success); }
/// <summary> /// Load the device. /// </summary> /// <exception cref="IOException">Cannot load device</exception> public void Load() { if (this.DeviceType == DeviceTypes.None) { return; } if (this.DeviceType == DeviceTypes.OPOS) { NetTracer.Information("Peripheral [CashDrawer] - OPOS device loading: {0}", this.DeviceName ?? "<Undefined>"); oposCashDrawer = new OPOSCashDrawerClass(); // Open oposCashDrawer.Open(this.DeviceName); Peripherals.CheckResultCode(this, oposCashDrawer.ResultCode); // Claim oposCashDrawer.ClaimDevice(Peripherals.ClaimTimeOut); Peripherals.CheckResultCode(this, oposCashDrawer.ResultCode); // Enable oposCashDrawer.DeviceEnabled = true; oposCashDrawer.StatusUpdateEvent += new _IOPOSCashDrawerEvents_StatusUpdateEventEventHandler(posCashDrawer_StatusUpdateEvent); } IsActive = true; }
/// <summary> /// Given a transaction, choose the discounts which should be active on each line /// according to the concurrency rules and add them to the sales items /// </summary> /// <param name="retailTransaction">Transaction whose discounts and sales items will be processed</param> public static void ApplyConcurrencyRules(RetailTransaction retailTransaction) { if (retailTransaction == null) { NetTracer.Warning("retailTransaction parameter is null"); throw new ArgumentNullException("retailTransaction"); } // In order to choose the best discount to apply when choosing from multiple we need to know // the effect of the offer on the whole transaction. So we get a list of offers on the transaction // for each type of concurrency, and sort them with largest discounts first. List <OfferGroup> sortedExclusiveOffers; List <OfferGroup> sortedBestPriceOffers; List <OfferGroup> sortedConcurrentOffers; GetSortedOfferLists(retailTransaction, out sortedExclusiveOffers, out sortedBestPriceOffers, out sortedConcurrentOffers); // Then, starting with exclusive offers, then best price, then compound offers, we find the best that apply. // We keep track of applied offers to given them priority. This ensures that once a line in a discount group (like mix and match) // chooses an offer, the rest of the members of the group will see the offer first. // We keep track of rejected offers to exclude them from consideration. This ensures that once an exclusive offer or best price // offer is chosen, no other offers one that line are available for use. Example would be if an exclusive multibuy on an item // is activated and a mix and match offer is also available for that item. The exclusive multibuy takes priority and no other // items in that mix and match group should be able to have the mix and match discount. HashSet <OfferGroup> appliedOffers = new HashSet <OfferGroup>(); HashSet <OfferGroup> rejectedOffers = new HashSet <OfferGroup>(); ApplyPeriodicDiscounts(retailTransaction, ConcurrencyMode.Exclusive, sortedExclusiveOffers, appliedOffers, rejectedOffers); ApplyPeriodicDiscounts(retailTransaction, ConcurrencyMode.BestPrice, sortedBestPriceOffers, appliedOffers, rejectedOffers); ApplyPeriodicDiscounts(retailTransaction, ConcurrencyMode.Compounded, sortedConcurrentOffers, appliedOffers, rejectedOffers); }
public virtual Image Create(string text, float xDpi = DEFAULT_DPI, float yDpi = DEFAULT_DPI) { NetTracer.Information("Peripheral [{0}] - Create", this); Bitmap barcodeImage = null; using (Font barcodeFont = new Font(FontName, FontSize)) { if (barcodeFont.Name.Equals(barcodeFont.OriginalFontName, StringComparison.Ordinal)) // If font installed. { using (Font barcodeTextFont = new Font(TEXT_FONT_NAME, TEXT_FONT_SIZE)) // Text font { try { text = Encode(text); SizeF barcodeSizeF = GetTextSizeF(text, barcodeFont, xDpi, yDpi); float barcodeTextHeight = barcodeTextFont.GetHeight(yDpi); barcodeImage = new Bitmap((int)barcodeSizeF.Width, (int)(barcodeSizeF.Height + barcodeTextHeight)); barcodeImage.SetResolution(xDpi, yDpi); using (Graphics graphic = Graphics.FromImage(barcodeImage)) { // Calculate left/right margin for drawing barcode considering dpi being used. float XYWithMargin = (xDpi / DEFAULT_DPI) * 5; // Draw barcode graphic.DrawString(text, barcodeFont, Brushes.Black, XYWithMargin, XYWithMargin); // Draw text below barcode in center RectangleF textRect = new RectangleF(0, barcodeSizeF.Height, barcodeSizeF.Width, barcodeTextHeight); using (StringFormat textFormat = new StringFormat(StringFormatFlags.NoClip) { Alignment = StringAlignment.Center }) { graphic.DrawString(text, barcodeTextFont, Brushes.Black, textRect, textFormat); } } } catch (Exception ex) { if (barcodeImage != null) { barcodeImage.Dispose(); } NetTracer.Error(ex, "Peripheral [{0}] - Exception during barcode creation.", this); } } } else { NetTracer.Error("Peripheral [{0}] - Barcode creation failed. Font {1} in not installed.", this, FontName); } } return(barcodeImage); }
/// <summary> /// Read the formula from the DB for the given group and code. /// </summary> /// <param name="taxGroup"></param> /// <param name="taxCode"></param> /// <returns></returns> public static Formula GetFormula(string taxGroup, string taxCode) { // Default value for the formula Formula formula = new Formula { TaxableBasis = TaxableBases.LineAmount, PriceIncludesTax = false, Id = 0, // Since Id's are always greater than 0 in AX, this 0 value indicates formula was not found. CalculationExpression = String.Empty }; try { using (SqlCommand command = new SqlCommand()) { command.Connection = Connection; command.CommandText = @"SELECT TAXABLEBASIS, PRICEINCLTAX, ID, CALCEXP1 FROM dbo.FORMULADESIGNER_IN WHERE TAXITEMGROUP = @TaxItemGroup AND TAXCODE = @TaxCode AND DATAAREAID = @DataAreaID" ; command.Parameters.AddWithValue("@TaxItemGroup", taxGroup); command.Parameters.AddWithValue("@TaxCode", taxCode); command.Parameters.AddWithValue("@DataAreaID", ApplicationSettings.Database.DATAAREAID); if (Connection.State != ConnectionState.Open) { Connection.Open(); } using (SqlDataReader reader = command.ExecuteReader()) { if (reader.Read()) { formula.TaxableBasis = (TaxableBases)reader["TAXABLEBASIS"]; formula.PriceIncludesTax = (int)reader["PRICEINCLTAX"] == 1; formula.Id = (int)reader["ID"]; formula.CalculationExpression = (string)reader["CALCEXP1"]; } else { NetTracer.Warning("GetFormula: Formula set to default. Unable to obtain formula from DB. No rows present for taxGroup: {0}; taxCode: {1}; DataAreaID: {2}", taxGroup, taxCode, ApplicationSettings.Database.DATAAREAID); } } } } catch (Exception ex) { NetTracer.Warning(ex, "GetFormula: Formula set to default. Unable to obtain formula from DB due to an exception. taxGroup: {0}; taxCode: {1}", taxGroup, taxCode); LSRetailPosis.ApplicationExceptionHandler.HandleException("FormulaData", ex); // Not necessary to rethrow because formula is set to default state. } finally { if (Connection.State == ConnectionState.Open) { Connection.Close(); } } return(formula); }
/// <summary> /// Given a set of promotion lines, tentative item price, and item, calculate the price after promotions are applied /// </summary> /// <param name="promotionLines">List of promotion configurations active for this item</param> /// <param name="price">Price of the item before the promotion, derived from trade agreement or base item price</param> /// <param name="saleItem">The sale item whose price is being determined</param> /// <returns>Unrounded price after applying all promotions</returns> public static decimal CalculatePromotionPrice(IEnumerable <PromotionInfo> promotionLines, decimal price, BaseSaleItem saleItem) { if (saleItem == null) { NetTracer.Warning("saleItem parameter is null"); throw new ArgumentNullException("saleItem"); } if (promotionLines == null || promotionLines.Count() == 0) { return(price); } decimal promoPrice = price; IList <PromoPrice> promoPrices = new List <PromoPrice>(); foreach (PromotionInfo promo in promotionLines) { PromoPrice promoLine = new PromoPrice(); promoLine.PromoId = promo.PromoId; promoLine.Concurrency = promo.Concurrency; promoLine.IsCompoundable = false; switch (promo.DiscountMethod) { case DiscountMethod.DiscountPercent: promoLine.PercentOff = promo.MaxDiscPct; promoLine.IsCompoundable = true; promoPrices.Add(promoLine); break; case DiscountMethod.OfferPrice: if (!saleItem.Transaction.TaxIncludedInPrice) { promoLine.AmountOff = price - promo.Price; promoPrices.Add(promoLine); } break; case DiscountMethod.OfferPriceInclTax: if (saleItem.Transaction.TaxIncludedInPrice) { promoLine.AmountOff = price - promo.PriceInclTax; promoPrices.Add(promoLine); } break; case DiscountMethod.DiscountAmount: promoLine.AmountOff = promo.MaxDiscAmount; promoLine.IsCompoundable = true; promoPrices.Add(promoLine); break; } } promoPrice = price - FindConcurrentPromoAmount(promoPrices, price); return(promoPrice); }
/// <summary> /// Display transaction on device /// </summary> /// <param name="posTransaction">PosTransation</param> public void ShowTransaction(IPosTransaction posTransaction) { if (IsActive) { NetTracer.Information("Peripheral [DualDisplay] - Show Transaction"); dualDisplayForm.ShowTransaction((PosTransaction)posTransaction); } }
/// <summary> /// Opens a peripheral. /// </summary> /// <param name="peripheralName">Name of the peripheral.</param> /// <param name="peripheralConfig">The peripheral configuration.</param> public void Open(string peripheralName, PeripheralConfiguration peripheralConfig) { this.CashDispenserName = peripheralName; // Open the cash dispenser. NetTracer.Information("Cash dispenser is opened for device '{0}'.", peripheralName); return; }
private void NotifyCompleted(RamblerMagneticStripeCardData card) { NetTracer.Information("Notify client with the MSR card data"); if (this.RamblerCardSwipeEvent != null) { this.RamblerCardSwipeEvent(this, card); } }
public void Unlock(LockedSessionRequest request) { ThrowIf.Null(request, "request"); LockManager.ReleaseLock <IRamblerStripeReader>(request.Token); NetTracer.Information(string.Format("The device is closed")); NetTracer.Information(string.Format("The Msr lock is released, token: {0}", request.Token)); }
private void posScale_DataEvent(int weight) { NetTracer.Information("Peripheral [Scale] - Data Event: {0}", weight); if (ScaleDataMessageEvent != null) { ScaleDataMessageEvent(weight); } }
/// <summary> /// Executes the assign on currently selected operator. /// </summary> /// <param name="extendedLogOnInfo">The extended log on info.</param> /// <exception cref="PosisException">Thrown if save failed.</exception> public void ExecuteAssign(IExtendedLogOnInfo extendedLogOnInfo) { NetTracer.Information("ExtendedLogOnViewModel::ExecuteAssign: Start."); bool saved = false; try { logonData.DbUtil.BeginTransaction(); // Save a local copy for immediate availability at store. logonData.CreateExtendedLogOn(this.SelectedResult.OperatorID, extendedLogOnInfo); // Save in HQ this.AxCreateExtendedLogOn(extendedLogOnInfo); saved = true; } catch (SqlException ex) { if (ex.Number == SQL_ERROR_DUPLICATE_RECORD) { throw new PosisException(ex.Number, ex) { ErrorMessageNumber = STRING_ALREADY_EXISTS }; } else if (ex.Number == SQL_ERROR_NULL_DATA) { throw new PosisException(ex.Number, ex) { ErrorMessageNumber = STRING_STAFF_NOT_FOUND }; } // Any other Sql error will be thrown as it is. throw; } finally { if (saved) { logonData.DbUtil.EndTransaction(); SelectedResult.ExtendedLogOnAssigned = true; OnPropertyChanged("Results"); NetTracer.Information("ExtendedLogOnViewModel::ExecuteAssign: Successful."); } else { logonData.DbUtil.CancelTransaction(); NetTracer.Error("ExtendedLogOnViewModel::ExecuteAssign: Failed."); } } }
/// <summary> /// Called when [application end request]. /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param> private void OnApplicationEndRequest(object sender, EventArgs e) { var response = HttpContext.Current.Response; if (response.StatusCode == (int)HttpStatusCode.Unauthorized) { NetTracer.Warning("Authentication failed for request '{0}' from the host '{1}'", HttpContext.Current.Request.Url, HttpContext.Current.Request.UserHostAddress); response.Headers.Add(AuthenticateHeader, AuthorizationScheme); } }
/// <summary> /// Creates failed <see cref="ValidateAddressDataResponse"/> response. /// </summary> /// <param name="errorCode">The error code associated with the failed address component.</param> /// <param name="faultAddressComponent">The failed address component.</param> /// <returns>The <see cref="ValidateAddressDataResponse"/> response.</returns> private static ValidateAddressDataResponse CreateFailedValidateAddressDataResponse(DataValidationErrors errorCode, string faultAddressComponent) { // If address is not valid, tell the user/client code : which component is the faulty one var message = string.Format(CultureInfo.InvariantCulture, @"Incorrect address provided: validate {0} property.", faultAddressComponent); NetTracer.Information(message); // create the response object and return return(new ValidateAddressDataResponse(isAddressValid: false, invalidAddressComponentName: faultAddressComponent, errorCode: errorCode, errorMessage: message)); }
/// <summary> /// Disable device for capture. /// </summary> public void EndCapture() { if (this.oposSigCapClass != null && this.IsActive) { NetTracer.Information("Peripheral [SigCap] - End Capture"); this.oposSigCapClass.DeviceEnabled = false; this.oposSigCapClass.DataEventEnabled = false; } }
/// <summary> /// Disable MSR for swipe. /// </summary> public void DisableForSwipe() { if (IsActive) { NetTracer.Information("Peripheral [MSR] - Device and Data Event disabled"); oposMSR.DeviceEnabled = false; oposMSR.DataEventEnabled = false; } }
/// <summary> /// Enable Scanner device for scan. /// </summary> public void ReEnableForScan() { if (IsActive) { NetTracer.Information("Peripheral [Scanner] - Device and Data Event enabled"); oposScanner.DataEventEnabled = true; oposScanner.DeviceEnabled = true; } }
/// <summary> /// Gets the sales line shipping rates for sales line group. /// </summary> /// <param name="salesLineGroup">The sales line group.</param> /// <param name="warehouseAddresses">The warehouse addresses.</param> /// <param name="itemGrossWeights">The item gross weights.</param> /// <param name="shippingAdapterConfigRecords">The shipping adapter configuration records.</param> /// <param name="requestContext">The request context.</param> /// <returns> /// An enumeration of sales line ids with corresponding shipping rates and weights. /// </returns> private static IEnumerable <SalesLineShippingRate> GetSalesLineShippingRatesPerGroup( IEnumerable <SalesLine> salesLineGroup, Dictionary <string, Address> warehouseAddresses, Dictionary <string, decimal> itemGrossWeights, IEnumerable <ShippingAdapterConfig> shippingAdapterConfigRecords, RequestContext requestContext) { // We package all the items with identical dlv mode, origin and destination addresses into one package. // Total weight of all items in current saleslines group decimal totalWeight; Address shippingDestination = null; Address shippingOrigin = null; string deliveryModeId = null; // Since destination, origin and delivery mode are identical for all lines within a group, we can grab values from any member of the list. // Does not matter if it is the first element, or the last, or anywhere in the middle. if (salesLineGroup != null && salesLineGroup.Any()) { shippingDestination = salesLineGroup.First().ShippingAddress; shippingOrigin = warehouseAddresses[salesLineGroup.First().InventoryLocationId.ToUpperInvariant()]; deliveryModeId = salesLineGroup.First().DeliveryMode; } var salesLineShippingRateList = GetSalesLineShippingRateListAndTotalWeight(salesLineGroup, itemGrossWeights, out totalWeight); ShippingRateInfo shippingRateInfo = new ShippingRateInfo { FromAddress = shippingOrigin, ToAddress = shippingDestination, GrossWeight = totalWeight }; // Get Carrier info ParameterSet adapterConfig = ExtractAdapterConfigForSpecificDeliveryMode(deliveryModeId, shippingAdapterConfigRecords); var carrierServiceRequest = new GetShippingRateFromCarrierServiceRequest(adapterConfig, shippingRateInfo); IRequestHandler carrierAdapterHandler = GetCarrierAdapterService(requestContext, carrierServiceRequest.GetType(), adapterConfig); if (carrierAdapterHandler != null) { // Contact carrier var carrierServiceResponse = requestContext.Execute <GetShippingRateFromCarrierServiceResponse>(carrierServiceRequest, carrierAdapterHandler); var totalShippingCharge = carrierServiceResponse.ShippingRate; // Redistribute rates across the salesline based on their weights foreach (var lineShippingRate in salesLineShippingRateList) { lineShippingRate.ShippingCharge = (totalShippingCharge * lineShippingRate.NetWeight) / totalWeight; } } else { NetTracer.Warning("No registered carrier adapter is found."); } return(salesLineShippingRateList); }
public void Print() { DM.CustomerDataManager customerDataManager = new DM.CustomerDataManager( ApplicationSettings.Database.LocalConnection, ApplicationSettings.Database.DATAAREAID); //Get the balances IList <DE.CustomerBalanceInfo> customerBalances = customerDataManager.GetCustomersBalances(); if ((customerBalances != null) && (customerBalances.Count > 0)) { //Print header information int charsInLine = 44; string line = "--------------------------------------------" + "\n"; string reportName = LSRetailPosis.ApplicationLocalizer.Language.Translate(51020); //"BALANCE REPORT" int leftPad = (charsInLine - reportName.Length) / 2; string report = "\n" + reportName.PadLeft(leftPad + reportName.Length) + "\n\n\n"; report += LSRetailPosis.ApplicationLocalizer.Language.Translate(51021) + " " + DateTime.Now.ToShortDateString() + " " + DateTime.Now.ToShortTimeString() + "\n\n"; //"Report printed" //Customer //Name //Balance report += LSRetailPosis.ApplicationLocalizer.Language.Translate(51022).PadRight(10).Substring(0, 10) + " " + LSRetailPosis.ApplicationLocalizer.Language.Translate(51023).PadRight(20).Substring(0, 20) + " " + LSRetailPosis.ApplicationLocalizer.Language.Translate(51024).PadLeft(12).Substring(0, 12) + "\n"; report += line; string customerId = string.Empty; string name = string.Empty; decimal balance = 0; decimal total = 0; //Loop throug the customer balances foreach (var customerBalance in customerBalances) { customerId = customerBalance.AccountNumber; name = customerBalance.Name; balance = customerBalance.Balance; total += balance; report += customerId.PadRight(10) + " " + name.PadRight(20).Substring(0, 20) + " " + (balance.ToString("n2")).PadLeft(12) + "\n"; } //Printer footer report += line; string totalText = LSRetailPosis.ApplicationLocalizer.Language.Translate(51025) + ": "; //TOTAL report += totalText.PadLeft(32) + (total.ToString("n2")).PadLeft(12) + "\n\n\n"; //Send text to printer if (((object)Customer.InternalApplication.Services.Printing) is IPrintingV2) { // Print to the default printer Customer.InternalApplication.Services.Printing.PrintDefault(true, report); } else { // Legacy support - direct print to printer #1 NetTracer.Warning("BalanceReport.Print - Printing service does not support default printer. Using printer #1"); Customer.InternalApplication.Services.Peripherals.Printer.PrintReceipt(report); } } }
/// <summary> /// Unload the device. /// </summary> public void Unload() { if (IsActive && dualDisplayForm != null) { NetTracer.Information("Peripheral [DualDisplay] - Device Released"); dualDisplayForm.Dispose(); dualDisplayForm = null; IsActive = false; } }