using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Ease.CoreV35;
using Ease.CoreV35.Model;
using Ease.CoreV35.Caching;
using System.Data.Linq.Mapping;
using Microsoft.VisualBasic;
using System.Data;

namespace Payroll.BO
{
    #region LoanIssue

    [Serializable]
    public class LoanIssue : AuditTrailBase, IworkflowInterface
    {
        #region Cache Store

        private static Cache _cache = new Cache(typeof(LoanIssue));

        #endregion

        #region Constructor

        private ObjectsTemplate<LoanSchedule> _MonthlySchedules = null;

        public LoanIssue()
        {
            _MonthlySchedules = null;
            _loanID = null;
            _loanNo = string.Empty;
            _employeeID = null;
            _loanAmount = 0;
            _issueDate = DateTime.MinValue;
            _noOfInstallments = 0;
            _installmentPrincipal = 0;
            _interestRate = 0;
            _startPaybackMonthDate = DateTime.MinValue;
            _remainInstallment = 0;
            _remainInterest = 0;
            _remNoInstallment = 0;
            _employee = null;
            _loan = null;
            _wfStatus = enumwfStatus.Not_yet_Submitted;
            _AverageInterestRate = false;
        }

        #endregion

        #region Properties

        #region LoanID : ID

        private ID _loanID;
        public ID LoanID
        {
            get { return _loanID; }
            set
            {
                base.OnPropertyChange<ID>("LoanID", _loanID, value);
                _loanID = value;
            }
        }

        #endregion

        #region loanNo : string

        private string _loanNo;
        public string LoanNo
        {
            get { return _loanNo; }
            set
            {
                base.OnPropertyChange<string>("loanNo", _loanNo, value);
                _loanNo = value;
            }
        }

        #endregion

        #region EmployeeID : ID

        private ID _employeeID;
        public ID EmployeeID
        {
            get { return _employeeID; }
            set
            {
                base.OnPropertyChange<ID>("EmployeeID", _employeeID, value);
                _employeeID = value;
            }
        }

        #endregion

        #region loanAmount : double

        private double _loanAmount;
        public double LoanAmount
        {
            get { return _loanAmount; }
            set
            {
                base.OnPropertyChange<double>("loanAmount", _loanAmount, value);
                _loanAmount = value;
            }
        }

        #endregion

        #region issueDate : DateTime

        private DateTime _issueDate;
        public DateTime IssueDate
        {
            get { return _issueDate; }
            set
            {
                base.OnPropertyChange<DateTime>("issueDate", _issueDate, value);
                _issueDate = value;
            }
        }

        #endregion

        #region noOfInstallments : int

        private int _noOfInstallments;
        public int NoOfInstallments
        {
            get { return _noOfInstallments; }
            set
            {
                base.OnPropertyChange<int>("noOfInstallments", _noOfInstallments, value);
                _noOfInstallments = value;
            }
        }

        #endregion

        #region installmentPrincipal : double

        private double _installmentPrincipal;
        public double InstallmentPrincipal
        {
            get { return _installmentPrincipal; }
            set
            {
                base.OnPropertyChange<double>("installmentPrincipal", _installmentPrincipal, value);
                _installmentPrincipal = value;
            }
        }

        #endregion

        #region interestRate : double

        private double _interestRate;
        public double InterestRate
        {
            get { return _interestRate; }
            set
            {
                base.OnPropertyChange<double>("interestRate", _interestRate, value);
                _interestRate = value;
            }
        }

        #endregion

        #region startPaybackMonthDate : DateTime

        private DateTime _startPaybackMonthDate;
        public DateTime StartPaybackMonthDate
        {
            get { return _startPaybackMonthDate; }
            set
            {
                base.OnPropertyChange<DateTime>("startPaybackMonthDate", _startPaybackMonthDate, value);
                _startPaybackMonthDate = value;
            }
        }

        #endregion

        #region remainInstallment : double

        private double _remainInstallment;
        public double RemainInstallment
        {
            get { return _remainInstallment; }
            set
            {
                base.OnPropertyChange<double>("remainInstallment", _remainInstallment, value);
                _remainInstallment = value;
            }
        }

        #endregion

        #region remainInterest : double

        private double _remainInterest;
        public double RemainInterest
        {
            get { return _remainInterest; }
            set
            {
                base.OnPropertyChange<double>("remainInterest", _remainInterest, value);
                _remainInterest = value;
            }
        }

        #endregion

        #region remNoInstallment : double

        private double _remNoInstallment;
        public double RemNoInstallment
        {
            get { return _remNoInstallment; }
            set
            {
                base.OnPropertyChange<double>("remNoInstallment", _remNoInstallment, value);
                _remNoInstallment = value;
            }
        }

        #endregion

        #region employee : Employee

        private Employee _employee;
        public Employee Employee
        {
            get
            {
                if (_employeeID.Integer > 0 && _employee == null)
                {
                    _employee = new Employee();
                    _employee = Employee.Get(_employeeID);
                }
                return this._employee;
            }
            set
            {
                _employee = value;
            }
        }
        #endregion

        #region loan : Loan

        private Loan _loan;
        public Loan LoanObj
        {
            get
            {
                if (_loanID.Integer > 0 && _loan == null)
                {
                    _loan = Loan.Get(_loanID);
                }
                return this._loan;
            }
            set
            {
                _loan = value;
            }
        }
        #endregion

        #region Schedule : Schedule

        private ObjectsTemplate<LoanSchedule> _Schedules;
        public ObjectsTemplate<LoanSchedule> Schedules
        {
            get
            {
                if (_Schedules == null && !ID.IsUnassigned && ID.Integer > 0)
                {
                    _Schedules = LoanSchedule.GetByIssueID(this.ID);
                }
                if (_Schedules == null)
                {
                    _Schedules = new ObjectsTemplate<LoanSchedule>();
                }
                return _Schedules;
            }
        }
        #endregion

        #region AverageInterestRate : bool

        private bool _AverageInterestRate;
        public bool AverageInterestRate
        {
            get { return _AverageInterestRate; }
            set
            {
                base.OnPropertyChange<bool>("AverageInterestRate", _AverageInterestRate, value);
                _AverageInterestRate = value;
            }
        }

        #endregion
        private enumwfStatus _wfStatus;
        public enumwfStatus WFStatus
        {
            get
            {
                return _wfStatus;
            }
            set
            {
                _wfStatus = value;
            }
        }


        private ObjectsTemplate<LoanEmployeeDoc> _issueDocks;
        public ObjectsTemplate<LoanEmployeeDoc> IssueDocks
        {
            get
            {
                if (_issueDocks == null)
                    _issueDocks = LoanEmployeeDoc.GetbyIssueId(this.ID);
                return _issueDocks;
            }
            set
            {
                _issueDocks = value;
            }
        }

        #region Service Factory ILoanIssueService : ILoanIssueService

        internal static ILoanIssueService Service
        {
            get { return Services.Factory.CreateService<ILoanIssueService>(typeof(ILoanIssueService)); }
        }

        #endregion

        #endregion

        #region Functions

        public ObjectsTemplate<LoanSchedule> MonthlySchedules(DateTime dateTime)
        {
            if (_MonthlySchedules == null && !this.ID.IsUnassigned && this.ID.Integer > 0)
            {
                _MonthlySchedules = LoanSchedule.GetByIssueIDAndMonth(this.ID, dateTime);
            }
            return _MonthlySchedules;
        }

        public static LoanIssue Get(ID nID)
        {
            LoanIssue oLoanIssue = null;
            #region Cache Header
            oLoanIssue = (LoanIssue)_cache["Get", nID];
            if (oLoanIssue != null)
                return oLoanIssue;
            #endregion
            oLoanIssue = LoanIssue.Service.Get(nID);
            #region Cache Footer
            _cache.Add(oLoanIssue, "Get", nID);
            #endregion
            return oLoanIssue;
        }

        public static LoanIssue GetExistingLoan(ID nLoanID, ID nEmpID)
        {
            LoanIssue oLoanIssue = null;
            #region Cache Header
            oLoanIssue = (LoanIssue)_cache["GetExistingLoan", nLoanID, nEmpID];
            if (oLoanIssue != null)
                return oLoanIssue;
            #endregion
            oLoanIssue = LoanIssue.Service.GetExistingLoan(nLoanID, nEmpID);
            #region Cache Footer
            _cache.Add(oLoanIssue, "GetExistingLoan", nLoanID, nEmpID);
            #endregion
            return oLoanIssue;
        }
        public static ObjectsTemplate<LoanIssue> GetExistingLoan(ID nEmpID)
        {
            #region Cache Header

            ObjectsTemplate<LoanIssue> loanIssues = _cache["GetExistingLoan", nEmpID] as ObjectsTemplate<LoanIssue>;
            if (loanIssues != null)
                return loanIssues;

            #endregion
            try
            {
                loanIssues = Service.GetExistingLoan(nEmpID);
            }
            catch (ServiceException e)
            {
                throw new Exception(e.Message, e);
            }

            #region Cache Footer

            _cache.Add(loanIssues, "GetExistingLoan", nEmpID);

            #endregion

            return loanIssues;
        }

        public static ObjectsTemplate<LoanIssue> GetAllExistingLoan(string LoanIDs)
        {
            ObjectsTemplate<LoanIssue> loanIssues = null;
            try
            {
                loanIssues = Service.GetAllExistingLoan(LoanIDs);
            }
            catch (ServiceException e)
            {
                throw new Exception(e.Message, e);
            }


            return loanIssues;
        }
        public static ObjectsTemplate<LoanIssue> GetAllExistingLoan(int EmpID, string sLaonIDs)
        {
            ObjectsTemplate<LoanIssue> loanIssues = null;

            try
            {
                loanIssues = Service.GetAllExistingLoan(EmpID, sLaonIDs);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message, e);
            }


            return loanIssues;
        }

        public static ObjectsTemplate<LoanIssue> GetAllExistingLoan(string LoanIDs, DateTime month)
        {
            ObjectsTemplate<LoanIssue> loanIssues = null;
            try
            {
                loanIssues = Service.GetAllExistingLoan(LoanIDs, month);
            }
            catch (ServiceException e)
            {
                throw new Exception(e.Message, e);
            }


            return loanIssues;
        }

        public static ObjectsTemplate<LoanIssue> GetByDueInstallmentDate(DateTime dateTime, string empID)
        {
            #region Cache Header

            ObjectsTemplate<LoanIssue> loanIssues = _cache["Get", dateTime, empID] as ObjectsTemplate<LoanIssue>;
            if (loanIssues != null)
                return loanIssues;

            #endregion

            try
            {
                loanIssues = Service.GetByDueInstallmentDate(dateTime, empID);
            }
            catch (ServiceException e)
            {
                throw new Exception(e.Message, e);
            }

            #region Cache Footer

            _cache.Add(loanIssues, "Get", dateTime, empID);

            #endregion

            return loanIssues;
        }

        public static ObjectsTemplate<LoanIssue> GetByDueInstallmentDate(DateTime dateTime)
        {
            #region Cache Header

            ObjectsTemplate<LoanIssue> loanIssues = _cache["Get", dateTime] as ObjectsTemplate<LoanIssue>;
            if (loanIssues != null)
                return loanIssues;

            #endregion

            try
            {
                loanIssues = Service.GetByDueInstallmentDate(dateTime);
            }
            catch (ServiceException e)
            {
                throw new Exception(e.Message, e);
            }

            #region Cache Footer

            _cache.Add(loanIssues, "Get", dateTime);

            #endregion

            return loanIssues;
        }

        public static ObjectsTemplate<LoanIssue> Get(DateTime dateTime)
        {
            #region Cache Header

            ObjectsTemplate<LoanIssue> loanIssues = _cache["Get", dateTime] as ObjectsTemplate<LoanIssue>;
            if (loanIssues != null)
                return loanIssues;

            #endregion

            try
            {
                loanIssues = Service.Get(dateTime);
            }
            catch (ServiceException e)
            {
                throw new Exception(e.Message, e);
            }

            #region Cache Footer

            _cache.Add(loanIssues, "Get", dateTime);

            #endregion

            return loanIssues;
        }
        public static ObjectsTemplate<LoanIssue> Get(DateTime dateTime, DateTime dateTime2)
        {
            #region Cache Header

            ObjectsTemplate<LoanIssue> loanIssues = _cache["Get", dateTime, dateTime2] as ObjectsTemplate<LoanIssue>;
            if (loanIssues != null)
                return loanIssues;

            #endregion

            try
            {
                loanIssues = Service.Get(dateTime, dateTime2);
            }
            catch (ServiceException e)
            {
                throw new Exception(e.Message, e);
            }

            #region Cache Footer

            _cache.Add(loanIssues, "Get", dateTime, dateTime2);

            #endregion

            return loanIssues;
        }

        public static ObjectsTemplate<LoanIssue> Get(string employeeNo)
        {
            #region Cache Header

            ObjectsTemplate<LoanIssue> loanIssues = _cache["Get", employeeNo] as ObjectsTemplate<LoanIssue>;
            if (loanIssues != null)
                return loanIssues;

            #endregion

            try
            {
                loanIssues = Service.Get(employeeNo);
            }
            catch (ServiceException e)
            {
                throw new Exception(e.Message, e);
            }

            #region Cache Footer

            _cache.Add(loanIssues, "Get", employeeNo);

            #endregion

            return loanIssues;
        }

        public static ObjectsTemplate<LoanIssue> GetByLoanID(ID nLoanID)
        {
            #region Cache Header

            ObjectsTemplate<LoanIssue> loanIssues = _cache["Get", nLoanID] as ObjectsTemplate<LoanIssue>;
            if (loanIssues != null)
                return loanIssues;

            #endregion

            try
            {
                loanIssues = Service.GetByLoanID(nLoanID);
            }
            catch (ServiceException e)
            {
                throw new Exception(e.Message, e);
            }

            #region Cache Footer

            _cache.Add(loanIssues, "Get", nLoanID);

            #endregion

            return loanIssues;
        }

        public static ObjectsTemplate<LoanIssue> Get()
        {
            #region Cache Header

            ObjectsTemplate<LoanIssue> loanIssues = _cache["Get"] as ObjectsTemplate<LoanIssue>;
            if (loanIssues != null)
                return loanIssues;

            #endregion

            try
            {
                loanIssues = Service.Get();
            }
            catch (ServiceException e)
            {
                throw new Exception(e.Message, e);
            }

            #region Cache Footer

            _cache.Add(loanIssues, "Get");

            #endregion

            return loanIssues;
        }

        public static DataSet GetIssuedLoanIDs(int EmpID)
        {
            DataSet ds = null;

            try
            {
                ds = Service.GetIssuedLoanIDs(EmpID);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message, e);
            }


            return ds;
        }

        public static DataSet GetIssuedLoans(int EmpID)
        {
            DataSet ds = null;

            try
            {
                ds = Service.GetIssuedLoans(EmpID);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message, e);
            }


            return ds;
        }

        public bool IsPaymentStarted()
        {
            bool paymentStarted = false;

            foreach (LoanSchedule schedule in this.Schedules)
            {
                if (schedule.PaymentDate != null)
                {
                    paymentStarted = true;
                    break;
                }
            }

            return paymentStarted;
        }

        public ID Save()
        {
            base.SetAuditTrailProperties();
            if (!this.ID.IsUnassigned)
            {
                if (this.IssueDocks != null)
                {
                    foreach (LoanEmployeeDoc item in this.IssueDocks)
                    {
                        item.CreatedBy = this.CreatedBy;
                        item.CreatedDate = this.CreatedDate;
                    }
                }
            }
            return LoanIssue.Service.Save(this);
        }
        public ID Save2()
        {
            base.SetAuditTrailProperties();
            if (!this.ID.IsUnassigned)
            {
                if (this.IssueDocks != null)
                {
                    foreach (LoanEmployeeDoc item in this.IssueDocks)
                    {
                        item.CreatedBy = this.CreatedBy;
                        item.CreatedDate = this.CreatedDate;
                    }
                }
            }
            return LoanIssue.Service.Save2(this);
        }
        public void Delete()
        {
            LoanIssue.Service.Delete(ID);
        }
        public void UpdateAvgIntStatus(ObjectsTemplate<LoanIssue> lis)
        {
            LoanIssue.Service.UpdateAvgIntStatus(lis);
        }

        public void PrepareEMISchedule(DateTime dMonth, EnumLoanFraction fractionate)
        {
            LoanSchedule oSchedule = null;

            this.Schedules.Clear();

            double nInterest = 0.0;
            double nTotalInterest = 0.0;
            double nInsPrinciple = 0.0;
            double nBalance = 0.0;
            double nTotalInstPrinciple = 0.0;
            double nRate = this.InterestRate / 1200.0;
            double nEffectiveBalance = this.LoanAmount;
            double nInstAmount = Financial.Pmt(nRate, this.NoOfInstallments, -this.LoanAmount, 0, DueDate.EndOfPeriod);

            dMonth = Ease.CoreV35.Utility.Global.DateFunctions.LastDateOfMonth(dMonth);

            nTotalInterest = 0;
            for (int i = 0; i < this.NoOfInstallments; i++)
            {
                nInterest = nEffectiveBalance * nRate;
                nTotalInterest = nTotalInterest + nInterest;
                if (i == this.NoOfInstallments - 1)
                {
                    nInsPrinciple = this.LoanAmount - nTotalInstPrinciple;
                }
                else
                {
                    nInsPrinciple = nInstAmount - nInterest;
                }
                nEffectiveBalance = nEffectiveBalance - nInsPrinciple;
                nTotalInstPrinciple += nInsPrinciple;
            }

            nBalance = this.LoanAmount + nTotalInterest;
            nEffectiveBalance = this.LoanAmount;
            nInstAmount = Financial.Pmt(nRate, this.NoOfInstallments, -this.LoanAmount, 0, DueDate.EndOfPeriod);
            nTotalInterest = 0;
            nTotalInstPrinciple = 0;

            for (int i = 0; i < this.NoOfInstallments; i++)
            {
                oSchedule = new LoanSchedule();
                nInterest = nEffectiveBalance * nRate;
                nTotalInterest = nTotalInterest + nInterest;
                oSchedule.CalculatedDate = dMonth;
                oSchedule.ScheduleNo = i + 1;
                if (i == this.NoOfInstallments - 1)
                {
                    oSchedule.InstallmentPrincipal = this.LoanAmount - nTotalInstPrinciple;
                }
                else
                {
                    oSchedule.InstallmentPrincipal = nInstAmount - nInterest;
                }
                oSchedule.OpeningBalance = nBalance;
                oSchedule.ActualInterest = nInterest;
                oSchedule.DueInstallmentDate = dMonth;
                oSchedule.InstallmentInterest = nInterest;

                nEffectiveBalance -= oSchedule.InstallmentPrincipal;
                nBalance = nBalance - (oSchedule.InstallmentPrincipal + oSchedule.InstallmentInterest);
                nTotalInstPrinciple += oSchedule.InstallmentPrincipal;

                oSchedule.ClosingBalance = nBalance;

                this.Schedules.Add(oSchedule);

                dMonth = dMonth.AddMonths(1);
                dMonth = Ease.CoreV35.Utility.Global.DateFunctions.LastDateOfMonth(dMonth);
            }

            if (fractionate != EnumLoanFraction.WithFraction)
            {
                AdjustSchedele(fractionate);
            }
        }

        public void PrepareEMISchedule(DateTime dMonth, EnumLoanFraction fractionate, int nSequenceNo)
        {
            LoanSchedule oSchedule = null;

            this.Schedules.Clear();

            double nInterest = 0.0;
            double nTotalInterest = 0.0;
            double nInsPrinciple = 0.0;
            double nBalance = 0.0;
            double nTotalInstPrinciple = 0.0;
            double nRate = this.InterestRate / 1200.0;
            double nEffectiveBalance = this.LoanAmount;
            double nInstAmount = Financial.Pmt(nRate, this.NoOfInstallments, -this.LoanAmount, 0, DueDate.EndOfPeriod);

            dMonth = Ease.CoreV35.Utility.Global.DateFunctions.LastDateOfMonth(dMonth);

            nTotalInterest = 0;
            for (int i = nSequenceNo - 1; i < this.NoOfInstallments; i++)
            {
                nInterest = nEffectiveBalance * nRate;
                nTotalInterest = nTotalInterest + nInterest;
                if (i == this.NoOfInstallments - 1)
                {
                    nInsPrinciple = this.LoanAmount - nTotalInstPrinciple;
                }
                else
                {
                    nInsPrinciple = nInstAmount - nInterest;
                }
                nEffectiveBalance = nEffectiveBalance - nInsPrinciple;
                nTotalInstPrinciple += nInsPrinciple;
            }

            nBalance = this.LoanAmount + nTotalInterest;
            nEffectiveBalance = this.LoanAmount;
            nInstAmount = Financial.Pmt(nRate, this.NoOfInstallments, -this.LoanAmount, 0, DueDate.EndOfPeriod);
            nTotalInterest = 0;
            nTotalInstPrinciple = 0;

            for (int i = nSequenceNo - 1; i < this.NoOfInstallments; i++)
            {
                oSchedule = new LoanSchedule();
                nInterest = nEffectiveBalance * nRate;
                nTotalInterest = nTotalInterest + nInterest;
                oSchedule.CalculatedDate = dMonth;
                oSchedule.ScheduleNo = i + 1;
                if (i == this.NoOfInstallments - 1)
                {
                    oSchedule.InstallmentPrincipal = this.LoanAmount - nTotalInstPrinciple;
                }
                else
                {
                    oSchedule.InstallmentPrincipal = nInstAmount - nInterest;
                }
                oSchedule.OpeningBalance = nBalance;
                oSchedule.ActualInterest = nInterest;
                oSchedule.DueInstallmentDate = dMonth;
                oSchedule.InstallmentInterest = nInterest;

                nEffectiveBalance -= oSchedule.InstallmentPrincipal;
                nBalance = nBalance - (oSchedule.InstallmentPrincipal + oSchedule.InstallmentInterest);
                nTotalInstPrinciple += oSchedule.InstallmentPrincipal;

                oSchedule.ClosingBalance = nBalance;

                this.Schedules.Add(oSchedule);

                dMonth = dMonth.AddMonths(1);
                dMonth = Ease.CoreV35.Utility.Global.DateFunctions.LastDateOfMonth(dMonth);
            }

            if (fractionate != EnumLoanFraction.WithFraction)
            {
                AdjustSchedele(fractionate);
            }
        }

        public void PrepareLMIDSchedule(DateTime dMonth, EnumLoanFraction fractionate)
        {
            LoanSchedule oSchedule = null;

            this.Schedules.Clear();

            double nTotalInterest = 0.0;
            double nBalance = 0.0;
            double nInstPrinciple = 0.0;
            double nTotalInstPrinciple = 0.0;
            int i = 0;

            dMonth = Ease.CoreV35.Utility.Global.DateFunctions.LastDateOfMonth(dMonth);
            nTotalInterest = this.LoanAmount * (this.InterestRate / 100.0) * ((double)this.NoOfInstallments / 12.0);
            nInstPrinciple = GlobalFunctions.Round(this.LoanAmount / this.NoOfInstallments);
            nBalance = this.LoanAmount + nTotalInterest;

            for (i = 0; i < this.NoOfInstallments; i++)
            {
                oSchedule = new LoanSchedule();
                oSchedule.CalculatedDate = dMonth;
                oSchedule.ScheduleNo = i + 1;
                if (i == this.NoOfInstallments - 1)
                {
                    oSchedule.InstallmentPrincipal = this.LoanAmount - nTotalInstPrinciple;
                }
                else
                {
                    oSchedule.InstallmentPrincipal = nInstPrinciple;
                }

                oSchedule.OpeningBalance = nBalance;
                oSchedule.ActualInterest = 0;
                oSchedule.DueInstallmentDate = dMonth;
                oSchedule.InstallmentInterest = 0;

                nBalance = nBalance - (oSchedule.InstallmentPrincipal + oSchedule.InstallmentInterest);
                nTotalInstPrinciple += oSchedule.InstallmentPrincipal;
                oSchedule.ClosingBalance = nBalance;

                this.Schedules.Add(oSchedule);

                dMonth = dMonth.AddMonths(1);
                dMonth = Ease.CoreV35.Utility.Global.DateFunctions.LastDateOfMonth(dMonth);
            }

            while (nTotalInterest > 0)
            {
                oSchedule = new LoanSchedule();
                oSchedule.CalculatedDate = dMonth;
                oSchedule.ScheduleNo = i++;
                oSchedule.InstallmentPrincipal = 0;
                oSchedule.OpeningBalance = nBalance;
                oSchedule.InstallmentInterest = nTotalInterest > nInstPrinciple ? nInstPrinciple : nTotalInterest;
                nBalance = nBalance - oSchedule.InstallmentInterest;
                oSchedule.ClosingBalance = nBalance;
                oSchedule.DueInstallmentDate = dMonth;
                nTotalInterest = nTotalInterest - nInstPrinciple;
                dMonth = dMonth.AddMonths(1);
                dMonth = Ease.CoreV35.Utility.Global.DateFunctions.LastDateOfMonth(dMonth);
                this.Schedules.Add(oSchedule);
            }

            if (fractionate != EnumLoanFraction.WithFraction)
            {
                AdjustSchedele(fractionate);
            }
        }
        public void PrepareLMIDSchedule(DateTime dMonth, EnumLoanFraction fractionate, int nSequenceNo)
        {
            LoanSchedule oSchedule = null;

            this.Schedules.Clear();

            double nTotalInterest = 0.0;
            double nBalance = 0.0;
            double nInstPrinciple = 0.0;
            double nTotalInstPrinciple = 0.0;
            int i = nSequenceNo - 1;

            dMonth = Ease.CoreV35.Utility.Global.DateFunctions.LastDateOfMonth(dMonth);
            nTotalInterest = this.LoanAmount * (this.InterestRate / 100.0) * ((double)this.NoOfInstallments / 12.0);
            nInstPrinciple = GlobalFunctions.Round(this.LoanAmount / this.NoOfInstallments);
            nBalance = this.LoanAmount + nTotalInterest;

            for (i = nSequenceNo - 1; i < this.NoOfInstallments; i++)
            {
                oSchedule = new LoanSchedule();
                oSchedule.CalculatedDate = dMonth;
                oSchedule.ScheduleNo = i + 1;
                if (i == this.NoOfInstallments - 1)
                {
                    oSchedule.InstallmentPrincipal = this.LoanAmount - nTotalInstPrinciple;
                }
                else
                {
                    oSchedule.InstallmentPrincipal = nInstPrinciple;
                }

                oSchedule.OpeningBalance = nBalance;
                oSchedule.ActualInterest = 0;
                oSchedule.DueInstallmentDate = dMonth;
                oSchedule.InstallmentInterest = 0;

                nBalance = nBalance - (oSchedule.InstallmentPrincipal + oSchedule.InstallmentInterest);
                nTotalInstPrinciple += oSchedule.InstallmentPrincipal;
                oSchedule.ClosingBalance = nBalance;

                this.Schedules.Add(oSchedule);

                dMonth = dMonth.AddMonths(1);
                dMonth = Ease.CoreV35.Utility.Global.DateFunctions.LastDateOfMonth(dMonth);
            }

            while (nTotalInterest > 0)
            {
                oSchedule = new LoanSchedule();
                oSchedule.CalculatedDate = dMonth;
                oSchedule.ScheduleNo = i++;
                oSchedule.InstallmentPrincipal = 0;
                oSchedule.OpeningBalance = nBalance;
                oSchedule.InstallmentInterest = nTotalInterest > nInstPrinciple ? nInstPrinciple : nTotalInterest;
                nBalance = nBalance - oSchedule.InstallmentInterest;
                oSchedule.ClosingBalance = nBalance;
                oSchedule.DueInstallmentDate = dMonth;
                nTotalInterest = nTotalInterest - nInstPrinciple;
                dMonth = dMonth.AddMonths(1);
                dMonth = Ease.CoreV35.Utility.Global.DateFunctions.LastDateOfMonth(dMonth);
                this.Schedules.Add(oSchedule);
            }

            if (fractionate != EnumLoanFraction.WithFraction)
            {
                AdjustSchedele(fractionate);
            }
        }

        public void PrepareSIDSchedule(DateTime dMonth, EnumLoanFraction fractionate)
        {
            LoanSchedule oSchedule = null;

            this.Schedules.Clear();

            int i = 0;
            double nInterest = 0.0;
            double nBalance = 0.0;


            dMonth = Ease.CoreV35.Utility.Global.DateFunctions.LastDateOfMonth(dMonth);
            nInterest = this.LoanAmount * this.InterestRate / 1200 * this.NoOfInstallments;
            nBalance = this.LoanAmount + nInterest;

            while (Math.Round(nBalance) > 0)
            {
                oSchedule = new LoanSchedule();
                oSchedule.CalculatedDate = dMonth;
                oSchedule.ScheduleNo = ++i;
                oSchedule.InstallmentInterest = nInterest / this.NoOfInstallments;
                oSchedule.InstallmentPrincipal = this.LoanAmount / this.NoOfInstallments;

                oSchedule.OpeningBalance = nBalance;
                oSchedule.ActualInterest = oSchedule.InstallmentInterest;
                oSchedule.DueInstallmentDate = dMonth;

                nBalance = nBalance - (oSchedule.InstallmentPrincipal + oSchedule.InstallmentInterest);

                oSchedule.ClosingBalance = nBalance;

                this.Schedules.Add(oSchedule);

                dMonth = dMonth.AddMonths(1);
                dMonth = Ease.CoreV35.Utility.Global.DateFunctions.LastDateOfMonth(dMonth);
            }

            if (fractionate != EnumLoanFraction.WithFraction)
            {
                AdjustSchedele(fractionate);
            }
        }
        public void PrepareSIDSchedule(DateTime dMonth, EnumLoanFraction fractionate, int nSequenceNo)
        {
            LoanSchedule oSchedule = null;

            this.Schedules.Clear();

            int i = nSequenceNo - 1;
            double nInterest = 0.0;
            double nBalance = 0.0;


            dMonth = Ease.CoreV35.Utility.Global.DateFunctions.LastDateOfMonth(dMonth);
            nInterest = this.LoanAmount * this.InterestRate / 1200 * this.NoOfInstallments;
            nBalance = this.LoanAmount + nInterest;

            while (Math.Round(nBalance) > 0)
            {
                oSchedule = new LoanSchedule();
                oSchedule.CalculatedDate = dMonth;
                oSchedule.ScheduleNo = ++i;
                oSchedule.InstallmentInterest = nInterest / this.NoOfInstallments;
                oSchedule.InstallmentPrincipal = this.LoanAmount / this.NoOfInstallments;

                oSchedule.OpeningBalance = nBalance;
                oSchedule.ActualInterest = oSchedule.InstallmentInterest;
                oSchedule.DueInstallmentDate = dMonth;

                nBalance = nBalance - (oSchedule.InstallmentPrincipal + oSchedule.InstallmentInterest);

                oSchedule.ClosingBalance = nBalance;

                this.Schedules.Add(oSchedule);

                dMonth = dMonth.AddMonths(1);
                dMonth = Ease.CoreV35.Utility.Global.DateFunctions.LastDateOfMonth(dMonth);
            }

            if (fractionate != EnumLoanFraction.WithFraction)
            {
                AdjustSchedele(fractionate);
            }
        }


        public void PrepareBankSchedule(DateTime dMonth, EnumLoanFraction fractionate)
        {
            LoanSchedule oSchedule = null;
            double nInterest = 0.0, nBalance = 0.0, nTotalInterest = 0.0, nInstPrinciple = 0.0, nAvgInterest = 0.0;
            int nDays = 0;

            this.Schedules.Clear();

            DateTime dNextMonth = new DateTime(this.StartPaybackMonthDate.Year, this.StartPaybackMonthDate.Month, 25);
            //int CheckDay = Ease.CoreV35.Utility.Global.DateFunctions.DateDiff("d", dMonth, Ease.CoreV35.Utility.Global.DateFunctions.LastDateOfMonth(dMonth));


            //if (dMonth.Day > 25)
            //{

            //    dNextMonth = Ease.CoreV35.Utility.Global.DateFunctions.DateAdd("m", 1, dNextMonth);//this.StartPaybackMonthDate.AddMonths(1);
            //}

            //dMonth = Ease.CoreV35.Utility.Global.DateFunctions.LastDateOfMonth(dMonth);
            nInstPrinciple = GlobalFunctions.Round(this.LoanAmount / this.NoOfInstallments);
            nBalance = this.LoanAmount;
            for (int i = 1; i <= this.NoOfInstallments; i++)
            {
                oSchedule = new LoanSchedule();
                if (i == 1)
                {
                    TimeSpan t = dNextMonth.Subtract(dNextMonth.TimeOfDay) - this.IssueDate.Subtract(this.IssueDate.TimeOfDay);
                    nDays = t.Days;
                    //nDays = Ease.CoreV35.Utility.Global.DateFunctions.DateDiff("d", this.IssueDate, dNextMonth);
                    nInterest = GlobalFunctions.Round((nDays * (this.LoanAmount * this.InterestRate)) / 36500);
                    nBalance = this.LoanAmount - nInstPrinciple;
                    //GlobalFunctions.Round(((this.LoanAmount * this.InterestRate))/100 / 12);
                    oSchedule.CalculatedDate = dNextMonth;
                }
                else
                {
                    DateTime dAddNextMonth = dNextMonth.AddMonths(1);
                    TimeSpan t = dAddNextMonth.Subtract(dAddNextMonth.TimeOfDay) - dNextMonth.Subtract(dNextMonth.TimeOfDay);
                    nDays = t.Days;
                    //nDays = Ease.CoreV35.Utility.Global.DateFunctions.DateDiff("d", dNextMonth,dAddNextMonth);
                    nInterest = GlobalFunctions.Round((nDays * (nBalance * this.InterestRate)) / 36500);
                    dNextMonth = dNextMonth.AddMonths(1);
                    nBalance = nBalance - nInstPrinciple;
                    oSchedule.CalculatedDate = dNextMonth;
                }

                nTotalInterest += nInterest;

                oSchedule.ScheduleNo = i;
                //if (i ==this.NoOfInstallments)
                //    nInstPrinciple = nBalance ;
                oSchedule.ActualInterest = nInterest;
                oSchedule.InstallmentPrincipal = nInstPrinciple;
                oSchedule.OpeningBalance = nBalance;
                oSchedule.InstallmentInterest = nInterest;
                oSchedule.DueInstallmentDate = Ease.CoreV35.Utility.Global.DateFunctions.LastDateOfMonth(dNextMonth);
                oSchedule.Days = nDays;
                oSchedule.ClosingBalance = nBalance;
                oSchedule.InterestRate = this.InterestRate;
                this.Schedules.Add(oSchedule);
            }

            nAvgInterest = nTotalInterest / this.NoOfInstallments;
            foreach (LoanSchedule oItem in this.Schedules)
            {
                oItem.InstallmentInterest = nAvgInterest;
            }
            //if (fractionate != EnumLoanFraction.WithFraction)
            //{
            //    AdjustSchedele(fractionate);
            //}
        }
        public void PrepareBankSchedule(DateTime dMonth, EnumLoanFraction fractionate, int nSequenceNo, int nRemainingInstallment, ObjectsTemplate<LoanSchedule> oItems)
        {
            string sFormat = "0";
            LoanSchedule oSchedule = null;
            double nInterest = 0.0, nBalance = 0.0, nTotalInterest = 0.0, nInstPrinciple = 0.0, nAvgInterest = 0.0;
            int nDays = 0;

            this.Schedules.Clear();
            //this.NoOfInstallments = nRemainingInstallment;
            DateTime dNextMonth = new DateTime(this.StartPaybackMonthDate.Year, this.StartPaybackMonthDate.Month, 25);

            if (dMonth.Day > 25)
            {

                dNextMonth = Ease.CoreV35.Utility.Global.DateFunctions.DateAdd("m", 1, dNextMonth);//this.StartPaybackMonthDate.AddMonths(1);
            }
            nInstPrinciple = GlobalFunctions.Round(this.LoanAmount / nRemainingInstallment);
            nBalance = this.LoanAmount;
            for (int i = nSequenceNo; i <= this.NoOfInstallments; i++)
            {
                oSchedule = new LoanSchedule();
                if (i == 1)
                {
                    TimeSpan t = dNextMonth.Subtract(dNextMonth.TimeOfDay) - this.IssueDate.Subtract(this.IssueDate.TimeOfDay);
                    nDays = t.Days;
                    nInterest = GlobalFunctions.Round((nDays * (this.LoanAmount * this.InterestRate)) / 36500);
                    nBalance = this.LoanAmount - nInstPrinciple;
                    oSchedule.CalculatedDate = dNextMonth;
                }
                else
                {
                    DateTime dAddNextMonth = dNextMonth.AddMonths(1);
                    TimeSpan t = dAddNextMonth.Subtract(dAddNextMonth.TimeOfDay) - dNextMonth.Subtract(dNextMonth.TimeOfDay);
                    nDays = t.Days;
                    nInterest = GlobalFunctions.Round((nDays * (nBalance * this.InterestRate)) / 36500);
                    dNextMonth = dNextMonth.AddMonths(1);
                    nBalance = nBalance - nInstPrinciple;
                    oSchedule.CalculatedDate = dNextMonth;
                }

                nTotalInterest += nInterest;

                oSchedule.ScheduleNo = i;
                oSchedule.ActualInterest = Math.Round(nInterest, 0);
                oSchedule.InstallmentPrincipal = Math.Round(nInstPrinciple);
                oSchedule.OpeningBalance = Math.Round(nBalance);
                oSchedule.InstallmentInterest = Math.Round(nInterest);
                oSchedule.DueInstallmentDate = Ease.CoreV35.Utility.Global.DateFunctions.LastDateOfMonth(dNextMonth);
                oSchedule.Days = nDays;
                oSchedule.ClosingBalance = nBalance;
                oSchedule.InterestRate = this.InterestRate;

                this.Schedules.Add(oSchedule);
            }
            ObjectsTemplate<LoanSchedule> oNewSchedules = new ObjectsTemplate<LoanSchedule>();
            foreach (LoanSchedule oItem in this.Schedules)
            {
                LoanSchedule item = oItems.Find(delegate(LoanSchedule ls) { return oItem.CalculatedDate.Month == ls.CalculatedDate.Month && oItem.CalculatedDate.Year == ls.CalculatedDate.Year; });
                if (item == null)
                    oNewSchedules.Add(oItem);
            }
            this.Schedules.Clear();
            foreach (LoanSchedule oItem in oNewSchedules)
            {
                this.Schedules.Add(oItem);
            }
            nAvgInterest = nTotalInterest / nRemainingInstallment; //Need to change
            foreach (LoanSchedule oItem in this.Schedules)
            {
                oItem.InstallmentInterest = nAvgInterest;
            }
        }

        public void PrepareHalfYearlySchedule(DateTime dMonth, EnumLoanFraction fractionate)
        {
            LoanSchedule oSchedule = null;
            double nInterest = 0.0, nBalance = 0.0, nTotalInterest = 0.0, nInstPrinciple = 0.0, nAvgInterest = 0.0, nMainAvgInterest = 0.0;
            int nDays = 0;

            this.Schedules.Clear();

            DateTime dNextMonth = new DateTime(this.StartPaybackMonthDate.Year, this.StartPaybackMonthDate.Month, 25);
            //if (dMonth.Day > 25)
            //{

            //    dNextMonth = Ease.CoreV35.Utility.Global.DateFunctions.DateAdd("m", 1, dNextMonth);
            //}
            nInstPrinciple = GlobalFunctions.Round(this.LoanAmount / this.NoOfInstallments);
            nBalance = this.LoanAmount;
            int nInstallmentCount = 1;
            double nPartialInterest = 0;
            for (int i = 1; i <= this.NoOfInstallments; i++)
            {
                oSchedule = new LoanSchedule();
                if (i == 1)
                {
                    TimeSpan t = dNextMonth.Subtract(dNextMonth.TimeOfDay) - this.IssueDate.Subtract(this.IssueDate.TimeOfDay);
                    nDays = t.Days;
                    //nInterest = GlobalFunctions.Round((nDays * (this.LoanAmount * this.InterestRate)) / 36500);
                    nBalance = this.LoanAmount - nInstPrinciple;
                    oSchedule.CalculatedDate = dNextMonth;
                }
                else
                {
                    DateTime dAddNextMonth = dNextMonth.AddMonths(1);
                    TimeSpan t = dAddNextMonth.Subtract(dAddNextMonth.TimeOfDay) - dNextMonth.Subtract(dNextMonth.TimeOfDay);
                    nDays = t.Days;
                    //nInterest = GlobalFunctions.Round((nDays * (nBalance * this.InterestRate)) / 36500);
                    dNextMonth = dNextMonth.AddMonths(1);
                    if (i == this.NoOfInstallments && nBalance < nInstPrinciple)
                    {
                        nInstPrinciple = nBalance;
                        nBalance = nInstPrinciple - nBalance;
                    }
                    else if (i == this.NoOfInstallments && nBalance > nInstPrinciple)
                    {
                        nInstPrinciple = nBalance;
                        nBalance = 0;
                    }
                    else
                        nBalance = nBalance - nInstPrinciple;
                    oSchedule.CalculatedDate = dNextMonth;
                }
                //nTotalInterest += nInterest;
               // nPartialInterest += nInterest;
                oSchedule.ScheduleNo = i;                
                oSchedule.InstallmentPrincipal = nInstPrinciple;
                oSchedule.OpeningBalance = nBalance;                
                //oSchedule.ActualInterest = nInterest;
                //if (nInstallmentCount % 6 == 0 || nInstallmentCount == this.NoOfInstallments)
                //{
                //    oSchedule.InstallmentInterest = nPartialInterest;
                //    nPartialInterest = 0;
                //}
                //else
                //{
                    oSchedule.InstallmentInterest = 0;
                //}
                oSchedule.DueInstallmentDate = Ease.CoreV35.Utility.Global.DateFunctions.LastDateOfMonth(dNextMonth);
                oSchedule.Days = nDays;
                oSchedule.ClosingBalance = nBalance;
                oSchedule.InterestRate = this.InterestRate;
                this.Schedules.Add(oSchedule);
                nInstallmentCount++;
            }
            nInstallmentCount = 1;
            nMainAvgInterest = (this.LoanAmount * this.InterestRate) / 100;
            nAvgInterest = nMainAvgInterest / 2;
            //double nInterestPeriod = this.NoOfInstallments / 6;
            //if (this.NoOfInstallments % 6 != 0)
            //{
            //    nInterestPeriod += 1;
            //}
            //nAvgInterest = nAvgInterest / nInterestPeriod;
            int nperiodic = 1;
            foreach (LoanSchedule oItem in this.Schedules)
            {
                if (nInstallmentCount % 6 == 0 || nInstallmentCount == this.NoOfInstallments)
                {
                    if (this.NoOfInstallments <= 6)
                    {
                        if (nInstallmentCount == this.NoOfInstallments)
                        {
                            oItem.InstallmentInterest = nMainAvgInterest;
                            break;
                        }
                    }
                    else if((nperiodic >= 3 && (this.NoOfInstallments - nInstallmentCount==0)))
                    {
                        if(IsEven(nperiodic))
                        {
                            oItem.InstallmentInterest = nAvgInterest;
                            break;
                        }
                        else if (IsOdd(nperiodic))
                        {
                            oItem.InstallmentInterest = nMainAvgInterest;
                            break;
                        }
                    }
                    else
                    {
                        oItem.InstallmentInterest = nAvgInterest;
                        nperiodic++;
                    }
                }
              
                nInstallmentCount++;
            }
        }

        private static  bool IsEven(int nperiodic)
        {
            return nperiodic % 2 == 0;
        }

        private static bool IsOdd(int nperiodic)
        {
            return nperiodic % 2 != 0;
        }

        private void AdjustSchedele(EnumLoanFraction fractionate)
        {
            if (fractionate == EnumLoanFraction.WithFraction) return;

            double nFraction = 0.0;

            foreach (LoanSchedule item in this.Schedules)
            {
                nFraction += item.InstallmentInterest - Math.Floor(item.InstallmentInterest);
                nFraction += item.InstallmentPrincipal - Math.Floor(item.InstallmentPrincipal);
                item.InstallmentPrincipal -= item.InstallmentPrincipal - Math.Floor(item.InstallmentPrincipal);
                item.InstallmentInterest -= item.InstallmentInterest - Math.Floor(item.InstallmentInterest);
            }
            double nequal = 0;
            for (int i = 1; i <= this.Schedules.Count - 1; i++)
            {
                if (this.Schedules[i - 1].Installment != this.Schedules[i].Installment)
                {
                    nequal = this.Schedules[i - 1].Installment - this.Schedules[i].Installment;
                    this.Schedules[i].InstallmentPrincipal = this.Schedules[i].InstallmentPrincipal + nequal;
                    nFraction = nFraction - nequal;
                }
            }
            nFraction = GlobalFunctions.Round(nFraction);
            if (nFraction != 0 && this.Schedules.Count > 0)
            {
                if (fractionate == EnumLoanFraction.FractionFirstMonth)
                {
                    if (this.InterestRate == 0)
                        this.Schedules[0].InstallmentPrincipal += nFraction;
                    else this.Schedules[0].InstallmentInterest += nFraction;
                }
                else
                {
                    if (this.InterestRate == 0)
                        this.Schedules[this.Schedules.Count - 1].InstallmentPrincipal += nFraction;
                    else this.Schedules[this.Schedules.Count - 1].InstallmentInterest += nFraction;
                }

                for (int i = 0; i < this.Schedules.Count; i++)
                {
                    //   if (i == 9) return;
                    this.Schedules[i].ClosingBalance = this.Schedules[i].OpeningBalance - (this.Schedules[i].InstallmentPrincipal + this.Schedules[i].InstallmentInterest);
                    if (i < this.Schedules.Count - 1)
                    {
                        this.Schedules[i + 1].OpeningBalance = this.Schedules[i].ClosingBalance;
                    }
                }
            }
        }

        public static LoanIssue GetByLoanAndEmployeeIdAndLoanNumber(ID LoanId, ID EmployeeId, string loanNumber)
        {

            return LoanIssue.Service.GetByLoanAndEmployeeIdAndLoanNumber(LoanId, EmployeeId, loanNumber);

        }

        public static ObjectsTemplate<LoanIssue> GetByEmployeeIdAndLoanNumber(ID id, string loanNumber)
        {
            ObjectsTemplate<LoanIssue> allIssuedLoans = new ObjectsTemplate<LoanIssue>();
            allIssuedLoans = LoanIssue.Service.GetByEmployeeIdAndLoanNumber(id, loanNumber);
            return allIssuedLoans;
        }

        public static LoanIssue GetExistingAllLoan(ID nLoanID, ID nEmpID)
        {
            LoanIssue oLoanIssue = null;
            #region Cache Header
            oLoanIssue = (LoanIssue)_cache["GetExistingLoan", nLoanID, nEmpID];
            if (oLoanIssue != null)
                return oLoanIssue;
            #endregion
            oLoanIssue = LoanIssue.Service.GetExistingAllLoan(nLoanID, nEmpID);
            #region Cache Footer
            _cache.Add(oLoanIssue, "GetExistingLoan", nLoanID, nEmpID);
            #endregion
            return oLoanIssue;
        }

        #endregion

        public string WFDesciption()
        {
            string sDescription;

            //sDescription = "Employee (" + Employee.EmployeeNo + ") " + Employee.Name
            //              + " applied " + this.Leave.Description + " From: " + this.AppliedFromDate.ToString("dd MMM yyyy")
            //              + " To: " + this.AppliedToDate.ToString("dd MMM yyyy")
            //              + " Total: " + this.ApprovedTotalDays.ToString()
            //              + " Reason: " + this.Remarks;
            sDescription = this.ObjectDescription;
            return sDescription;
        }

        public int GetStatusbyWf(enumwfStatus wfstatus)
        {

            return (int)this.WFStatus;
        }

        public string ObjectDescription
        {
            get
            {
                string str = "";
                str = " Employee (" + this.Employee.EmployeeNo + ")" + this.Employee.Name
                        + " applied " + this.LoanObj.Name + " Loan. ";
                return str;

            }
        }

        public ID SetupID
        {
            get { return ID.FromInteger(2); }
        }

        public ID ObjectID
        {
            get { return this.ID; }
        }
    }
    #endregion

    #region ILoanIssue Service

    public interface ILoanIssueService
    {
        LoanIssue Get(ID id);
        ObjectsTemplate<LoanIssue> Get();
        DataSet GetIssuedLoanIDs(int EmpID);
        ID Save(LoanIssue item);
        ID Save2(LoanIssue item);
        void Delete(ID id);

        LoanIssue GetExistingLoan(ID nLoanID, ID nEmpID);
        LoanIssue GetExistingAllLoan(ID nLoanID, ID nEmpID);
        ObjectsTemplate<LoanIssue> GetExistingLoan(ID nEmpID);
        ObjectsTemplate<LoanIssue> GetByDueInstallmentDate(DateTime dateTime, string empID);
        ObjectsTemplate<LoanIssue> Get(DateTime dateTime);
        ObjectsTemplate<LoanIssue> Get(DateTime dateTime, DateTime dateTime2);
        ObjectsTemplate<LoanIssue> Get(string employeeNo);

        ObjectsTemplate<LoanIssue> GetByLoanID(ID nLoanID);

        ObjectsTemplate<LoanIssue> GetByEmployeeIdAndLoanNumber(ID id, string loanNumber);
        LoanIssue GetByLoanAndEmployeeIdAndLoanNumber(ID LoanId, ID EmployeeId, string loanNumber);
        DataSet GetIssuedLoans(int EmpID);

        ObjectsTemplate<LoanIssue> GetByDueInstallmentDate(DateTime dateTime);
        ObjectsTemplate<LoanIssue> GetAllExistingLoan(string LoanIDs);
        ObjectsTemplate<LoanIssue> GetAllExistingLoan(int EmpID, string sLaonIDs);
        ObjectsTemplate<LoanIssue> GetAllExistingLoan(string LoanIDs, DateTime month);
        void UpdateAvgIntStatus(ObjectsTemplate<LoanIssue> lis);
    }

    #endregion
}