public void AddFunds(IClient client, double amount, ICurrency currency, IEmailSender emailSender, ILogger logger) { if (client.Accounts.Count > 0) { IAccount account = client.Accounts[0]; if (!(currency is DinarCurrency)) { amount = FinanceManager.Convert(currency, amount); } if (client is IOrganization) { if (amount < 10000) { logger.ErrorLogg("Amount cannot be smaller than 10000 for organizations"); return; } } if (account.Credit != null) { FinanceManager.CreditPayment(account.Id, amount); emailSender.SendEmail("Credit debt is reduced.", client.Email); } else { FinanceManager.AccountPayment(account.Id, amount); } } else { throw new Exception("This user has 0 accounts"); } }
/// <summary> /// Constructor /// </summary> /// <param name="account">User account</param> /// <param name="value">Initial value for this order</param> /// <param name="requestedCurrency">Currency that is requested</param> /// <param name="feeFactory">Fee factory to use for calculating transaction costs</param> public MonetaryOrder(IAccountTypeInternal account, Money value, ICurrency requestedCurrency, IFeeFactory feeFactory) : base(account, value) { this.requestedCurrency = requestedCurrency; checkInitialValues(); setCommission(feeFactory); }
public Journal(JournalTypes journalType, string journalNumber, IManagementCompany managementCompany, ICurrency currency) { this.JournalType = journalType; this.JournalNumber = journalNumber; this.ManagementCompany = managementCompany; this.currency = Currency; }
/// <summary> /// Initializes a new instance of the <see cref="T:B4F.TotalGiro.Instruments.Price">Price</see> class. /// </summary> /// <param name="quantity">The quantity (just a number) of the price</param> /// <param name="underlying">The currency the price is in</param> /// <param name="instrument">The instrument to which the price belongs</param> /// <param name="xRate">The xRate involved</param> public Price(Decimal quantity, ICurrency underlying, IInstrument instrument, decimal xRate) { this.quantity = quantity; this.underlying = underlying; this.instrument = instrument; this.xRate = xRate; }
public void SerializingValidValueWithDoubleRepresentation( [ValueSource(nameof(AllCurrencies))] ICurrency currency) { var amount = 1.23m; var value = new Money(amount, currency); var stub = new StubWithDoubleRepresentation() { Money = value }; var doc = Serialize(stub); doc = doc.GetValue(_moneyField).AsBsonDocument; BsonValue amountValue = null; BsonValue currencyValue = null; Assert.Multiple(() => { Assert.DoesNotThrow(() => amountValue = doc.GetElement(_customAmountFieldName).Value); Assert.DoesNotThrow(() => currencyValue = doc.GetElement(_customCurrencyFieldName).Value); }); Assert.Multiple(() => { Assert.That(amountValue.BsonType, Is.EqualTo(BsonType.Double)); Assert.That(amountValue.AsDouble, Is.EqualTo((double)amount)); Assert.That(currencyValue.BsonType, Is.EqualTo(BsonType.String)); Assert.That(currencyValue.AsString, Is.EqualTo(currency.CharCode)); }); }
protected override string CreateRequestUrl(double amount, ICurrency fromCurrency, ICurrency toCurrency) { return(string.Format(@"http://www.bing.com/search?q={0}+{1}+in+{2}+site%3Anowhereplace.pt&scope=web&mkt=en-US&FORM=W0LH", amount, fromCurrency.Name.Replace(" ", "+"), toCurrency.Name.Replace(" ", "+"))); }
public Change Add(ICurrency currencyType, int count = 1) { if (_currency.ContainsKey(currencyType)) count += _currency[currencyType]; _currency[currencyType] = count; return this; }
protected void Button3_Click(object sender, EventArgs e) { try { //connect string connectMessage = Connect(); //get base currency ICompany thisCompany = _session.Company.Get(); if (thisCompany == null) { throw new Exception("No company found."); } ICurrency thisCurrency = thisCompany.BaseCurrency; if (thisCurrency == null) { throw new Exception("No currency found."); } TextBox4.Text += thisCurrency.Code; } catch (Exception ex) { TextBox4.Text += ex.Message; } finally { //always disconnect after we are finished. Disconnect(); } }
/// <summary> /// Initializes Exchange object /// </summary> /// <param name="ExchangeName">Name</param> /// <param name="defaultCurrency">Default currency</param> /// <param name="defaultCountry">Default country</param> /// <param name="defaultSettlementPeriod">Default settlement period</param> public Exchange(string ExchangeName, ICurrency defaultCurrency, ICountry defaultCountry, short defaultSettlementPeriod) { this.exchangeName = ExchangeName; this.defaultCountry = defaultCountry; this.DefaultCurrency = defaultCurrency; this.defaultSettlementPeriod = defaultSettlementPeriod; }
/// <summary> /// Constructor for creating a test FeeClient object /// </summary> /// <param name="account"></param> /// <param name="instrument"></param> /// <param name="side"></param> /// <param name="actiontype"></param> /// <param name="transactionDate"></param> /// <param name="issizebased"></param> /// <param name="orderValue"></param> /// <param name="amount"></param> /// <param name="price"></param> /// <param name="ordercurrency"></param> /// <param name="isValueInclComm"></param> public CommClient(IAccountTypeInternal account,IInstrument instrument, Side side, OrderActionTypes actiontype, DateTime transactionDate, bool issizebased, InstrumentSize orderValue, Money amount, Price price, ICurrency ordercurrency, bool isValueInclComm) { if (account == null) throw new ApplicationException("It is not possible to calculate the commission when the account is unknown."); if (instrument == null) throw new ApplicationException("It is not possible to calculate the commission when the instrument value is unknown."); this.account = account; this.instrument = instrument; this.Side = side; this.ActionType = actiontype; this.TransactionDate = transactionDate; this.IsSizeBased = issizebased; this.OriginalOrderType = issizebased ? BaseOrderTypes.SizeBased : BaseOrderTypes.AmountBased; this.Value = orderValue; this.amount = amount; this.Price = price; this.OrderCurrency = ordercurrency; this.IsValueInclComm = isValueInclComm; type = CommClientType.Test; }
public void SetModel(ICurrency currency) { this.currency = currency; currencyNameText.text = currency.Name; balanceText.text = currency.Balance.ToString(); currency.AddBallanceChangeListener(OnBalanceChanged); }
public async Task <CryptonatorApiResponse> GetConversionRateAsync(ICurrency primary, ICurrency secondary) { if (primary == null || secondary == null) { throw new ArgumentNullException("You cannot specify null as currency."); } if ((primary.Type & CurrencyType.Primary) != CurrencyType.Primary) { throw new ArgumentException("Specified primary currency is not usable as primary currency.", nameof(primary)); } if ((secondary.Type & CurrencyType.Secondary) != CurrencyType.Secondary) { throw new ArgumentException("Specified secondary currency is not usable as secondary currency.", nameof(primary)); } var url = string.Concat("https://api.cryptonator.com/api/full/", primary.Code.ToLower(), "-", secondary.Code.ToLower()); using (var req = new HttpRequestMessage(HttpMethod.Get, url)) { var res = await this.Http.SendAsync(req); if (!res.IsSuccessStatusCode) { throw new Exception("Cryptonator API returned an error."); } var resd = JsonConvert.DeserializeObject <CryptonatorApiResponse>(await res.Content.ReadAsStringAsync()); return(resd); } }
public virtual ICurrency Calculate(ICurrency currency, decimal price, decimal tender) { if (currency.AllDenominations.Count == 0) { throw new InvalidCurrencyException("No currency denominations found"); } decimal change = tender - price; // the currency.AllDenominations.Min(x => x.Denomination) is to ensure that if there is a currency that // has a minimum value that is less then that change, the extra will be "dropped" and no infinite loop will occur. // This itself has the problem that in a large system, these "dropped" percentages could be significant. This would // be addressed with the business and the development team to determine the best course of action. while (change >= currency.AllDenominations.Min(x => x.Denomination)) { foreach (Money money in currency.AllDenominations) { while (change >= money.Denomination) { money.Add(1); change -= money.Denomination; } } } return(currency); }
public DataSet SelectCurrencyTest(ICurrency currency) { DataSet tableVerify = new DataSet(); tableVerify = dbEntity.SelectObject(currency) as DataSet; return(tableVerify); }
public CurrencyExchangeResult(ICurrency exchangedCurrency, double exchangedAmount, DateTime timestamp, object state) { ExchangedCurrency = exchangedCurrency; ExchangedAmount = exchangedAmount; Timestamp = timestamp; State = state; }
protected override string CreateRequestUrl(double amount, ICurrency fromCurrency, ICurrency toCurrency) { return(string.Format(@"http://moneycentral.msn.com/investor/market/currencyconverter.aspx?strAmt={0}&iSelectCurFrom={1}&iSelectCurTo={2}", amount, ((MsnMoneyCurrency)fromCurrency).Id, ((MsnMoneyCurrency)toCurrency).Id)); }
private String addRateLog(ForumPost data, String content) { if (data.Rate == 0) { return(content); } List <ForumRateLog> logs = rateService.GetByPost(data.Id); StringBuilder sb = new StringBuilder(); sb.AppendFormat("<div class=\"forum-rate-list\"><div class=\"forum-rate-title\">{0}</div>", alang("creditLog")); sb.Append("<table class=\"forum-rate-table table table-condensed\">"); foreach (ForumRateLog x in logs) { ICurrency currency = currencyService.GetICurrencyById(x.CurrencyId); sb.Append("<tr>"); sb.AppendFormat("<td class=\"forum-rate-user\"><a href=\"{0}\" target=\"_blank\">{1}</a></td>", toUser(x.User), x.User.Name); sb.AppendFormat("<td class=\"forum-rate-name\">{0} <span class=\"forum-rate-value\">+{1}</span></td>", currency.Name, x.Income); sb.AppendFormat("<td class=\"forum-rate-note\">{0}</td>", x.Reason); sb.AppendFormat("<td class=\"forum-rate-time\">{0}</td>", x.Created.ToString("g")); sb.Append("</tr>"); } sb.Append("</table></div>"); return(content + sb.ToString()); }
public async Task <int> CreateOrder(int userid, CreateorderPayload createorderPayload) { List <Task> addticketstoorder = new List <Task>(); var order = new Order(); order.Orderitems = createorderPayload.Ordertoreserve; var occurrencedateintid = await WithConnection(async c => { return(c.Query <int>("select Activity_occurrence_id from Activity_occurrence where Activity_id = @activityid and Start_datetime = @activitydate", new { activityid = createorderPayload.Activityid, @activitydate = createorderPayload.Activityoccurrencedate }, commandType: CommandType.Text).FirstOrDefault()); }); var orderid = await WithConnection(async c => { DynamicParameters parameters = new DynamicParameters(); parameters.Add("@activityoccurrenceid", occurrencedateintid, DbType.Int32); parameters.Add("@userid", userid, DbType.Int32); parameters.Add("@amount", order.Orderamount, DbType.Int32); parameters.Add("@output", DbType.Int32, direction: ParameterDirection.Output); await c.ExecuteAsync("Createorder", parameters, commandType: CommandType.StoredProcedure); int output = parameters.Get <int>("@output"); return(output); }); foreach (var ticket in createorderPayload.Ordertoreserve) { ICurrency currency = null; await new TicketRepository(_config).AddTickettoorder(occurrencedateintid, orderid, ticket.Id, ticket.Quantity); } //await Task.WhenAll(addticketstoorder); return(orderid); }
/// <summary> /// Initializes a new instance of the <see cref="T:B4F.TotalGiro.Instruments.Price">Price</see> class. /// </summary> /// <param name="money">This is the amount that one particular instrument to which the price belongs would cost</param> /// <param name="instrument">The instrument to which the price belongs</param> public Price(Money money, IInstrument instrument) { this.quantity = money.Quantity; this.underlying = (ICurrency)money.Underlying; this.instrument = instrument; this.XRate = money.XRate; }
public bool CanUseOnNormal(ICurrency currency) { var item = _factory.GetNormal(); AffixManager affixManager = CreateAffixManager(item.ItemBase); return(currency.Execute(item, affixManager)); }
private void ClearCurrency(ICurrency currency) { foreach (Money money in currency.AllDenominations) { money.Clear(); } }
public async Task Update( ICurrency currency, CancellationToken cancellationToken = default(CancellationToken)) { ThrowIfDisposed(); cancellationToken.ThrowIfCancellationRequested(); if (currency == null) { throw new ArgumentException("currency must not be null"); } if (currency.Id == Guid.Empty) { throw new ArgumentException("currency must have a non-empty id"); } var c = Currency.FromICurrency(currency); await EnsureProjectId().ConfigureAwait(false); await currencyCommands.UpdateAsync( projectId, c.Id.ToString(), c, cancellationToken).ConfigureAwait(false); }
protected override void InitializeObject(IGenericEntity ent) { if (ent is ICurrency) { ICurrency Currency = (ICurrency)ent; DBStoredProcedure spInsert = new DBStoredProcedure(); spInsert.ProcedureName = "catInsertCurrency"; spInsert.AddParameter(new DBParameter("@Code", DbType.String, ParameterDirection.Input, Currency.Code)); spInsert.AddParameter(new DBParameter("@Name", DbType.String, ParameterDirection.Input, Currency.Name)); DBStoredProcedure spUpdate = new DBStoredProcedure(); spUpdate.ProcedureName = "catUpdateCurrency"; spUpdate.AddParameter(new DBParameter("@Id", DbType.Int32, ParameterDirection.Input, Currency.Id)); spUpdate.AddParameter(new DBParameter("@Code", DbType.String, ParameterDirection.Input, Currency.Code)); spUpdate.AddParameter(new DBParameter("@Name", DbType.String, ParameterDirection.Input, Currency.Name)); DBStoredProcedure spDelete = new DBStoredProcedure(); spDelete.ProcedureName = "catDeleteCurrency"; spDelete.AddParameter(new DBParameter("@Id", DbType.Int32, ParameterDirection.Input, Currency.Id)); this.AddStoredProcedure("InsertObject", spInsert); this.AddStoredProcedure("UpdateObject", spUpdate); this.AddStoredProcedure("DeleteObject", spDelete); DBStoredProcedure spSelect = new DBStoredProcedure(); spSelect.ProcedureName = "catSelectCurrency"; spSelect.AddParameter(new DBParameter("@Id", DbType.Int32, ParameterDirection.Input, Currency.Id)); this.AddStoredProcedure("SelectObject", spSelect); } }
public void Show(ICurrency currency) { if ((mode & Target.Customer) == Target.Customer || showCashierMessage) { customerForm.Show(currency); } }
private async void OnPriceChanged() { Price price = Price; if (price == null) { Content = null; return; } if (price.Currency != currency?.UniqueCode) { currency = currencyProvider.Get(price.Currency); string symbol = await queryDispatcher.QueryAsync(new GetCurrencySymbol(price.Currency)); if (symbol != currency.Symbol) { currency = currency.ForCustomSymbol(symbol); } } Content = new TextBlock() { Text = currency.Format(price.Value), FontSize = FontSize, Foreground = Foreground, }; }
public async Task <IActionResult> CurrencyEdit(Guid?currencyGuid) { ViewBag.Title = "Edit Currency"; ViewBag.Heading = "Edit Currency"; CurrencyViewModel model = new CurrencyViewModel(); if (currencyGuid.HasValue) { ICurrency currency = await dataManager.FetchCurrency(currencyGuid.Value); model.Guid = currency.Guid; model.Title = currency.Title; model.Code = currency.Code; //var node = SiteMaps.Current.FindSiteMapNodeFromKey("CurrencyEdit"); //if (node != null) //{ // node.Title = "Edit Currency"; //} } return(View(model)); }
public void Setup() { _gold = new Currency(Guid.NewGuid(), "Gold", "GLD", 0, 999); _itemDef = new ItemDefinition(Guid.NewGuid()) { name = "Root item", description = "Some description of root item", layoutShape = new ComplexShape2D(new bool[3, 3] { { true, false, false }, { false, true, false }, { false, false, true }, }), maxStackSize = 3, buyPrice = new CurrencyDecorator <double>[] { new CurrencyDecorator(_gold, 10d), }, sellPrice = new CurrencyDecorator <double>[] { new CurrencyDecorator(_gold, 7d), } }; _childItemDef = new ItemDefinition(Guid.NewGuid(), _itemDef) { name = "Child item", description = "Child description", maxStackSize = 10, }; }
public ShopItem(int id, ICurrency price, ISellableItem item, List <ShopItemOption> shopItemOptions) { Id = id; Price = price; Item = item; ShopItemOptions = shopItemOptions; }
public IActionResult Get(string moeda, int valorEmCentavos) { //Validar as entradas if (valorEmCentavos < 0) { return(BadRequest("Valor em centavos inválido")); } if (moeda == null || moeda.Length != 3) { return(BadRequest("Moeda inválida")); } ICurrency currency = FactoryCurrency.Create(moeda); IAPIExternalController apilayer = _APIExternalController; var taxas = apilayer.Live(currency.GetMoedas().ToArray()); if (taxas == null) { return(StatusCode((int)HttpStatusCode.InternalServerError, "Erro interno, verificar logs ou solicitar ajuda ao administrador do sistema")); } if (!currency.IsValid(taxas)) { return(BadRequest("Moeda desconhecida")); } double taxaUSD = currency.GetTaxaUSD(taxas); double taxaMoeda = currency.GetTaxaMoeda(taxas); return(base.Ok(CalcularRetorno(valorEmCentavos, taxaUSD, taxaMoeda))); }
public virtual string Display(ICurrency currency) { // METHOD 1 - with foreach loop (did not remove code so reviewers could evaluate both methods) //StringBuilder sr = new StringBuilder(); //foreach (Money money in currency.AllDenominations) //{ // if (money.Count > 0) // { // sr.Append(String.Format("{0} {1},", money.Count, money.Name)); // } //} // METHOD 2 - Using LINQ.. both one line and 2 line versions. 1 line version commented out due to complexity and clarity var money = currency.AllDenominations.Where(x => x.Count > 0); var sr = money.Aggregate(new StringBuilder(), (x, y) => x.Append(String.Format("{0} {1},", y.Count, y.Name))); //var sr = currency.AllDenominations.Where(x => x.Count > 0).Aggregate(new StringBuilder(), (x, y) => x.Append(String.Format("{0} {1},", y.Count, y.Name))); if (sr.Length == 0) { return(String.Format("{0}\n", "No Change Due")); // not part of the requirements, yet exact change is a viable value. } else { return(String.Format("{0}\n", sr.ToString().Trim(','))); } }
public void GetAllConversionsRecursive(ICurrency start, double startConversionRate, Dictionary <ICurrency, ConversionTable <ICurrency, double> .Row> dict) { foreach (var kvp in start.conversionTable.conversions) { var rate = kvp.Value.conversionRate * startConversionRate; // Already have this conversion in our table, and it's not better than we one we have. if (dict.ContainsKey(kvp.Key)) { if (rate > dict[kvp.Key].conversionRate) { // Conversion rate is better than we currently have. dict[kvp.Key] = new ConversionTable <ICurrency, double> .Row(rate); GetAllConversionsRecursive(kvp.Key, kvp.Value.conversionRate * startConversionRate, dict); } continue; } dict[kvp.Key] = new ConversionTable <ICurrency, double> .Row(rate); GetAllConversionsRecursive(kvp.Key, kvp.Value.conversionRate * startConversionRate, dict); } }
public async Task <bool> Add( ICurrency currency, CancellationToken cancellationToken = default(CancellationToken)) { if (currency == null) { return(false); } cancellationToken.ThrowIfCancellationRequested(); if (currency.Guid == Guid.Empty) { currency.Guid = Guid.NewGuid(); } bool result = await dbCurrency.Create( currency.Guid, currency.Title, currency.Code, currency.SymbolLeft, currency.SymbolRight, currency.DecimalPointChar, currency.ThousandsPointChar, currency.DecimalPlaces, currency.Value, currency.LastModified, currency.Created, cancellationToken); return(result); }
public void Show(ICurrency currency) { if ((mode & Target.Cashier) == Target.Cashier) { touchForm.Show(currency); } }
public async Task Update( ICurrency currency, CancellationToken cancellationToken = default(CancellationToken)) { ThrowIfDisposed(); cancellationToken.ThrowIfCancellationRequested(); if (currency == null) { throw new ArgumentException("currency must not be null"); } if (currency.Id == Guid.Empty) { throw new ArgumentException("currency must have a non-empty id"); } var c = Currency.FromICurrency(currency); bool tracking = dbContext.ChangeTracker.Entries <Currency>().Any(x => x.Entity.Id == c.Id); if (!tracking) { dbContext.Currencies.Update(c); } int rowsAffected = await dbContext.SaveChangesAsync(cancellationToken) .ConfigureAwait(false); }
static void Main() { Console.WriteLine("Select currency: £ = 1, $ = 2"); ICurrency currency = CurrencySelector.CurrencySelect(Console.ReadLine()); if (currency != null) { Console.WriteLine("What is the till's float?"); if (int.TryParse(Console.ReadLine(), out int cashFloat)) { currency = CurrencyCalc.SetFloat(cashFloat, currency); } foreach (int denomination in currency.Denominations) { Console.WriteLine(currency.SpecifiedCurrency + denomination); if (int.TryParse(Console.ReadLine(), out int numberOfdenominations)) { currency = CurrencyCalc.CalculateCurrency(numberOfdenominations, denomination, currency); } } currency = CurrencyCalc.CalculateBankingTotal(currency); Console.WriteLine("Total cash in the till: " + currency.SpecifiedCurrency + currency.CashTotal); Console.WriteLine("Total Amount of cash to be banked: " + currency.SpecifiedCurrency + currency.BankingTotal); } else { Console.WriteLine("No Valid currency selected"); } }
/// <summary> /// The formatted price. /// </summary> /// <param name="display"> /// The display. /// </param> /// <param name="currency"> /// The currency. /// </param> /// <returns> /// The <see cref="string"/>. /// </returns> public static string FormattedPrice(this ProductDisplay display, ICurrency currency) { if (!display.ProductVariants.Any()) { return(FormatPrice(display.Price, currency)); } var variants = display.ProductVariants.ToArray(); var onsaleLow = variants.Any(x => x.OnSale) ? variants.Where(x => x.OnSale).Min(x => x.SalePrice) : 0; var low = variants.Any(x => !x.OnSale) ? variants.Where(x => !x.OnSale).Min(x => x.Price) : 0; var onSaleHigh = variants.Any(x => x.OnSale) ? variants.Where(x => x.OnSale).Max(x => x.SalePrice) : 0; var max = variants.Any(x => !x.OnSale) ? variants.Where(x => !x.OnSale).Max(x => x.Price) : 0; if (variants.Any(x => x.OnSale)) { low = onsaleLow < low ? onsaleLow : low; max = max > onSaleHigh ? max : onSaleHigh; } if (low != max) { return(string.Format( "{0} - {1}", FormatPrice(low, currency), FormatPrice(max, currency))); } return(FormatPrice(display.Price, currency)); }
public ShopItem(int id, ICurrency price, ISellableItem item) { Id = id; Price = price; Item = item; ShopItemOptions = new List <ShopItemOption>(); }
/// <summary> /// Initializes a new instance of the <see cref="CheckoutManagerSummaryFactory"/> class. /// </summary> /// <param name="currency"> /// The <see cref="ICurrency"/>. /// </param> /// <param name="basketLineItemFactory"> /// The basket Line Item Factory. /// </param> public CheckoutManagerSummaryFactory(ICurrency currency, BasketLineItemFactory basketLineItemFactory) { Mandate.ParameterNotNull(currency, "currency"); Mandate.ParameterNotNull(basketLineItemFactory, "basketLineItemFactory"); _currency = currency; _basketLineItemFactory = basketLineItemFactory; }
/// <summary> /// Return currency from number code /// </summary> /// <param name="numCode"> /// number code /// </param> /// <param name="currency"> /// currency /// </param> /// <returns> /// true if ISO 4217 contain this currency /// </returns> public static bool TryParse(int numCode, out ICurrency currency) { currency = Parse(numCode); if(currency != null) return true; currency = new UnknownCurrency(numCode); return false; }
/// <summary> /// Return currency from character code /// </summary> /// <param name="charCode"> /// character code /// </param> /// <param name="currency"> /// currency /// </param> /// <returns> /// true if ISO 4217 contain this currency /// </returns> public static bool TryParse(string charCode, out ICurrency currency) { currency = Parse(charCode); if(currency != null) return true; currency = new UnknownCurrency(charCode); return false; }
/// <summary> /// Initializes a new instance of the <see cref="SalePreparationSummaryFactory"/> class. /// </summary> /// <param name="currency"> /// The <see cref="ICurrency"/>. /// </param> /// <param name="basketLineItemFactory"> /// The basket Line Item Factory. /// </param> public SalePreparationSummaryFactory(ICurrency currency, BasketLineItemFactory basketLineItemFactory) { Mandate.ParameterNotNull(currency, "currency"); Mandate.ParameterNotNull(basketLineItemFactory, "basketLineItemFactory"); _currency = currency; _basketLineItemFactory = basketLineItemFactory; }
public AccountDetailsView(ICurrency baseCurrency) { Money zeroAmount = new Money(0m, baseCurrency); TotalAll = zeroAmount.DisplayString; TotalPositions = TotalAll; TotalCash = TotalAll; Status = AccountStati.Active; StatusIsOpen = true; }
/// <summary> /// Initializes a new instance of the <see cref="BasketLineItemFactory"/> class. /// </summary> /// <param name="umbraco"> /// The umbraco. /// </param> /// <param name="currentCustomer"> /// The current Customer. /// </param> /// <param name="currency"> /// The currency. /// </param> public BasketLineItemFactory(UmbracoHelper umbraco, ICustomerBase currentCustomer, ICurrency currency) { Mandate.ParameterNotNull(umbraco, "umbraco"); Mandate.ParameterNotNull(currency, "currency"); Mandate.ParameterNotNull(currentCustomer, "currentCustomer"); this._umbraco = umbraco; this._currency = currency; this._currentCustomer = currentCustomer; }
public CommCalc(string name, ICurrency commCurrency, Money minValue, Money maxValue, Money fixedSetup) { Name = name; CommCurrency = commCurrency; MinValue = minValue; MaxValue = maxValue; FixedSetup = fixedSetup; checkCurrencies(); }
private bool isCurrencyLoaded(string Symbol, ref ICurrency LoadedCurrency) { foreach (ICurrency c in theCurrencies) { if (c.Symbol == Symbol) { LoadedCurrency = c; return true; } } return false; }
/// <summary> /// Builds a <see cref="AddItemModel"/> from <see cref="IProductContent"/>. /// </summary> /// <param name="product"> /// The product. /// </param> /// <param name="currency"> /// The currency. /// </param> /// <param name="showWishList"> /// The show wish list. /// </param> /// <returns> /// The <see cref="AddItemModel"/>. /// </returns> public static AddItemModel BuildAddItemModel(this IProductContent product, ICurrency currency, bool showWishList) { return new AddItemModel() { Product = product.AsProductDisplay(), ContentId = 0, BasketPageId = BazaarContentHelper.GetBasketContent().Id, ShowWishList = showWishList, WishListPageId = BazaarContentHelper.GetWishListContent().Id, Currency = currency }; }
public InstructionEngineParameters(PricingTypes pricingType, decimal minimumQty, ICurrency underlying) { this.pricingType = pricingType; switch (pricingType) { case PricingTypes.Direct: this.minimumRebalanceAmount = new Money(minimumQty, underlying); break; case PricingTypes.Percentage: this.minimumRebalancePercentage = minimumQty; break; } }
public FeeCalc(FeeType feeType, string name, ICurrency feeCurrency, IAssetManager assetManager) : this() { if ((feeType == null || feeType.Key == FeeTypes.None)|| string.IsNullOrEmpty(name) || feeCurrency == null || assetManager == null) throw new ApplicationException("Not all parameters are passed in to instantiate a new fee calculation"); FeeType = feeType; Name = name; FeeCurrency = feeCurrency; this.AssetManager = assetManager; checkData(); }
/// <summary> /// Constructor /// </summary> /// <param name="parent">Parent order</param> /// <param name="feeFactory">Fee factory to use for calculating transaction costs</param> internal MonetaryOrder(IOrderAmountBased parent, IFeeFactory feeFactory) : base(parent.Account, (parent.Amount - parent.Commission)) { if (parent.TradedInstrument != null && parent.TradedInstrument.IsTradeable) { ITradeableInstrument instrument = (ITradeableInstrument)parent.TradedInstrument; this.requestedCurrency = instrument.CurrencyNominal; checkInitialValues(); setCommission(feeFactory); this.moneyParent = parent; } else throw new ApplicationException("Can not insert a monetary order without a requested currency"); }
/// <summary> /// Gets historical exchange rate by currency and time /// </summary> /// <param name="session">Data access object</param> /// <param name="currency">Currency</param> /// <param name="date">Date</param> /// <returns>Historical exchange object</returns> public static IHistoricalExRate GetHistoricalExRate(IDalSession session, ICurrency currency, DateTime date) { IList list; IHistoricalExRate rate = null; List<ICriterion> expressions = new List<ICriterion>(); expressions.Add(Expression.Eq("Currency.Key", currency.Key)); expressions.Add(Expression.Eq("RateDate", date)); list = session.GetList(typeof(HistoricalExRate), expressions); if (list != null && list.Count > 0) { rate = (IHistoricalExRate)list[0]; } return rate; }
/// <summary> /// Constructor of CommValueDetails object /// </summary> /// <param name="detailsToCopy">The object we want to clone from</param> /// <param name="commCurrency">The new currency to convert to</param> /// <param name="detailsToCopy">The ex rate to use</param> internal CommValueDetails(ICommValueDetails detailsToCopy, ICurrency commCurrency, decimal exRate) { Money commission; if (detailsToCopy == null || detailsToCopy.CommLines.Count == 0) throw new ApplicationException("It is not possible to clone the commissiondetails when they are null"); foreach (ICommValueBreakupLine line in detailsToCopy.CommLines) { if (line.CommCurrency.Equals(commCurrency)) commission = line.CalcValue; else commission = line.CalcValue.Convert(exRate, commCurrency); AddLine(line.CalcType, commission, line.CalcInfo); } }
public static Currency FromICurrency(ICurrency icurrency) { Currency c = new Currency(); c.Guid = icurrency.Guid; c.Title = icurrency.Title; c.Code = icurrency.Code; c.SymbolLeft = icurrency.SymbolLeft; c.SymbolRight = icurrency.SymbolRight; c.DecimalPointChar = icurrency.DecimalPointChar; c.ThousandsPointChar = icurrency.ThousandsPointChar; c.DecimalPlaces = icurrency.DecimalPlaces; c.Value = icurrency.Value; return c; }
internal AggregatedCashValuation(ValuationCollection cashValuations, bool aggregateToBase) { bool hasInitialized = false; if (aggregateToBase) { foreach (IValuation valuation in cashValuations) { if (valuation.Instrument.IsCash) { if (this.account == null) { this.account = valuation.Account; this.date = valuation.Date; this.key = valuation.Key; this.marketRate = 1M; this.avgOpenExRate = 1M; baseCurrency = ((ICurrency)valuation.Instrument).BaseCurrency; price = new Price(1M, baseCurrency, baseCurrency); this.bookPrice = price; this.costPrice = price; this.marketPrice = price; this.displayInstrumentsCategory = valuation.DisplayInstrumentsCategory; this.AssetClass = valuation.ValuationMutation.AssetClass; this.ValuationMutation = valuation.ValuationMutation; } this.size += valuation.BaseMarketValue; this.bookValue += valuation.BookValue; this.bookChange += valuation.BookChange; this.deposit += valuation.Deposit; this.withDrawal += valuation.WithDrawal; if (!valuation.ValuationMutation.IsSecurityValuationMutation) { this.depositToDate += ((IMonetaryValuationMutation)valuation.ValuationMutation).DepositToDate; this.withDrawalToDate += ((IMonetaryValuationMutation)valuation.ValuationMutation).WithDrawalToDate; } hasInitialized = true; } } } if (!hasInitialized) throw new ApplicationException("Class AggregatedCashValuation could not be initialized"); }
public IGLLookupRecord GetGLLookupRecord( ICurrency currency, bool isExternalExecution, bool isInternalExecution, bool isUnsettled, BookingComponentTypes bookingComponentType) { var returnvalue = from c in Records where ((c.IsExternalExecution == isExternalExecution) && (c.IsInternalExecution == isInternalExecution) && (c.IsUnSettled == isUnsettled) && (c.BookingComponentType == bookingComponentType) && (c.Currency.Equals(currency))) select c; if (returnvalue.Count() == 0) throw new ApplicationException("No Lookup record is matched."); return returnvalue.ElementAt(0); }
protected static Tuple<double[,], double[]> computeCorrelationAndVol(DateTime priceDate, IAsset underlying, ICurrency cur, int date_nb) { List<DateTime> dates_correl = new List<DateTime>(); int total = 0, real = 0; // current number of date : total also have not taken dates cause week end while (real < date_nb) { DateTime curr_date = priceDate - TimeSpan.FromDays(total); if (!(curr_date.DayOfWeek == DayOfWeek.Saturday || curr_date.DayOfWeek == DayOfWeek.Sunday)) { dates_correl.Add(curr_date); real++; } total++; } // get the prices from database Dictionary<DateTime, double> hist_correl = AccessDB.Get_Asset_Price(underlying.getName(), dates_correl); // transform the Tuple format to double[,] format double[,] hist_correl_double = new double[2, date_nb]; int j = 0; foreach (DateTime d in dates_correl) { hist_correl_double[0, j] = hist_correl[d]; j++; } j = 0; foreach (DateTime d in dates_correl) { hist_correl_double[1, j] = 1 / cur.getChangeToEuro(d); j++; } // compute correl and vol using C++ functions Wrapping.Tools tools = new Wrapping.Tools(); double[,] correl = new double[2, 2]; double[] vol = new double[2]; tools.getCorrelAndVol(date_nb, 2, hist_correl_double, correl, vol); return new Tuple<double[,], double[]>(correl, vol); }
public static IGLAccount GetSettlementDifferenceGLAccount(IDalSession session, ICurrency currency, ITradeableInstrument instrument) { IGLAccount glAccount = null; if (instrument.SettlementDifferenceAccount != null) glAccount = instrument.SettlementDifferenceAccount; else { List<ICriterion> expressions = new List<ICriterion>(); expressions.Add(Expression.Eq("IsSettlementDifference", true)); IList<IGLAccount> list = session.GetTypedList<GLAccount, IGLAccount>(expressions); if (list != null) { if (list.Count == 1) glAccount = list[0]; else if (list.Count > 1) glAccount = list.Where(x => x.DefaultCurrency.Equals(currency)).FirstOrDefault(); } } if (glAccount == null) throw new ApplicationException("Lookup of Settlement Difference GL Account produced no account."); else return glAccount; }
private void LoadFromReader(DbDataReader reader, ICurrency currency) { currency.Guid = new Guid(reader["Guid"].ToString()); currency.Title = reader["Title"].ToString(); currency.Code = reader["Code"].ToString(); currency.SymbolLeft = reader["SymbolLeft"].ToString(); currency.SymbolRight = reader["SymbolRight"].ToString(); currency.DecimalPointChar = reader["DecimalPointChar"].ToString(); currency.ThousandsPointChar = reader["ThousandsPointChar"].ToString(); currency.DecimalPlaces = reader["DecimalPlaces"].ToString(); currency.Value = Convert.ToDecimal(reader["Value"]); currency.LastModified = Convert.ToDateTime(reader["LastModified"]); currency.Created = Convert.ToDateTime(reader["Created"]); }
public async Task<bool> Save(ICurrency currency) { if (currency == null) { return false; } bool result; if (currency.Guid == Guid.Empty) { currency.Guid = Guid.NewGuid(); result = await dbCurrency.Create( currency.Guid, currency.Title, currency.Code, currency.SymbolLeft, currency.SymbolRight, currency.DecimalPointChar, currency.ThousandsPointChar, currency.DecimalPlaces, currency.Value, currency.LastModified, currency.Created); } else { result = await dbCurrency.Update( currency.Guid, currency.Title, currency.Code, currency.SymbolLeft, currency.SymbolRight, currency.DecimalPointChar, currency.ThousandsPointChar, currency.DecimalPlaces, currency.Value, currency.LastModified); } return result; }
public Quarter() { volume = new FluidOunces(); volume.Unit = 270; currency = new USCurrency(); currency.UnitPrice = 25; }