public virtual void GetRange(DateTime date, string Range, int?cashAccountID, out DateTime?RangeStart, out DateTime?RangeEnd)
{
switch (Range)
{
case "W":
RangeStart = date.AddDays(-1 * (PXDateTime.DayOfWeekOrdinal(date.DayOfWeek) - 1));
RangeEnd = date.AddDays(7 - PXDateTime.DayOfWeekOrdinal(date.DayOfWeek));
return;
case "M":
RangeStart = new DateTime(date.Year, date.Month, 1);
RangeEnd = new DateTime(date.Year, date.Month, 1).AddMonths(1).AddDays(-1);
return;
case "P":
CashAccount cashAccount = PXSelect <CashAccount, Where <CashAccount.cashAccountID, Equal <Required <CashAccount.cashAccountID> > > > .Select(this, cashAccountID);
int?organizationID = PXAccess.GetParentOrganizationID(cashAccount?.BranchID);
var period = FinPeriodRepository.FindFinPeriodByDate(date, organizationID);
RangeStart = period?.StartDate;
RangeEnd = period?.EndDate;
return;
case "D":
default:
RangeStart = date;
RangeEnd = date;
return;
}
}
protected static DateTime getPrevDate(DateTime aGuessDate, DateTime aBeforeDate, int Day)
{
return((aGuessDate < aBeforeDate) ? aGuessDate : PXDateTime.DatePlusMonthSetDay(aGuessDate, -1, Day));
}
protected static DateTime getNextDate(DateTime aGuessDate, DateTime aLastStatementDate, int Day)
{
return((aLastStatementDate < aGuessDate) ? aGuessDate : PXDateTime.DatePlusMonthSetDay(aGuessDate, 1, Day));
}
public static DateTime CalcStatementDateBefore(DateTime aBeforeDate, string aPrepareOn, int?aDay00, int?aDay01)
{
DateTime statementDate = DateTime.MinValue;
switch (aPrepareOn)
{
case PrepareOnType.FixedDayOfMonth:
statementDate = new PXDateTime(aBeforeDate.Year, aBeforeDate.Month, aDay00 ?? 1);
statementDate = getPrevDate(statementDate, aBeforeDate, aDay00 ?? 1);
break;
case PrepareOnType.EndOfMonth:
DateTime dateTime = new DateTime(aBeforeDate.Year, aBeforeDate.Month, 1);
statementDate = dateTime.AddDays(-1);
break;
case PrepareOnType.Custom:
DateTime dateTime1 = DateTime.MinValue;
DateTime dateTime2 = DateTime.MinValue;
bool useBoth = (aDay00 != null) && (aDay01 != null);
if (aDay00 != null)
{
dateTime1 = new PXDateTime(aBeforeDate.Year, aBeforeDate.Month, aDay00.Value);
}
if (aDay01 != null)
{
dateTime2 = new PXDateTime(aBeforeDate.Year, aBeforeDate.Month, aDay01.Value);
}
if (useBoth)
{
Int32 Day00 = (Int32)aDay00;
Int32 Day01 = (Int32)aDay01;
Utilities.SwapIfGreater(ref dateTime1, ref dateTime2);
Utilities.SwapIfGreater(ref Day00, ref Day01);
if (aBeforeDate > dateTime2)
{
statementDate = dateTime2;
}
else
{
if (aBeforeDate > dateTime1)
{
statementDate = dateTime1;
}
else
{
statementDate = PXDateTime.DatePlusMonthSetDay(dateTime2, -1, Day01);
}
}
}
else
{
DateTime dt = (dateTime1 != DateTime.MinValue) ? dateTime1 : dateTime2;
if (dt != DateTime.MinValue)
{
statementDate = getPrevDate(dt, statementDate, aDay00 ?? aDay01 ?? 1);
}
}
break;
default:
throw new PXException(Messages.UnknownPrepareOnType);
}
return(statementDate);
}
public static DateTime?CalcNextStatementDate(DateTime aLastStmtDate, string aPrepareOn, int?aDay00, int?aDay01)
{
DateTime?nextDate = null;
switch (aPrepareOn)
{
case PrepareOnType.FixedDayOfMonth:
DateTime guessDate = new PXDateTime(aLastStmtDate.Year, aLastStmtDate.Month, aDay00 ?? 1);
nextDate = getNextDate(guessDate, aLastStmtDate, aDay00 ?? 1);
break;
case PrepareOnType.EndOfMonth:
DateTime dateTime = new DateTime(aLastStmtDate.Year, aLastStmtDate.Month, 1);
dateTime = dateTime.AddMonths(1);
TimeSpan diff = (dateTime.Subtract(aLastStmtDate));
int days = diff.Days;
if (days < 2)
{
nextDate = dateTime.AddMonths(1).AddDays(-1);
}
else
{
nextDate = dateTime.AddDays(-1);
}
break;
case PrepareOnType.Custom:
DateTime dateTime1 = DateTime.MinValue;
DateTime dateTime2 = DateTime.MinValue;
bool useBoth = (aDay00 != null) && (aDay01 != null);
if (aDay00 != null)
{
dateTime1 = new PXDateTime(aLastStmtDate.Year, aLastStmtDate.Month, aDay00.Value);
}
if (aDay01 != null)
{
dateTime2 = new PXDateTime(aLastStmtDate.Year, aLastStmtDate.Month, aDay01.Value);
}
if (useBoth)
{
Int32 Day00 = (Int32)aDay00;
Int32 Day01 = (Int32)aDay01;
Utilities.SwapIfGreater(ref dateTime1, ref dateTime2);
Utilities.SwapIfGreater(ref Day00, ref Day01);
if (aLastStmtDate < dateTime1)
{
nextDate = dateTime1;
}
else
{
if (aLastStmtDate < dateTime2)
{
nextDate = dateTime2;
}
else
{
nextDate = PXDateTime.DatePlusMonthSetDay(dateTime1, 1, Day00);
}
}
}
else
{
DateTime dt = (dateTime1 != DateTime.MinValue) ? dateTime1 : dateTime2;
if (dt != DateTime.MinValue)
{
nextDate = getNextDate(dt, aLastStmtDate, aDay00 ?? aDay01 ?? 1);
}
}
break;
}
return(nextDate);
}
public static List <ScheduleDet> MakeSchedule(PXGraph graph, Schedule s, short Times, DateTime runDate)
{
List <ScheduleDet> ret = new List <ScheduleDet>();
if (s.NextRunDate == null && s.LastRunDate == null)
{
s.NextRunDate = s.StartDate;
}
else if (s.NextRunDate == null)
{
s.NextRunDate = s.LastRunDate;
}
int i = 0;
short oldRunCntr = s.RunCntr ?? 0;
do
{
ScheduleDet d = new ScheduleDet();
do
{
switch (s.ScheduleType)
{
case "D":
d.ScheduledDate = s.NextRunDate;
s.NextRunDate = ((DateTime)s.NextRunDate).AddDays((short)s.DailyFrequency);
break;
case "W":
CalcRunDatesWeekly(s, d);
break;
case "P":
try
{
switch (s.PeriodDateSel)
{
case "S":
d.ScheduledDate = FinPeriodIDAttribute.PeriodStartDate(graph, FinPeriodIDAttribute.PeriodFromDate(graph, s.NextRunDate));
s.NextRunDate = FinPeriodIDAttribute.PeriodStartDate(graph, FinPeriodIDAttribute.PeriodPlusPeriod(graph, FinPeriodIDAttribute.PeriodFromDate(graph, s.NextRunDate), (short)s.PeriodFrequency));
break;
case "E":
d.ScheduledDate = FinPeriodIDAttribute.PeriodEndDate(graph, FinPeriodIDAttribute.PeriodFromDate(graph, s.NextRunDate));
s.NextRunDate = FinPeriodIDAttribute.PeriodEndDate(graph, FinPeriodIDAttribute.PeriodPlusPeriod(graph, FinPeriodIDAttribute.PeriodFromDate(graph, s.NextRunDate), (short)s.PeriodFrequency));
break;
case "D":
d.ScheduledDate = FinPeriodIDAttribute.PeriodStartDate(graph, FinPeriodIDAttribute.PeriodFromDate(graph, s.NextRunDate)).AddDays((short)s.PeriodFixedDay - 1);
if (((DateTime)d.ScheduledDate).CompareTo(FinPeriodIDAttribute.PeriodEndDate(graph, FinPeriodIDAttribute.PeriodFromDate(graph, s.NextRunDate))) > 0)
{
d.ScheduledDate = FinPeriodIDAttribute.PeriodEndDate(graph, FinPeriodIDAttribute.PeriodFromDate(graph, s.NextRunDate));
}
DateTime?OldNextRunDate = s.NextRunDate;
s.NextRunDate = FinPeriodIDAttribute.PeriodStartDate(graph, FinPeriodIDAttribute.PeriodPlusPeriod(graph, FinPeriodIDAttribute.PeriodFromDate(graph, s.NextRunDate), (short)s.PeriodFrequency)).AddDays((short)s.PeriodFixedDay - 1);
if (((DateTime)s.NextRunDate).CompareTo(FinPeriodIDAttribute.PeriodEndDate(graph, FinPeriodIDAttribute.PeriodPlusPeriod(graph, FinPeriodIDAttribute.PeriodFromDate(graph, OldNextRunDate), (short)s.PeriodFrequency))) > 0)
{
s.NextRunDate = FinPeriodIDAttribute.PeriodEndDate(graph, FinPeriodIDAttribute.PeriodPlusPeriod(graph, FinPeriodIDAttribute.PeriodFromDate(graph, OldNextRunDate), (short)s.PeriodFrequency));
}
break;
}
}
catch (PXFinPeriodException)
{
if (d.ScheduledDate != null && (bool)s.NoRunLimit == false && s.RunCntr + 1 == s.RunLimit)
{
s.NextRunDate = null;
}
else
{
s.RunCntr = oldRunCntr;
throw;
}
}
break;
case "M":
switch (s.MonthlyDaySel)
{
case "D":
d.ScheduledDate = new PXDateTime((short)((DateTime)s.NextRunDate).Year, (short)((DateTime)s.NextRunDate).Month, (short)s.MonthlyOnDay);
s.NextRunDate = PXDateTime.DatePlusMonthSetDay((DateTime)d.ScheduledDate, (short)s.MonthlyFrequency, (short)s.MonthlyOnDay);
break;
case "W":
d.ScheduledDate = PXDateTime.MakeDayOfWeek((short)((DateTime)s.NextRunDate).Year, (short)((DateTime)s.NextRunDate).Month, (short)s.MonthlyOnWeek, (short)s.MonthlyOnDayOfWeek);
//s.NextRunDate = ((DateTime)d.ScheduledDate).AddMonths((short)s.MonthlyFrequency);
s.NextRunDate = new PXDateTime(((DateTime)d.ScheduledDate).Year, ((DateTime)d.ScheduledDate).Month, 1).AddMonths((short)s.MonthlyFrequency);
s.NextRunDate = PXDateTime.MakeDayOfWeek((short)((DateTime)s.NextRunDate).Year, (short)((DateTime)s.NextRunDate).Month, (short)s.MonthlyOnWeek, (short)s.MonthlyOnDayOfWeek);
break;
}
break;
default:
throw new PXException();
}
} while (d.ScheduledDate == s.LastRunDate);
if (d.ScheduledDate != null &&
((DateTime)d.ScheduledDate).CompareTo(s.StartDate) >= 0 &&
((bool)s.NoEndDate || ((DateTime)d.ScheduledDate).CompareTo(s.EndDate) <= 0) &&
(((DateTime)d.ScheduledDate).CompareTo(runDate) <= 0) &&
((bool)s.NoRunLimit || s.RunCntr < s.RunLimit))
{
try
{
d.ScheduledPeriod = FinPeriodIDAttribute.PeriodFromDate(graph, d.ScheduledDate);
}
catch
{
s.RunCntr = oldRunCntr;
throw;
}
ret.Add(d);
s.RunCntr++;
if ((bool)s.NoRunLimit == false && s.RunCntr >= s.RunLimit ||
(s.NextRunDate != null) && (bool)s.NoEndDate == false && ((DateTime)s.NextRunDate).CompareTo(s.EndDate) > 0)
{
s.Active = false;
s.NextRunDate = null;
}
if (s.NextRunDate == null)
{
break;
}
if (++i >= Times)
{
return(ret);
}
}
else
{
if (d.ScheduledDate != null)
{
s.NextRunDate = d.ScheduledDate;
}
break;
}
} while (true);
return(ret);
}
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 = _financialPeriodProvider.PeriodStartDate(_graph, _financialPeriodProvider.PeriodFromDate(_graph, scheduleParameters.NextRunDate));
scheduleParameters.NextRunDate = _financialPeriodProvider.PeriodStartDate(_graph, _financialPeriodProvider.PeriodPlusPeriod(_graph, _financialPeriodProvider.PeriodFromDate(_graph, scheduleParameters.NextRunDate), (short)scheduleParameters.PeriodFrequency));
break;
case PeriodDateSelOption.PeriodEnd:
occurrence.ScheduledDate = _financialPeriodProvider.PeriodEndDate(_graph, _financialPeriodProvider.PeriodFromDate(_graph, scheduleParameters.NextRunDate));
scheduleParameters.NextRunDate = _financialPeriodProvider.PeriodEndDate(_graph, _financialPeriodProvider.PeriodPlusPeriod(_graph, _financialPeriodProvider.PeriodFromDate(_graph, scheduleParameters.NextRunDate), (short)scheduleParameters.PeriodFrequency));
break;
case PeriodDateSelOption.PeriodFixedDate:
occurrence.ScheduledDate = _financialPeriodProvider.PeriodStartDate(_graph, _financialPeriodProvider.PeriodFromDate(_graph, scheduleParameters.NextRunDate)).AddDays((short)scheduleParameters.PeriodFixedDay - 1);
if (((DateTime)occurrence.ScheduledDate).CompareTo(_financialPeriodProvider.PeriodEndDate(_graph, _financialPeriodProvider.PeriodFromDate(_graph, scheduleParameters.NextRunDate))) > 0)
{
occurrence.ScheduledDate = _financialPeriodProvider.PeriodEndDate(_graph, _financialPeriodProvider.PeriodFromDate(_graph, scheduleParameters.NextRunDate));
}
DateTime?OldNextRunDate = scheduleParameters.NextRunDate;
scheduleParameters.NextRunDate = _financialPeriodProvider.PeriodStartDate(_graph, _financialPeriodProvider.PeriodPlusPeriod(_graph, _financialPeriodProvider.PeriodFromDate(_graph, scheduleParameters.NextRunDate), (short)scheduleParameters.PeriodFrequency)).AddDays((short)scheduleParameters.PeriodFixedDay - 1);
if (((DateTime)scheduleParameters.NextRunDate).CompareTo(_financialPeriodProvider.PeriodEndDate(_graph, _financialPeriodProvider.PeriodPlusPeriod(_graph, _financialPeriodProvider.PeriodFromDate(_graph, OldNextRunDate), (short)scheduleParameters.PeriodFrequency))) > 0)
{
scheduleParameters.NextRunDate = _financialPeriodProvider.PeriodEndDate(_graph, _financialPeriodProvider.PeriodPlusPeriod(_graph, _financialPeriodProvider.PeriodFromDate(_graph, OldNextRunDate), (short)scheduleParameters.PeriodFrequency));
}
break;
}
}
catch (PXFinPeriodException financialPeriodException)
{
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(
financialPeriodException,
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 = _financialPeriodProvider.PeriodFromDate(_graph, occurrence.ScheduledDate);
}
catch (PXFinPeriodException financialPeriodException)
{
scheduleParameters.RunCntr = oldRunCounter;
throw new PXFinPeriodException(
financialPeriodException,
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);
}
