Example #1
0
        /// <summary>
        /// Returns the appropriate recognition date in a given financial period,
        /// taking into account the <see cref="DRScheduleOption"/> settings of the
        /// deferral code, as well as the absolute recognition date boundaries provided
        /// as arguments to this method.
        /// </summary>
        /// <param name="finPeriod">The financial period in which recognition must happen.</param>
        /// <param name="minimumDate">The earliest date where recognition is allowed.</param>
        /// <param name="maximumDate">The latest date where recognition is allowed.</param>
        /// <returns></returns>
        protected DateTime GetRecognitionDate(string finPeriod, DateTime minimumDate, DateTime?maximumDate, int?organizationID)
        {
            DateTime date = minimumDate;

            switch (_code.ScheduleOption)
            {
            case DRScheduleOption.ScheduleOptionStart:
                date = _finPeriodRepository.PeriodStartDate(finPeriod, organizationID);
                break;

            case DRScheduleOption.ScheduleOptionEnd:
                date = _finPeriodRepository.PeriodEndDate(finPeriod, organizationID);
                break;

            case DRScheduleOption.ScheduleOptionFixedDate:
                DateTime startDate = _finPeriodRepository.PeriodStartDate(finPeriod, organizationID);
                DateTime endDate   = _finPeriodRepository.PeriodEndDate(finPeriod, organizationID);

                if (_code.FixedDay.Value <= startDate.Day)
                {
                    date = startDate;
                }
                else if (_code.FixedDay.Value >= endDate.Day)
                {
                    date = endDate;
                }
                else
                {
                    date = new DateTime(startDate.Year, startDate.Month, _code.FixedDay.Value);
                }
                break;
            }

            if (date < minimumDate && _code.StartOffset >= 0)
            {
                return(minimumDate);
            }
            else if (date > maximumDate)
            {
                return(maximumDate.Value);
            }

            return(date);
        }
Example #2
0
        public virtual IEnumerable <ScheduleDet> MakeSchedule(
            Schedule scheduleParameters,
            short numberOccurrences,
            DateTime?runDate = null)
        {
            runDate = runDate ?? _graph.Accessinfo.BusinessDate;

            List <ScheduleDet> scheduleOccurrences = new List <ScheduleDet>();

            if (scheduleParameters.NextRunDate == null && scheduleParameters.LastRunDate == null)
            {
                scheduleParameters.NextRunDate = scheduleParameters.StartDate;
            }
            else if (scheduleParameters.NextRunDate == null)
            {
                scheduleParameters.NextRunDate = scheduleParameters.LastRunDate;
            }

            int   occurrencesCreated = 0;
            short oldRunCounter      = scheduleParameters.RunCntr ?? 0;

            do
            {
                ScheduleDet occurrence = new ScheduleDet();
                do
                {
                    switch (scheduleParameters.ScheduleType)
                    {
                    case GLScheduleType.Daily:
                        occurrence.ScheduledDate       = scheduleParameters.NextRunDate;
                        scheduleParameters.NextRunDate = ((DateTime)scheduleParameters.NextRunDate).AddDays((short)scheduleParameters.DailyFrequency);
                        break;

                    case GLScheduleType.Weekly:
                        CalcRunDatesWeekly(scheduleParameters, occurrence);
                        break;

                    case GLScheduleType.Periodically:
                        try
                        {
                            switch (scheduleParameters.PeriodDateSel)
                            {
                            case PeriodDateSelOption.PeriodStart:
                                occurrence.ScheduledDate = _finPeriodRepository.PeriodStartDate(
                                    _finPeriodRepository.GetPeriodIDFromDate(scheduleParameters.NextRunDate, FinPeriod.organizationID.MasterValue),
                                    FinPeriod.organizationID.MasterValue);

                                scheduleParameters.NextRunDate = _finPeriodRepository.PeriodStartDate(
                                    _finPeriodRepository.GetOffsetPeriodId(
                                        _finPeriodRepository.GetPeriodIDFromDate(scheduleParameters.NextRunDate, FinPeriod.organizationID.MasterValue),
                                        (short)scheduleParameters.PeriodFrequency,
                                        FinPeriod.organizationID.MasterValue),
                                    FinPeriod.organizationID.MasterValue);
                                break;

                            case PeriodDateSelOption.PeriodEnd:
                                occurrence.ScheduledDate = _finPeriodRepository.PeriodEndDate(
                                    _finPeriodRepository.GetPeriodIDFromDate(scheduleParameters.NextRunDate, FinPeriod.organizationID.MasterValue),
                                    FinPeriod.organizationID.MasterValue);

                                scheduleParameters.NextRunDate = _finPeriodRepository.PeriodEndDate(
                                    _finPeriodRepository.GetOffsetPeriodId(
                                        _finPeriodRepository.GetPeriodIDFromDate(scheduleParameters.NextRunDate, FinPeriod.organizationID.MasterValue),
                                        (short)scheduleParameters.PeriodFrequency,
                                        FinPeriod.organizationID.MasterValue),
                                    FinPeriod.organizationID.MasterValue);
                                break;

                            case PeriodDateSelOption.PeriodFixedDate:
                                occurrence.ScheduledDate = _finPeriodRepository.PeriodStartDate(
                                    _finPeriodRepository.GetPeriodIDFromDate(scheduleParameters.NextRunDate, FinPeriod.organizationID.MasterValue),
                                    FinPeriod.organizationID.MasterValue)
                                                           .AddDays((short)scheduleParameters.PeriodFixedDay - 1);

                                if (((DateTime)occurrence.ScheduledDate).CompareTo(
                                        _finPeriodRepository.PeriodEndDate(
                                            _finPeriodRepository.GetPeriodIDFromDate(scheduleParameters.NextRunDate, FinPeriod.organizationID.MasterValue),
                                            FinPeriod.organizationID.MasterValue))
                                    > 0)
                                {
                                    occurrence.ScheduledDate = _finPeriodRepository.PeriodEndDate(
                                        _finPeriodRepository.GetPeriodIDFromDate(scheduleParameters.NextRunDate, FinPeriod.organizationID.MasterValue),
                                        FinPeriod.organizationID.MasterValue);
                                }

                                DateTime?OldNextRunDate = scheduleParameters.NextRunDate;
                                scheduleParameters.NextRunDate = _finPeriodRepository.PeriodStartDate(
                                    _finPeriodRepository.GetOffsetPeriodId(
                                        _finPeriodRepository.GetPeriodIDFromDate(scheduleParameters.NextRunDate, FinPeriod.organizationID.MasterValue),
                                        (short)scheduleParameters.PeriodFrequency,
                                        FinPeriod.organizationID.MasterValue),
                                    FinPeriod.organizationID.MasterValue)
                                                                 .AddDays((short)scheduleParameters.PeriodFixedDay - 1);

                                if (((DateTime)scheduleParameters.NextRunDate).CompareTo(
                                        _finPeriodRepository.PeriodEndDate(
                                            _finPeriodRepository.GetOffsetPeriodId(
                                                _finPeriodRepository.GetPeriodIDFromDate(OldNextRunDate, FinPeriod.organizationID.MasterValue),
                                                (short)scheduleParameters.PeriodFrequency,
                                                FinPeriod.organizationID.MasterValue),
                                            FinPeriod.organizationID.MasterValue))
                                    > 0)
                                {
                                    scheduleParameters.NextRunDate = _finPeriodRepository.PeriodEndDate(
                                        _finPeriodRepository.GetOffsetPeriodId(
                                            _finPeriodRepository.GetPeriodIDFromDate(OldNextRunDate, FinPeriod.organizationID.MasterValue),
                                            (short)scheduleParameters.PeriodFrequency,
                                            FinPeriod.organizationID.MasterValue),
                                        FinPeriod.organizationID.MasterValue);
                                }
                                break;
                            }
                        }
                        catch (PXFinPeriodException)
                        {
                            if (occurrence.ScheduledDate != null &&
                                (bool)scheduleParameters.NoRunLimit == false &&
                                scheduleParameters.RunCntr + 1 == scheduleParameters.RunLimit &&
                                scheduleParameters.NextRunDate != null)
                            {
                                scheduleParameters.NextRunDate = null;
                            }
                            else
                            {
                                scheduleParameters.RunCntr = oldRunCounter;
                                throw new PXFinPeriodException(Messages.NoFinancialPeriodForNextExecutionDate);
                            }
                        }
                        break;

                    case GLScheduleType.Monthly:
                        switch (scheduleParameters.MonthlyDaySel)
                        {
                        case "D":
                            occurrence.ScheduledDate       = new PXDateTime((short)((DateTime)scheduleParameters.NextRunDate).Year, (short)((DateTime)scheduleParameters.NextRunDate).Month, (short)scheduleParameters.MonthlyOnDay);
                            scheduleParameters.NextRunDate = PXDateTime.DatePlusMonthSetDay((DateTime)occurrence.ScheduledDate, (short)scheduleParameters.MonthlyFrequency, (short)scheduleParameters.MonthlyOnDay);
                            break;

                        case "W":
                            occurrence.ScheduledDate = PXDateTime.MakeDayOfWeek((short)((DateTime)scheduleParameters.NextRunDate).Year, (short)((DateTime)scheduleParameters.NextRunDate).Month, (short)scheduleParameters.MonthlyOnWeek, (short)scheduleParameters.MonthlyOnDayOfWeek);

                            scheduleParameters.NextRunDate = new PXDateTime(((DateTime)occurrence.ScheduledDate).Year, ((DateTime)occurrence.ScheduledDate).Month, 1).AddMonths((short)scheduleParameters.MonthlyFrequency);
                            scheduleParameters.NextRunDate = PXDateTime.MakeDayOfWeek((short)((DateTime)scheduleParameters.NextRunDate).Year, (short)((DateTime)scheduleParameters.NextRunDate).Month, (short)scheduleParameters.MonthlyOnWeek, (short)scheduleParameters.MonthlyOnDayOfWeek);
                            break;
                        }
                        break;

                    default:
                        throw new PXException();
                    }
                }while (occurrence.ScheduledDate == scheduleParameters.LastRunDate);

                if (occurrence.ScheduledDate != null &&
                    ((DateTime)occurrence.ScheduledDate).CompareTo(scheduleParameters.StartDate) >= 0 &&
                    ((bool)scheduleParameters.NoEndDate || ((DateTime)occurrence.ScheduledDate).CompareTo(scheduleParameters.EndDate) <= 0) &&
                    (((DateTime)occurrence.ScheduledDate).CompareTo(runDate) <= 0) &&
                    ((bool)scheduleParameters.NoRunLimit || scheduleParameters.RunCntr < scheduleParameters.RunLimit))
                {
                    try
                    {
                        occurrence.ScheduledPeriod = _finPeriodRepository.GetPeriodIDFromDate(occurrence.ScheduledDate, FinPeriod.organizationID.MasterValue);
                    }
                    catch (PXFinPeriodException)
                    {
                        scheduleParameters.RunCntr = oldRunCounter;
                        throw new PXFinPeriodException(Messages.NoFinancialPeriodForNextExecutionDate);
                    }

                    scheduleOccurrences.Add(occurrence);
                    scheduleParameters.RunCntr++;

                    if ((bool)scheduleParameters.NoRunLimit == false && scheduleParameters.RunCntr >= scheduleParameters.RunLimit ||
                        (scheduleParameters.NextRunDate != null) && (bool)scheduleParameters.NoEndDate == false && ((DateTime)scheduleParameters.NextRunDate).CompareTo(scheduleParameters.EndDate) > 0)
                    {
                        scheduleParameters.Active      = false;
                        scheduleParameters.NextRunDate = null;
                    }

                    if (scheduleParameters.NextRunDate == null)
                    {
                        break;
                    }

                    if (++occurrencesCreated >= numberOccurrences)
                    {
                        return(scheduleOccurrences);
                    }
                }
                else
                {
                    if (((DateTime)occurrence.ScheduledDate).CompareTo(scheduleParameters.StartDate) < 0)
                    {
                        continue;
                    }
                    if (occurrence.ScheduledDate != null)
                    {
                        scheduleParameters.NextRunDate = occurrence.ScheduledDate;
                    }
                    break;
                }
            }while (true);

            return(scheduleOccurrences);
        }