public Journal(JournalTypes journalType, string journalNumber, IManagementCompany managementCompany, ICurrency currency)
 {
     this.JournalType = journalType;
     this.JournalNumber = journalNumber;
     this.ManagementCompany = managementCompany;
     this.currency = Currency;
 }

 public CurrencyExchangeResult(ICurrency exchangedCurrency, double exchangedAmount, DateTime timestamp, object state)
 {
     ExchangedCurrency = exchangedCurrency;
     ExchangedAmount = exchangedAmount;
     Timestamp = timestamp;
     State = state;
 }

        public Change Add(ICurrency currencyType, int count = 1)
        {
            if (_currency.ContainsKey(currencyType)) count += _currency[currencyType];
            _currency[currencyType] = count;

            return this;
        }

 /// <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;
 }

        /// <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;
        }

 /// <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
 /// </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);
 }

        /// <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;
        }

 /// <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>
        /// 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>
        /// 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 AccountDetailsView(ICurrency baseCurrency)
        {
            Money zeroAmount = new Money(0m, baseCurrency);
            TotalAll = zeroAmount.DisplayString;
            TotalPositions = TotalAll;
            TotalCash = TotalAll;

            Status = AccountStati.Active;
            StatusIsOpen = true;
        }

        public CommCalc(string name, ICurrency commCurrency, Money minValue, Money maxValue,
			Money fixedSetup)
        {
            Name = name;
            CommCurrency = commCurrency;
            MinValue = minValue;
            MaxValue = maxValue;
            FixedSetup = fixedSetup;

            checkCurrencies();
        }

 /// <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
         };
 }

 private bool isCurrencyLoaded(string Symbol, ref ICurrency LoadedCurrency)
 {
     foreach (ICurrency c in theCurrencies)
     {
         if (c.Symbol == Symbol)
         {
             LoadedCurrency = c;
             return true;
         }
     }
     return false;
 }

 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>
        /// 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;
        }