Example #1
0
 public override bool Transform(DateTime changeDate, decimal oldChildRatio, byte newParentRatio, bool isSpinOff,
         string instrumentName, string isin, DateTime issueDate)
 {
     MutualFund newFund = new MutualFund();
     newFund.AdminFee = this.AdminFee;
     newFund.BuyCost = this.BuyCost;
     newFund.CapitalisationCost = this.CapitalisationCost;
     newFund.Dividend = this.Dividend;
     newFund.RatingMS = this.RatingMS;
     newFund.SellCost = this.SellCost;
     return transform(newFund, changeDate, oldChildRatio, newParentRatio, isSpinOff, instrumentName, isin, issueDate);
 }
Example #2
0
        public static void SaveSecurity(ref int instrumentID, ref bool blnSaveSuccess, SecurityDetails secDetails)
        {
            if (!SecurityManager.IsCurrentUserInRole("Data Mtce: Instrument Edit"))
                throw new System.Security.SecurityException("You are not authorized to update instrument details.");

            IDalSession session = NHSessionFactory.CreateSession();

            try
            {
                SecurityInstrument sec = null;
                if (instrumentID != 0)
                    sec = (SecurityInstrument)InstrumentMapper.GetTradeableInstrument(session, instrumentID);
                else
                {
                    switch (secDetails.SecCategory)
                    {
                        case SecCategories.Stock:
                            sec = new Stock();
                            break;
                        case SecCategories.Bond:
                            sec = new Bond();
                            break;
                        case SecCategories.MutualFund:
                            sec = new MutualFund();
                            break;
                        case SecCategories.VirtualFund:
                            IVirtualFundTradingAccount tradingAcc = new VirtualFundTradingAccount();
                            tradingAcc.ShortName = secDetails.InstrumentName + " Trading Account";
                            if (string.IsNullOrEmpty(secDetails.TradingAccountNumber))
                                tradingAcc.Number = secDetails.InstrumentName + " TA";
                            else
                                tradingAcc.Number = secDetails.TradingAccountNumber;

                            IVirtualFundHoldingsAccount holdingAcc = new VirtualFundHoldingsAccount();
                            holdingAcc.ShortName = secDetails.InstrumentName + " Holding Account";
                            if (string.IsNullOrEmpty(secDetails.HoldingAccountNumber))
                                holdingAcc.Number = secDetails.InstrumentName + " HA";
                            else
                                holdingAcc.Number = secDetails.HoldingAccountNumber;

                            IJournal journal = new Journal(JournalTypes.Memorial,
                                secDetails.JournalNumber,
                                LoginMapper.GetCurrentManagmentCompany(session),
                                InstrumentMapper.GetCurrency(session, secDetails.NominalCurrencyID));
                            sec = new VirtualFund(holdingAcc, tradingAcc, journal);
                            break;
                        case SecCategories.CashManagementFund:
                            sec = new CashManagementFund();
                            break;
                        default:
                            throw new ApplicationException("This seccategory is not supported.");
                    }
                }
                if (sec == null)
                    throw new ApplicationException("The instrument could not be found.");

                if (secDetails.DefaultExchangeID != int.MinValue)
                    sec.DefaultExchange = ExchangeMapper.GetExchange(session, secDetails.DefaultExchangeID);
                else
                    throw new ApplicationException("The default exchange is mandatory.");

                sec.Name = secDetails.InstrumentName;
                sec.Isin = secDetails.ISIN;
                sec.CompanyName = secDetails.CompanyName;
                sec.IssueDate = secDetails.IssueDate;
                sec.PriceType = secDetails.PriceType;
                sec.IsGreenFund = secDetails.IsGreenFund;
                sec.IsCultureFund = secDetails.IsCultureFund;
                sec.AllowNetting = secDetails.AllowNetting;
                sec.DecimalPlaces = secDetails.DecimalPlaces;

                if (secDetails.HomeExchangeID != int.MinValue)
                    sec.HomeExchange = ExchangeMapper.GetExchange(session, secDetails.HomeExchangeID);
                else
                    sec.HomeExchange = null;
                if (secDetails.RouteID != int.MinValue)
                    sec.DefaultRoute = RouteMapper.GetRoute(session, secDetails.RouteID);
                else
                    sec.DefaultRoute = null;
                if (secDetails.CountryID != int.MinValue)
                    sec.Country = CountryMapper.GetCountry(session, secDetails.CountryID);
                else
                    sec.Country = null;
                if (secDetails.NominalCurrencyID != int.MinValue)
                    sec.CurrencyNominal = InstrumentMapper.GetCurrency(session, secDetails.NominalCurrencyID);
                else
                    sec.CurrencyNominal = null;

                // sec category specific stuff
                switch (secDetails.SecCategory)
                {
                    case SecCategories.Bond:
                        IBond bond = (IBond)sec;
                        bond.AccruedInterestCalcType = secDetails.AccruedInterestCalcType;
                        bond.NominalValue = new Money(secDetails.NominalValue, bond.CurrencyNominal);
                        bond.CouponRate = secDetails.CouponRate;
                        if ((int)secDetails.CouponFreq >= (int)Regularities.Annual)
                            bond.CouponFreq = secDetails.CouponFreq;
                        else
                            bond.CouponFreq = 0;
                        bond.MaturityDate = secDetails.MaturityDate;
                        bond.UltimoDating = secDetails.UltimoDating;
                        bond.FirstCouponPaymntDate = secDetails.FirstCouponPaymntDate;

                        if (secDetails.RedemptionAmount != 0)
                            bond.RedemptionAmount = new Money(secDetails.RedemptionAmount, bond.CurrencyNominal);
                        else
                            bond.RedemptionAmount = null;
                        bond.IsPerpetual = secDetails.IsPerpetual;
                        bond.IsFixedCouponRate = secDetails.IsFixedCouponRate;
                        break;
                    case SecCategories.VirtualFund:
                        IVirtualFundTradingAccount tradingAcc = ((IVirtualFund)sec).TradingAccount;
                        if (tradingAcc != null)
                        {
                            if (!string.IsNullOrEmpty(secDetails.TradingAccountNumber))
                                tradingAcc.Number = secDetails.TradingAccountNumber;
                        }
                        IVirtualFundHoldingsAccount holdingAcc = ((IVirtualFund)sec).HoldingsAccount;
                        if (holdingAcc != null)
                        {
                            if (!string.IsNullOrEmpty(secDetails.HoldingAccountNumber))
                                holdingAcc.Number = secDetails.HoldingAccountNumber;
                        }
                        IJournal journal = ((IVirtualFund)sec).JournalForFund;
                        if (journal != null)
                        {
                            journal.BankAccountDescription = secDetails.JournalDescription;
                            //journal.ExactJournal = secDetails.ExactJournalNumber;
                        }
                        ((IVirtualFund)sec).InitialNavPerUnit = new Money(secDetails.InitialNavPerUnit, sec.CurrencyNominal);
                        break;
                }

                // instrument exchange
                IInstrumentExchange ie = sec.InstrumentExchanges.GetDefault() ?? sec.InstrumentExchanges.FirstOrDefault();
                if (ie == null)
                {
                    ie = new InstrumentExchange(sec, sec.DefaultExchange, secDetails.NumberOfDecimals);
                    sec.InstrumentExchanges.Add(ie);
                }
                else
                {
                    ie.Exchange = sec.DefaultExchange;
                    ie.NumberOfDecimals = secDetails.NumberOfDecimals;
                }

                if (secDetails.DefaultCounterpartyID != int.MinValue)
                    ie.DefaultCounterParty = (ICounterPartyAccount)AccountMapper.GetAccount(session, secDetails.DefaultCounterpartyID);
                else
                    ie.DefaultCounterParty = null;
                ie.DefaultSettlementPeriod = secDetails.DefaultSettlementPeriod;
                ie.TickSize = secDetails.TickSize;
                ie.DoesSupportAmountBasedBuy = secDetails.DoesSupportAmountBasedBuy;
                ie.DoesSupportAmountBasedSell = secDetails.DoesSupportAmountBasedSell;
                ie.DoesSupportServiceCharge = secDetails.DoesSupportServiceCharge;
                ie.ServiceChargePercentageBuy = secDetails.ServiceChargePercentageBuy;
                ie.ServiceChargePercentageSell = secDetails.ServiceChargePercentageSell;
                ie.RegisteredInNameOf = secDetails.RegisteredInNameof;
                ie.DividendPolicy = secDetails.DividendPolicy;
                ie.CommissionRecipientName = secDetails.CommissionRecipientName;
                ie.CertificationRequired = secDetails.CertificationRequired;

                // set Activity
                if (sec.Key != 0)
                {
                    if ((sec.IsActive && !secDetails.IsActive) || (Util.IsNullDate(sec.InActiveDate) && Util.IsNotNullDate(secDetails.InActiveDate)))
                    {
                        int activePositions = GetNumberActivePositionsForInstrument(session, sec.Key);
                        if (activePositions > 0)
                            throw new ApplicationException(string.Format("There are still {0} open positions in {1}, close these positions before the instrument can be inactivated.", activePositions, sec.DisplayNameWithIsin));
                    }

                    sec.IsActive = secDetails.IsActive;
                    sec.InActiveDate = secDetails.InActiveDate;
                }

                if (sec.Validate())
                {
                    blnSaveSuccess = InstrumentMapper.Update(session, sec);
                    instrumentID = sec.Key;
                }
            }
            finally
            {
                session.Close();
            }
        }