Ejemplo n.º 1
0
        public static object CreateMemorialBooking(int journalId)
        {
            IDalSession session = NHSessionFactory.CreateSession();

            try
            {
                IJournal journal = JournalMapper.GetJournal(session, journalId);

                string nextJournalEntryNumber = JournalEntryMapper.GetNextJournalEntryNumber(session, journal);

                IMemorialBooking newMemorialBooking = new MemorialBooking(journal, nextJournalEntryNumber);

                JournalEntryMapper.Insert(session, newMemorialBooking);

                return newMemorialBooking.Key;
            }
            finally
            {
                session.Close();
            }
            throw new Exception("The method or operation is not implemented.");
        }
Ejemplo n.º 2
0
        private static void createJournalEntryForNav(IDalSession session, INavCalculation calc, DateTime bookingDate)
        {
            IVirtualFund fund = calc.Fund;
            string nextJournalNumber = JournalEntryMapper.GetNextJournalEntryNumber(session, fund.JournalForFund);

            IMemorialBooking newEntry = new MemorialBooking(fund.JournalForFund, nextJournalNumber);
            newEntry.TransactionDate = calc.ValuationDate;
            calc.Bookings = newEntry;
        }
Ejemplo n.º 3
0
        public bool Settle(IJournal journal, string nextJournalEntryNumber, IGLAccount settleDiffGLAccount)
        {
            bool success = false;
            if ((TradeStatements != null && TradeStatements.Count > 0) && (BankSettlements != null && BankSettlements.Count > 0))
            {
                // TODO -> What if not in base currency????
                Money diff = SettleDifference;
                foreach (ITradingJournalEntry journalEntry in TradeStatements)
                {
                    ((IOrderExecution)journalEntry.Trade).SettleExternal(SettlementDate);
                }

                if (diff != null && diff.IsNotZero)
                {
                    MemorialBooking = new MemorialBooking(journal, nextJournalEntryNumber);
                    MemorialBooking.TransactionDate = SettlementDate;
                    MemorialBooking.Description = "Settlement Difference";

                    IGLAccount glAcctA = BankSettlements[0].GLAccount;
                    IGLAccount glAcctB = settleDiffGLAccount;

                    IJournalEntryLine sideA = new JournalEntryLine();
                    sideA.GLAccount = glAcctA;
                    sideA.Balance = diff.Negate();
                    sideA.Description = MemorialBooking.Description;
                    sideA.IsSettledStatus = true;
                    sideA.ValueDate = SettlementDate;
                    MemorialBooking.Lines.AddJournalEntryLine(sideA);

                    IJournalEntryLine sideB = new JournalEntryLine();
                    sideB.GLAccount = glAcctB;
                    sideB.Balance = diff;
                    sideB.Description = MemorialBooking.Description;
                    sideB.IsSettledStatus = true;
                    sideB.ValueDate = SettlementDate;
                    MemorialBooking.Lines.AddJournalEntryLine(sideB);

                    MemorialBooking.BookLines();
                }
                success = true;
            }
            return success;
        }
Ejemplo n.º 4
0
        private static bool createMgtFeeTransactionForMP(IJournal journalMgmtFee, IGLLookupRecords lookups, int mgtPeriodId, int year, int quarter, ManagementTypes managementType, FeeFactory feeFactory, DateTime minDate, DateTime maxDate, decimal taxPercentage, bool createCashInitiatedOrders)
        {
            bool retVal = false;
            IDalSession session = NHSessionFactory.CreateSession();
            Hashtable parameterLists = new Hashtable(1);
            Hashtable parameters = new Hashtable(2);

            Util.GetDatesFromQuarter(year, quarter, out minDate, out maxDate);

            parameterLists.Add("periods", Util.GetPeriodsFromQuarter(year, quarter));
            parameters.Add("mgtPeriodId", mgtPeriodId);
            parameters.Add("managementType", managementType);
            IList<IManagementPeriodUnit> unitsUnsorted = session.GetTypedListByNamedQuery<IManagementPeriodUnit>(
                "B4F.TotalGiro.ApplicationLayer.Fee.ManagementPeriodUnitsForMgtFeeTransactionCreation",
                parameters,
                parameterLists);

            if (unitsUnsorted != null && unitsUnsorted.Count > 0)
            {
                var unitsByMP = from a in unitsUnsorted
                          group a by a.ManagementPeriod into g
                          select new { ManagementPeriod = g.Key, Units = g.ToList() };

                if (unitsByMP.Count() != 1)
                    throw new ApplicationException("The number of management periods is not what is expected.");

                IManagementPeriod managementPeriod = unitsByMP.First().ManagementPeriod;
                IList<IManagementPeriodUnit> units = unitsByMP.First().Units;

                DateTime feeStartDate = minDate;
                DateTime feeEndDate = maxDate;

                if (managementPeriod.StartDate > minDate)
                    feeStartDate = managementPeriod.StartDate;
                if (Util.IsNotNullDate(managementPeriod.EndDate) && managementPeriod.EndDate < maxDate)
                    feeEndDate = managementPeriod.EndDate.Value;

                if (feeStartDate.Year != feeEndDate.Year)
                    throw new ApplicationException("The year of the start date and end date for the management fee should equal");

                string mgtFeeDescription;
                decimal mgtFeeThreshold;
                getMgtFeeInfo(managementPeriod, feeEndDate, year, quarter, out mgtFeeDescription, out mgtFeeThreshold);

                if (units != null && units.Count > 0)
                {
                    // check the number of units
                    int expectedUnitCount = Util.DateDiff(DateInterval.Month, feeStartDate, feeEndDate) + 1;
                    if (expectedUnitCount != units.Count)
                        throw new ApplicationException(string.Format("The number of units {0} does not equal the number of expected units {1}.", units.Count, expectedUnitCount));

                    // check if all have the same management period
                    var mps = from a in units
                              group a by a.ManagementPeriod into g
                              select g.Key;
                    if (mps.Count() != 1)
                        throw new ApplicationException("Not all units belong to the same management period.");

                    if (mps.First().Key != managementPeriod.Key)
                        throw new ApplicationException("The management period is not ok.");

                    if (Util.GetPeriodFromDate(managementPeriod.StartDate) == Util.GetPeriodFromDate(feeStartDate) && managementPeriod.StartDate.Day != feeStartDate.Day)
                        throw new ApplicationException(string.Format("The start date of the management period ({0}) does not equal the presented start date ({1}).", managementPeriod.StartDate.ToString("yyyy-MM-dd"), feeStartDate.ToString("yyyy-MM-dd")));

                    if (managementPeriod.EndDate.HasValue)
                    {
                        if (feeEndDate > managementPeriod.EndDate)
                            throw new ApplicationException(string.Format("The end date of the management period ({0}) does not equal the presented end date ({1}).", managementPeriod.EndDate.Value.ToString("yyyy-MM-dd"), feeEndDate.ToString("yyyy-MM-dd")));
                        else if (Util.GetPeriodFromDate(managementPeriod.EndDate.Value) == Util.GetPeriodFromDate(feeEndDate) && managementPeriod.EndDate.Value.Day != feeEndDate.Day)
                            throw new ApplicationException(string.Format("The end date of the management period ({0}) does not equal the presented end date ({1}).", managementPeriod.EndDate.Value.ToString("yyyy-MM-dd"), feeEndDate.ToString("yyyy-MM-dd")));
                    }

                    IAccountTypeCustomer account = (IAccountTypeCustomer)managementPeriod.Account;
                    if (!account.ExitFeePayingAccount.Equals(account))
                        mgtFeeDescription += string.Format(" voor {0}", account.Number);

                    string nextJournalEntryNumber = JournalEntryMapper.GetNextJournalEntryNumber(session, journalMgmtFee);
                    IMemorialBooking memorialBooking = new MemorialBooking(journalMgmtFee, nextJournalEntryNumber);
                    memorialBooking.TransactionDate = feeEndDate.AddDays(1);
                    memorialBooking.Description = mgtFeeDescription;

                    IManagementFee mgtFee = new ManagementFee(account, feeStartDate, feeEndDate, units, memorialBooking, taxPercentage, lookups);
                    if (mgtFee != null && mgtFee.NettAmount != null && mgtFee.NettAmount.IsNotZero)
                    {
                        if (mgtFee.NettAmount.Quantity < mgtFeeThreshold)
                        {
                            ITradeableInstrument instrument;
                            account = account.ExitFeePayingAccount;
                            if (createCashInitiatedOrders && mgtFee.NeedToCreateCashInitiatedOrder(out instrument))
                            {
                                if (instrument != null)
                                {
                                    OrderAmountBased order = new OrderAmountBased(account, mgtFee.Components.TotalAmount, instrument, true, feeFactory, true);
                                    order.OrderInfo = mgtFeeDescription;
                                    mgtFee.CashInitiatedOrder = order;
                                }
                                else
                                {
                                    // Sell from the biggest position
                                    IFundPosition pos = account.Portfolio.PortfolioInstrument.Where(x => x.Size.IsGreaterThanZero).OrderByDescending(x => x.CurrentValue).FirstOrDefault();
                                    if (pos != null && (pos.CurrentBaseValue + mgtFee.NettAmount).IsGreaterThanOrEqualToZero)
                                    {
                                        OrderAmountBased order = new OrderAmountBased(account, mgtFee.Components.TotalAmount, pos.Instrument, true, feeFactory, true);
                                        order.OrderInfo = mgtFeeDescription;
                                        mgtFee.CashInitiatedOrder = order;
                                    }
                                }
                            }

                            if (mgtFee.CashInitiatedOrder == null && (account.Portfolio.TotalValue() + mgtFee.TotalAmount).IsLessThanZero)
                                throw new ApplicationException(string.Format("Could not create a management fee booking for account {0} since the total portfolio value ({1}) is insufficient.", account.DisplayNumberWithName, account.Portfolio.TotalValue().DisplayString));

                            mgtFee.BookLines();
                            GeneralOperationsBookingMapper.Update(session, mgtFee);
                            retVal = true;
                        }
                    }
                }
            }
            session.Close();
            return retVal;
        }
Ejemplo n.º 5
0
 private static IMemorialBooking getNewCashDividendBooking(IDalSession session, IJournal journal, DateTime transactionDate)
 {
     string nextJournalEntryNumber = JournalEntryMapper.GetNextJournalEntryNumber(session, journal);
     IMemorialBooking newMemorialBooking = new MemorialBooking(journal, nextJournalEntryNumber);
     newMemorialBooking.TransactionDate = transactionDate;
     JournalEntryMapper.Insert(session, newMemorialBooking);
     return newMemorialBooking;
 }
Ejemplo n.º 6
0
        private static bool processBondPosition(
            IFundPosition pos, IExchange exchange, DateTime upToDate,
            IList<IBondCouponPaymentDailyCalculation> oldCalculations, IGLLookupRecords lookups, 
            IDalSession session)
        {
            bool success = false;
            IBond bond = pos.Instrument as IBond;
            if (bond == null || bond.SecCategory.Key != SecCategories.Bond)
                throw new ApplicationException(string.Format("The instrument {0} is not a bond.", pos.Instrument.DisplayIsinWithName));

            if (bond.DoesPayInterest)
            {
                DateTime calcDate;
                if (Util.IsNotNullDate(pos.LastBondCouponCalcDate))
                    calcDate = pos.LastBondCouponCalcDate.AddDays(1);
                else
                    calcDate = pos.OpenDate;

                while (calcDate <= upToDate)
                {
                    if (exchange == null)
                        exchange = bond.DefaultExchange ?? bond.HomeExchange;

                    InstrumentSize size = pos.PositionTransactions.Where(x => x.TransactionDate <= calcDate).Select(x => x.Size).Sum();
                    if (size != null && size.IsNotZero)
                    {
                        if (!Util.IsWeekendOrHoliday(calcDate, exchange.ExchangeHolidays))
                        {
                            DateTime settlementDate = bond.GetSettlementDate(calcDate, exchange);

                            IBondCouponPayment bip = null;
                            DateTime lastCouponDate = bond.LastCouponDate(settlementDate);
                            if (Util.IsNullDate(lastCouponDate))
                                lastCouponDate = bond.IssueDate;
                            DateTime nextCouponDate = bond.NextCouponDate(settlementDate);
                            if ((bond.IsPerpetual || bond.MaturityDate >= settlementDate) &&
                                Util.IsNotNullDate(lastCouponDate) && lastCouponDate <= settlementDate &&
                                Util.IsNotNullDate(nextCouponDate) && nextCouponDate >= settlementDate)
                            {
                                // Per position -> Does have an Active BondCouponPayment
                                bip = pos.BondCouponPayments.GetBondCouponPaymentByDate(settlementDate);
                                if (bip == null)
                                {
                                    ICouponHistory couponHistory = bond.Coupons.GetCouponByDate(settlementDate);
                                    if (couponHistory == null)
                                    {
                                        couponHistory = new CouponHistory(bond, lastCouponDate, nextCouponDate);
                                        bond.Coupons.AddCoupon(couponHistory);
                                    }
                                    int journalID = int.Parse((string)(System.Configuration.ConfigurationManager.AppSettings.Get("DefaultAccruedInterestJournal")));
                                    IJournal journal = JournalMapper.GetJournal(session, journalID);
                                    string nextJournalEntryNumber = JournalEntryMapper.GetNextJournalEntryNumber(session, journal);
                                    IMemorialBooking memorialBooking = new MemorialBooking(journal, nextJournalEntryNumber);
                                    memorialBooking.TransactionDate = couponHistory.EndAccrualDate;
                                    bip = new BondCouponPayment(pos, couponHistory, memorialBooking);
                                    pos.BondCouponPayments.AddPayment(bip);
                                }
                                if (bip != null)
                                {
                                    // Add interest accrual
                                    bip.CalculateDailyInterest(size, calcDate, settlementDate,
                                        oldCalculations != null && oldCalculations.Count > 0 ? oldCalculations.Where(x => x.CalcDate == calcDate).ToList() : null,
                                        lookups);
                                }
                            }

                            // If coupon payment date equals settlementDate -> set to status -> to-be-settled
                            if (bip != null && nextCouponDate <= settlementDate)
                                bip.SetToBeSettled(calcDate, settlementDate);

                            // If coupon payment date -> pay (unsettled to settled)
                            // Settle the interest
                            List<IBondCouponPayment> bipsToBeSettled  = pos.BondCouponPayments.ToBeSettledPayments(calcDate);
                            if (bipsToBeSettled != null && bipsToBeSettled.Count > 0)
                            {
                                foreach (IBondCouponPayment bipToBeSettled in bipsToBeSettled)
                                    bipToBeSettled.SettleInterest(calcDate);
                            }
                            success = true;
                        }
                        pos.LastBondCouponCalcDate = calcDate;
                    }
                    calcDate = calcDate.AddDays(1);
                }
            }
            return success;
        }
Ejemplo n.º 7
0
 public static bool StornoBondTransaction(IDalSession session, ITransaction storno, IInternalEmployeeLogin employee)
 {
     bool success = false;
     if (storno.Approved)
     {
         IList<IBondCouponPayment> bondPaymentsToStorno = storno.GetBondPaymentsToStorno();
         if (bondPaymentsToStorno != null && bondPaymentsToStorno.Count > 0)
         {
             IGLLookupRecords lookups = null;
             int journalID = int.Parse((string)(System.Configuration.ConfigurationManager.AppSettings.Get("DefaultAccruedInterestJournal")));
             IJournal journal = JournalMapper.GetJournal(session, journalID);
             foreach (IBondCouponPayment payment in bondPaymentsToStorno.OrderByDescending(x => x.CouponHistory.StartAccrualDate))
             {
                 if (payment.Status == BondCouponPaymentStati.Active || payment.Status == BondCouponPaymentStati.ToBeSettled)
                 {
                     if (lookups == null)
                         lookups = GlLookupRecordMapper.GetGLLookupRecords(session, BookingComponentParentTypes.AccruedInterest);
                     payment.Cancel();
                     success = true;
                 }
                 else if (payment.Status == BondCouponPaymentStati.Settled)
                 {
                     string nextJournalEntryNumber = JournalEntryMapper.GetNextJournalEntryNumber(session, journal);
                     IMemorialBooking memorialBooking = new MemorialBooking(journal, nextJournalEntryNumber);
                     memorialBooking.TransactionDate = payment.CouponHistory.EndAccrualDate;
                     payment.Storno(employee, storno.StornoReason, memorialBooking);
                     success = true;
                 }
             }
         }
     }
     return success;
 }