/// <summary>
/// Generates a time value that is offset from the time portion of the caller supplied DateTime by a random interval.
/// </summary>
/// <param name="dateTimeToModify">DateTime value to modify.</param>
/// <param name="offsetInterval">Specifies offset time interval (e.g. years, months, days, hours, minutes or seconds).</param>
/// <param name="minOffset">Smallest offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <param name="maxOffset">Maximum offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <returns>Time value that has been offset from the time portion of dateTimeToModify by a random duration. Date is not set in the return value. </returns>
public DateTime OffsetTime(DateTime dateTimeToModify, enRandomOffsetType offsetInterval, int minOffset, int maxOffset)
{
long temp = 0;
DateTime timeToModify = DateTime.Now.Date + dateTimeToModify.TimeOfDay;
return(OffsetDateTime(timeToModify, offsetInterval, minOffset, maxOffset, out temp, enDwDateTimeFormat.enTimeOnly));
}
/// <summary>
/// Generates a date value that is offset from the caller supplied DateTime by a random interval.
/// </summary>
/// <param name="dateTimeToModify">DateTime value to modify.</param>
/// <param name="offsetInterval">Specifies offset time interval (e.g. years, months, days, hours, minutes or seconds).</param>
/// <param name="minOffset">Smallest offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <param name="maxOffset">Maximum offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <returns>DateTime value that has been offset from the dateTimeToModify by a random duration. Time is not set in the return value. </returns>
public DateTime OffsetDate(DateTime dateTimeToModify, enRandomOffsetType offsetInterval, int minOffset, int maxOffset)
{
long temp = 0;
DateTime dateToModify = dateTimeToModify.Date + new TimeSpan(0, 0, 0);
return(OffsetDateTime(dateToModify, offsetInterval, minOffset, maxOffset, out temp, enDwDateTimeFormat.enDateOnly));
}
/// <summary>
/// Generates DateTime values as an array of integers that are offset from the caller supplied DateTime by random intervals.
/// </summary>
/// <param name="dateTimesToModify">Array of DateTime values to modify.</param>
/// <param name="offsetInterval">Specifies offset time interval (e.g. years, months, days, hours, minutes or seconds).</param>
/// <param name="minOffset">Smallest offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <param name="maxOffset">Maximum offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <returns>DateTime values converted to a 64-bit integer array that have been offset from the dateTimesToModify by random durationsNC. Output values are in yyyyMMddHHmmss format.</returns>
public long[] OffsetDateTimeAsInteger(DateTime[] dateTimesToModify, enRandomOffsetType offsetInterval, int minOffset, int maxOffset)
{
long[] dwDateTime = default(long[]);
OffsetDateTime(dateTimesToModify, offsetInterval, minOffset, maxOffset, out dwDateTime, enDwDateTimeFormat.enDateAndTime);
return(dwDateTime);
}
/// <summary>
/// Generates a DateTime value as an integer that is offset from the caller supplied DateTime by a random interval.
/// </summary>
/// <param name="dateTimeToModify">DateTime value to modify.</param>
/// <param name="offsetInterval">Specifies offset time interval (e.g. years, months, days, hours, minutes or seconds).</param>
/// <param name="minOffset">Smallest offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <param name="maxOffset">Maximum offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <returns>DateTime value converted to an integer that has been offset from the dateTimeToModify by a random duration. Output value is in yyyyMMddHHmmss format.</returns>
public long OffsetDateTimeAsInteger(DateTime dateTimeToModify, enRandomOffsetType offsetInterval, int minOffset, int maxOffset)
{
long dwDateTime = 0;
OffsetDateTime(dateTimeToModify, offsetInterval, minOffset, maxOffset, out dwDateTime, enDwDateTimeFormat.enDateAndTime);
return(dwDateTime);
}
/// <summary>
/// Generates a date value as an integer that is offset from the caller supplied DateTime by a random interval.
/// </summary>
/// <param name="dateTimeToModify">DateTime value to modify.</param>
/// <param name="offsetInterval">Specifies offset time interval (e.g. years, months, days, hours, minutes or seconds).</param>
/// <param name="minOffset">Smallest offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <param name="maxOffset">Maximum offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <returns>DateTime value converted to an integer that has been offset from the dateTimeToModify by a random duration. Time is not set in the return value. Output value is in yyyyMMdd format.</returns>
public int OffsetDateAsInteger(DateTime dateTimeToModify, enRandomOffsetType offsetInterval, int minOffset, int maxOffset)
{
long dwDate = 0;
DateTime dateToModify = dateTimeToModify.Date + new TimeSpan(0, 0, 0);
OffsetDateTime(dateToModify, offsetInterval, minOffset, maxOffset, out dwDate, enDwDateTimeFormat.enDateOnly);
return(Convert.ToInt32(dwDate));
}
/// <summary>
/// Generates a time value as an integer that is offset from the time portion of the caller supplied DateTime by a random interval.
/// </summary>
/// <param name="dateTimeToModify">DateTime value to modify.</param>
/// <param name="offsetInterval">Specifies offset time interval (e.g. years, months, days, hours, minutes or seconds).</param>
/// <param name="minOffset">Smallest offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <param name="maxOffset">Maximum offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <returns>Time value converted to an integer that has been offset from the time portion of dateTimeToModify by a random duration. Date is not set in the return value. Output value is in HHmmss format.</returns>
public int OffsetTimeAsInteger(DateTime dateTimeToModify, enRandomOffsetType offsetInterval, int minOffset, int maxOffset)
{
long dwTime = 0;
DateTime timeToModify = DateTime.Now.Date + dateTimeToModify.TimeOfDay;
OffsetDateTime(timeToModify, offsetInterval, minOffset, maxOffset, out dwTime, enDwDateTimeFormat.enTimeOnly);
return(Convert.ToInt32(dwTime));
}
//properties
//methods
/// <summary>
/// Creates a DataTable containing a set of random DateTime values.
/// </summary>
/// <param name="numRows">Num of rows with DateTime values to generate.</param>
/// <param name="dataRequest">RandomDateTimeDataRequest object contains the definition for how to generate the random DateTime values.</param>
/// <returns>ADO.NET DataTable containing the set of random values.</returns>
public DataTable CreateRandomDataTable(int numRows, RandomDateTimeDataRequest dataRequest)
{
DataTable dt = null;
enRandomOffsetType randOffsetType = enRandomOffsetType.enUnknown;
enRandomIncrementType randDateIncrementType = enRandomIncrementType.enUnknown;
enDateConversionType dateConversionType = enDateConversionType.DoNotConvert;
if (dataRequest.ConvertGeneratedValueToInteger)
{
if (dataRequest.ConvertDateTo32BitInteger)
{
dateConversionType = enDateConversionType.ConvertDateTo32bitInt;
}
else if (dataRequest.ConvertTimeTo32BitInteger)
{
dateConversionType = enDateConversionType.ConvertTimeTo32bitInt;
}
else if (dataRequest.ConvertDateTimeTo64BitInteger)
{
dateConversionType = enDateConversionType.ConvertDateTimeTo64bitInt;
}
else
{
dateConversionType = enDateConversionType.DoNotConvert;
}
}
if (dataRequest.RangeOfDates)
{
dt = CreateRangeDataTable(numRows, dataRequest.EarliestDate, dataRequest.LatestDate, dataRequest.SpecifyTimeForEachDay, dataRequest.EarliestTime, dataRequest.LatestTime, dateConversionType);
}
else if (dataRequest.OffsetFromCurrentDate)
{
randOffsetType = GetRandomOffsetType(dataRequest);
dt = CreateOffsetFromCurrentDateDataTable(randOffsetType, numRows, dataRequest.MinimumOffset, dataRequest.MaximumOffset, dataRequest.SpecifyTimeForEachDay, dataRequest.EarliestTime, dataRequest.LatestTime, dateConversionType);
}
else if (dataRequest.OffsetFromDataTableDate)
{
randOffsetType = GetRandomOffsetType(dataRequest);
dt = CreateOffsetFromDataTableDate(randOffsetType, numRows, dataRequest.MinimumOffset, dataRequest.MaximumOffset, dataRequest.SpecifyTimeForEachDay, dataRequest.EarliestTime, dataRequest.LatestTime, dateConversionType);
}
else if (dataRequest.OutputSequentialDates)
{
randDateIncrementType = GetRandomDateIncrementType(dataRequest);
dt = CreateDateSequenceDataTable(randDateIncrementType, numRows, dataRequest.IncrementSize, dataRequest.StartSequentialDate, dataRequest.EndSequentialDate, dataRequest.SpecifyTimeForEachDay, dataRequest.EarliestTime, dataRequest.LatestTime, dataRequest.MinNumDatesPerIncrement, dataRequest.MaxNumDatesPerIncrement, dataRequest.InitStartSequentialDate, dateConversionType);
}
else
{
dt = new DataTable();
}
return(dt);
}
/// <summary>
/// Generates an array of date values that are offset from the caller supplied DateTime by random intervals.
/// </summary>
/// <param name="dateTimesToModify">Array of date values to modify.</param>
/// <param name="offsetInterval">Specifies offset time interval (e.g. years, months, days, hours, minutes or seconds).</param>
/// <param name="minOffset">Smallest offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <param name="maxOffset">Maximum offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <returns>Array of DateTime values that have been offset from the dateTimesToModify by random durations. Time is not set in the return values. </returns>
public DateTime[] OffsetDate(DateTime[] dateTimesToModify, enRandomOffsetType offsetInterval, int minOffset, int maxOffset)
{
long[] temp = default(long[]);
DateTime[] datesToModify = new DateTime[dateTimesToModify.Length];
for (int i = 0; i < dateTimesToModify.Length; i++)
{
datesToModify[i] = dateTimesToModify[i].Date + new TimeSpan(0, 0, 0);
}
return(OffsetDateTime(datesToModify, offsetInterval, minOffset, maxOffset, out temp, enDwDateTimeFormat.enDateOnly));
}
/// <summary>
/// Generates an array of time values that are offset from the time portion of the caller supplied DateTime array by random intervals.
/// </summary>
/// <param name="dateTimesToModify">Array of time values to modify.</param>
/// <param name="offsetInterval">Specifies offset time interval (e.g. years, months, days, hours, minutes or seconds).</param>
/// <param name="minOffset">Smallest offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <param name="maxOffset">Maximum offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <returns>Array of time values that have been offset from the time portion of dateTimesToModify by random durations. Date is not set in the return values. </returns>
public DateTime[] OffsetTime(DateTime[] dateTimesToModify, enRandomOffsetType offsetInterval, int minOffset, int maxOffset)
{
long[] temp = default(long[]);
DateTime[] timesToModify = new DateTime[dateTimesToModify.Length];
for (int i = 0; i < dateTimesToModify.Length; i++)
{
timesToModify[i] = DateTime.Now.Date + dateTimesToModify[i].TimeOfDay;
}
return(OffsetDateTime(timesToModify, offsetInterval, minOffset, maxOffset, out temp, enDwDateTimeFormat.enTimeOnly));
}
private enRandomOffsetType GetRandomOffsetType(RandomDateTimeDataRequest dataRequest)
{
enRandomOffsetType offsetType = enRandomOffsetType.enUnknown;
if (dataRequest.YearsOffset)
{
offsetType = enRandomOffsetType.enYears;
}
else if (dataRequest.MonthsOffset)
{
offsetType = enRandomOffsetType.enMonths;
}
else
{
//DaysOffset
offsetType = enRandomOffsetType.enDays;
}
return(offsetType);
}
/// <summary>
/// Generates an array of time values as integers that are offset from the time portion of the caller supplied dateTimesToModify by random intervals.
/// </summary>
/// <param name="dateTimesToModify">Array of time values to modify.</param>
/// <param name="offsetInterval">Specifies offset time interval (e.g. years, months, days, hours, minutes or seconds).</param>
/// <param name="minOffset">Smallest offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <param name="maxOffset">Maximum offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <returns>Array of time values converted to an array of 32-bit integers that have been offset from the time portion of dateTimesToModify by random durations. Date is not set in the return value. Return values are in HHmmss format.</returns>
public int[] OffsetTimeAsInteger(DateTime[] dateTimesToModify, enRandomOffsetType offsetInterval, int minOffset, int maxOffset)
{
long[] temp = new long[dateTimesToModify.Length];
int[] dwTime = new int[dateTimesToModify.Length];
DateTime[] timesToModify = new DateTime[dateTimesToModify.Length];
for (int i = 0; i < dateTimesToModify.Length; i++)
{
timesToModify[i] = DateTime.Now.Date + dateTimesToModify[i].TimeOfDay;
}
OffsetDateTime(timesToModify, offsetInterval, minOffset, maxOffset, out temp, enDwDateTimeFormat.enTimeOnly);
for (int i = 0; i < dateTimesToModify.Length; i++)
{
dwTime[i] = Convert.ToInt32(temp[i]);
}
return(dwTime);
}
/// <summary>
/// Generates an array of date values as a integers that are offset from the caller supplied DateTime by random intervals.
/// </summary>
/// <param name="dateTimesToModify">Array of date values to modify.</param>
/// <param name="offsetInterval">Specifies offset time interval (e.g. years, months, days, hours, minutes or seconds).</param>
/// <param name="minOffset">Smallest offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <param name="maxOffset">Maximum offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <returns>Array of date values converted to a 32-bit integer array. Values have been offset from the dateTimesToModify by random durations. Time is not set in the return values. Output values are in yyyyMMdd format.</returns>
public int[] OffsetDateAsInteger(DateTime[] dateTimesToModify, enRandomOffsetType offsetInterval, int minOffset, int maxOffset)
{
long[] temp = new long[dateTimesToModify.Length];
int[] dwDate = new int[dateTimesToModify.Length];
DateTime[] datesToModify = new DateTime[dateTimesToModify.Length];
for (int i = 0; i < dateTimesToModify.Length; i++)
{
datesToModify[i] = dateTimesToModify[i].Date + new TimeSpan(0, 0, 0);
}
OffsetDateTime(datesToModify, offsetInterval, minOffset, maxOffset, out temp, enDwDateTimeFormat.enDateOnly);
for (int i = 0; i < dateTimesToModify.Length; i++)
{
dwDate[i] = Convert.ToInt32(temp[i]);
}
return(dwDate);
}
private DateTime[] OffsetDateTime(DateTime[] dateTimesToModify, enRandomOffsetType offsetInterval, int minOffset, int maxOffset, out long[] dwDateTime, enDwDateTimeFormat dwDtFormat)
{
DateTime[] dtm = new DateTime[dateTimesToModify.Length];
DateTime[] retDtm = new DateTime[dateTimesToModify.Length];
dwDateTime = new long[dateTimesToModify.Length];
DateTime minDt = DateTime.MinValue;
DateTime maxDt = DateTime.MaxValue;
double minDays = 0.0;
double maxDays = 0.0;
double minSeconds = 0.9;
double maxSeconds = 0.0;
double randNum = 0.0;
for (int i = 0; i < dateTimesToModify.Length; i++)
{
switch (offsetInterval)
{
case enRandomOffsetType.enYears:
minDt = dateTimesToModify[i].AddYears(minOffset);
maxDt = dateTimesToModify[i].AddYears(maxOffset);
break;
case enRandomOffsetType.enMonths:
minDt = dateTimesToModify[i].AddMonths(minOffset);
maxDt = dateTimesToModify[i].AddMonths(maxOffset);
break;
case enRandomOffsetType.enDays:
minDt = dateTimesToModify[i].AddDays(minOffset);
maxDt = dateTimesToModify[i].AddDays(maxOffset);
break;
case enRandomOffsetType.enHours:
minDt = dateTimesToModify[i].AddHours(minOffset);
maxDt = dateTimesToModify[i].AddHours(maxOffset);
break;
case enRandomOffsetType.enMinutes:
minDt = dateTimesToModify[i].AddMinutes(minOffset);
maxDt = dateTimesToModify[i].AddMinutes(maxOffset);
break;
case enRandomOffsetType.enSeconds:
minDt = dateTimesToModify[i].AddSeconds(minOffset);
maxDt = dateTimesToModify[i].AddSeconds(maxOffset);
break;
default:
minDt = dateTimesToModify[i];
maxDt = dateTimesToModify[i];
break;
}
minDays = minDt.Subtract(DateTime.MinValue).TotalDays;
maxDays = maxDt.Subtract(DateTime.MinValue).TotalDays;
minSeconds = minDt.Subtract(DateTime.MinValue).TotalSeconds;
maxSeconds = maxDt.Subtract(DateTime.MinValue).TotalSeconds;
switch (offsetInterval)
{
case enRandomOffsetType.enYears:
case enRandomOffsetType.enMonths:
case enRandomOffsetType.enDays:
randNum = _rn.GenerateRandomNumber(minDays, maxDays);
dtm[i] = DateTime.MinValue.AddDays(randNum);
break;
case enRandomOffsetType.enHours:
case enRandomOffsetType.enMinutes:
case enRandomOffsetType.enSeconds:
randNum = _rn.GenerateRandomNumber(minSeconds, maxSeconds);
dtm[i] = DateTime.MinValue.AddSeconds(randNum);
break;
default:
dtm = dateTimesToModify;
break;
}
switch (dwDtFormat)
{
case enDwDateTimeFormat.enDateAndTime:
dwDateTime[i] = Convert.ToInt64(dtm[i].ToString("yyyyMMddHHmmss"));
retDtm[i] = dtm[i];
break;
case enDwDateTimeFormat.enDateOnly:
dwDateTime[i] = Convert.ToInt64(dtm[i].ToString("yyyyMMdd"));
retDtm[i] = dtm[i].Date + new TimeSpan(0, 0, 0);
break;
case enDwDateTimeFormat.enTimeOnly:
dwDateTime[i] = Convert.ToInt64(dtm[i].ToString("HHmmss"));
retDtm[i] = DateTime.Now.Date + dtm[i].TimeOfDay;
break;
default:
dwDateTime[i] = Convert.ToInt64(dtm[i].ToString("yyyyMMddHHmmss"));
retDtm[i] = dtm[i];
break;
}
}
return(retDtm);
}
/// <summary>
/// Routines for testing date/time offset processing.
/// </summary>
/// <param name="offsetType">enRandomOffsetType enum that determines type of offset to generate (seconds, minutes, hours, days or years).</param>
/// <param name="numRows">Number of random offsets to generate.</param>
/// <param name="minimumOffset">Minimum offset number. </param>
/// <param name="maximumOffset">Maximum offset number.</param>
/// <param name="generateRandomTime">Set to true to generate a time for the random offset.</param>
/// <param name="fromTime">Minium time to generate.</param>
/// <param name="toTime">Maximum time to generate.</param>
/// <param name="dateConversionType">Determines whether or not to convert the DateTime value to an integer. Useful for data warehousing scenarios.</param>
/// <returns>ADO.NET DataTable containing the set of random values. First column contains a date/time that has been offset from the base value stored in the second column (this is a stand-in for the a value that might be found in a database table or an application. </returns>
public DataTable CreateOffsetPreviewDataTable(enRandomOffsetType offsetType, int numRows, string minimumOffset, string maximumOffset, bool generateRandomTime, string fromTime, string toTime, enDateConversionType dateConversionType)
{
DataTable dt = new DataTable();
DateTime currDate = DateTime.Now;
DateTime minDate = DateTime.MinValue;
DateTime maxDate = DateTime.MaxValue;
try
{
DataColumn dc = new DataColumn("RandomValue");
//dc.DataType = Type.GetType("System.DateTime");
switch (dateConversionType)
{
case enDateConversionType.DoNotConvert:
dc.DataType = Type.GetType("System.DateTime");
break;
case enDateConversionType.ConvertDateTo32bitInt:
dc.DataType = Type.GetType("System.Int32");
break;
case enDateConversionType.ConvertTimeTo32bitInt:
dc.DataType = Type.GetType("System.Int32");
break;
case enDateConversionType.ConvertDateTimeTo64bitInt:
dc.DataType = Type.GetType("System.Int64");
break;
default:
dc.DataType = Type.GetType("System.DateTime");
break;
}
dt.Columns.Add(dc);
DataColumn dc2 = new DataColumn("CurrentDate");
dc2.DataType = Type.GetType("System.DateTime");
dt.Columns.Add(dc2);
//DataColumn dc3 = new DataColumn("RandomNum");
//dc3.DataType = Type.GetType("System.Int32");
//dt.Columns.Add(dc3);
//DataColumn dc4 = new DataColumn("MinDays");
//dc4.DataType = Type.GetType("System.Int32");
//dt.Columns.Add(dc4);
//DataColumn dc5 = new DataColumn("MaxDays");
//dc5.DataType = Type.GetType("System.Int32");
//dt.Columns.Add(dc5);
//DataColumn dc6 = new DataColumn("nRowNum");
//dc6.DataType = Type.GetType("System.Int32");
//dt.Columns.Add(dc6);
for (int i = 0; i < numRows; i++)
{
double minOffset = Convert.ToDouble(minimumOffset);
double maxOffset = Convert.ToDouble(maximumOffset);
currDate = _rv.GenerateRandomDate(Convert.ToDateTime("01/01/1900"), Convert.ToDateTime("12/31/2029"));
minDate = DateTime.MinValue;
maxDate = DateTime.MaxValue;
if (offsetType == enRandomOffsetType.enYears)
{
minDate = currDate.AddYears((int)minOffset);
maxDate = currDate.AddYears((int)maxOffset);
}
else if (offsetType == enRandomOffsetType.enMonths)
{
minDate = currDate.AddMonths((int)minOffset);
maxDate = currDate.AddMonths((int)maxOffset);
}
else if (offsetType == enRandomOffsetType.enDays)
{
minDate = currDate.AddDays((int)minOffset);
maxDate = currDate.AddDays((int)maxOffset);
}
else
{
_msg.Length = 0;
_msg.Append("Unable to process offset type passed to CreateOffsetFromDataTableDate routine.");
throw new System.Exception(_msg.ToString());
}
TimeSpan fromTimeTs = generateRandomTime ? Convert.ToDateTime(fromTime).TimeOfDay : Convert.ToDateTime("01/01/2000 00:00:00").TimeOfDay;
TimeSpan toTimeTs = generateRandomTime ? Convert.ToDateTime(toTime).TimeOfDay : Convert.ToDateTime("01/01/2000 23:59:59").TimeOfDay;
double fromSeconds = fromTimeTs.TotalSeconds;
double toSeconds = toTimeTs.TotalSeconds;
DataRow dr = dt.NewRow();
int minDays = (int)minDate.Subtract(DateTime.MinValue).TotalDays;
int maxDays = (int)maxDate.Subtract(DateTime.MinValue).TotalDays;
int randNum = _rn.GenerateRandomInt(minDays, maxDays);
randNum = _rn.GenerateRandomInt(minDays, maxDays); //Second random number is a workaround that fixes problem of random numbers
//sequencing from low to high based on earliest to latest dates.
//(Jan. 2015: Do not know what is causing sequencing to occur.)
//(Guess: might be related to GenerateRandomDate above.)
//int randNum = _rn.GenerateRandomInt(689948, 697252); //test
int saveRandNum = randNum;
TimeSpan ts = new TimeSpan(randNum, 0, 0, 0, 0);
DateTime dtm = DateTime.MinValue.Add(ts);
if (generateRandomTime)
{
randNum = _rn.GenerateRandomInt((int)fromSeconds, (int)toSeconds);
TimeSpan ts2 = new TimeSpan(0, 0, 0, randNum, 0);
dtm = dtm.AddSeconds(ts2.TotalSeconds);
}
//dr[0] = dtm;
switch (dateConversionType)
{
case enDateConversionType.DoNotConvert:
dr[0] = dtm;
break;
case enDateConversionType.ConvertDateTo32bitInt:
dr[0] = Convert.ToInt32(dtm.ToString("yyyyMMdd"));
break;
case enDateConversionType.ConvertTimeTo32bitInt:
dr[0] = Convert.ToInt32(dtm.ToString("HHmmss"));
break;
case enDateConversionType.ConvertDateTimeTo64bitInt:
dr[0] = Convert.ToInt64(dtm.ToString("yyyyMMddHHmmss"));
break;
default:
dr[0] = dtm;
break;
}
dr[1] = currDate;
//dr[2] = saveRandNum;
//dr[3] = minDays;
//dr[4] = maxDays;
//dr[5] = i;
dt.Rows.Add(dr);
}
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append("Error in CreateOffsetFromDataTableDate routine.\r\n");
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
throw new System.Exception(_msg.ToString());
}
finally
{
;
}
return(dt);
}
/// <summary>
/// Generates a DateTime value that is offset from the caller supplied DateTime by a random interval.
/// </summary>
/// <param name="dateTimeToModify">DateTime value to modify.</param>
/// <param name="offsetInterval">Specifies offset time interval (e.g. years, months, days, hours, minutes or seconds).</param>
/// <param name="minOffset">Smallest offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <param name="maxOffset">Maximum offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <returns>DateTime value that has been offset from the dateTimeToModify by a random duration.</returns>
public DateTime OffsetDateTime(DateTime dateTimeToModify, enRandomOffsetType offsetInterval, int minOffset, int maxOffset)
{
long temp = 0;
return(OffsetDateTime(dateTimeToModify, offsetInterval, minOffset, maxOffset, out temp, enDwDateTimeFormat.enDateAndTime));
}
/// <summary>
/// Routines for generating dates that are offset from the current date/time value.
/// </summary>
/// <param name="offsetType">enRandomOffsetType enum that determines type of offset to generate (seconds, minutes, hours, days or years).</param>
/// <param name="numRows">Number of random offsets to generate.</param>
/// <param name="minimumOffset">Minimum offset number. </param>
/// <param name="maximumOffset">Maximum offset number.</param>
/// <param name="generateRandomTime">Set to true to generate a time for the random offset.</param>
/// <param name="fromTime">Minium time to generate.</param>
/// <param name="toTime">Maximum time to generate.</param>
/// <param name="dateConversionType">Determines whether or not to convert the DateTime value to an integer. Useful for data warehousing scenarios.</param>
/// <returns>ADO.NET DataTable containing the set of random values. First column of the result set contains a date that has been offset from current date.</returns>
public DataTable CreateOffsetFromCurrentDateDataTable(enRandomOffsetType offsetType, int numRows, string minimumOffset, string maximumOffset, bool generateRandomTime, string fromTime, string toTime, enDateConversionType dateConversionType)
{
DataTable dt = new DataTable();
try
{
double minOffset = Convert.ToDouble(minimumOffset);
double maxOffset = Convert.ToDouble(maximumOffset);
TimeSpan currDateTs = DateTime.Now.Subtract(DateTime.MinValue);
double currDateDays = currDateTs.TotalDays;
double minOffsetDays = currDateDays + minOffset;
double maxOffsetDays = currDateDays + maxOffset;
if (offsetType == enRandomOffsetType.enYears)
{
DateTime tempDtm = DateTime.Now.AddYears((int)minOffset);
minOffsetDays = tempDtm.Subtract(DateTime.MinValue).TotalDays;
tempDtm = DateTime.Now.AddYears((int)maxOffset);
maxOffsetDays = tempDtm.Subtract(DateTime.MinValue).TotalDays;
}
else if (offsetType == enRandomOffsetType.enMonths)
{
DateTime tempDtm = DateTime.Now.AddMonths((int)minOffset);
minOffsetDays = tempDtm.Subtract(DateTime.MinValue).TotalDays;
tempDtm = DateTime.Now.AddMonths((int)maxOffset);
maxOffsetDays = tempDtm.Subtract(DateTime.MinValue).TotalDays;
}
else if (offsetType == enRandomOffsetType.enDays)
{
//minOffset and maxOffset already specify days
minOffsetDays = currDateDays + minOffset;
maxOffsetDays = currDateDays + maxOffset;
}
else
{
_msg.Length = 0;
_msg.Append("Unable to process offset type passed to CreateOffsetFromDataTableDate routine.");
throw new System.Exception(_msg.ToString());
}
TimeSpan fromTimeTs = generateRandomTime ? Convert.ToDateTime(fromTime).TimeOfDay : Convert.ToDateTime("01/01/2000 00:00:00").TimeOfDay;
TimeSpan toTimeTs = generateRandomTime ? Convert.ToDateTime(toTime).TimeOfDay : Convert.ToDateTime("01/01/2000 23:59:59").TimeOfDay;
double fromSeconds = fromTimeTs.TotalSeconds;
double toSeconds = toTimeTs.TotalSeconds;
DataColumn dc = new DataColumn("RandomValue");
//dc.DataType = Type.GetType("System.DateTime");
switch (dateConversionType)
{
case enDateConversionType.DoNotConvert:
dc.DataType = Type.GetType("System.DateTime");
break;
case enDateConversionType.ConvertDateTo32bitInt:
dc.DataType = Type.GetType("System.Int32");
break;
case enDateConversionType.ConvertTimeTo32bitInt:
dc.DataType = Type.GetType("System.Int32");
break;
case enDateConversionType.ConvertDateTimeTo64bitInt:
dc.DataType = Type.GetType("System.Int64");
break;
default:
dc.DataType = Type.GetType("System.DateTime");
break;
}
dt.Columns.Add(dc);
DataColumn dc2 = new DataColumn("OffsetDays");
dc2.DataType = Type.GetType("System.Int32");
dt.Columns.Add(dc2);
for (int i = 0; i < numRows; i++)
{
DataRow dr = dt.NewRow();
Double randNum = _rn.GenerateRandomNumber(minOffsetDays, maxOffsetDays);
TimeSpan ts = new TimeSpan((int)randNum, 0, 0, 0, 0);
DateTime dtm = DateTime.MinValue.Add(ts);
if (generateRandomTime)
{
randNum = _rn.GenerateRandomNumber(fromSeconds, toSeconds);
TimeSpan ts2 = new TimeSpan(0, 0, 0, (int)randNum, 0);
dtm = dtm.AddSeconds(ts2.TotalSeconds);
}
TimeSpan offsetTs = dtm.Subtract(DateTime.Now);
int offset = Convert.ToInt32(offsetTs.TotalDays);
//dr[0] = dtm;
switch (dateConversionType)
{
case enDateConversionType.DoNotConvert:
dr[0] = dtm;
break;
case enDateConversionType.ConvertDateTo32bitInt:
dr[0] = Convert.ToInt32(dtm.ToString("yyyyMMdd"));
break;
case enDateConversionType.ConvertTimeTo32bitInt:
dr[0] = Convert.ToInt32(dtm.ToString("HHmmss"));
break;
case enDateConversionType.ConvertDateTimeTo64bitInt:
dr[0] = Convert.ToInt64(dtm.ToString("yyyyMMddHHmmss"));
break;
default:
dr[0] = dtm;
break;
}
dr[1] = offset;
dt.Rows.Add(dr);
}
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append("Error in CreateOffsetFromDataTableDate routine.\r\n");
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
throw new System.Exception(_msg.ToString());
}
finally
{
;
}
return(dt);
}
/// <summary>
/// Generates an array DateTime values that are offset from the caller supplied DateTime by random intervals.
/// </summary>
/// <param name="dateTimesToModify">Array of DateTime values to modify.</param>
/// <param name="offsetInterval">Specifies offset time interval (e.g. years, months, days, hours, minutes or seconds).</param>
/// <param name="minOffset">Smallest offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <param name="maxOffset">Maximum offset. Specify negative numbers to specify offsets that generate earlier dates.</param>
/// <returns>Array of DateTime values that have been offset from the dateTimesToModify by random durations.</returns>
public DateTime[] OffsetDateTime(DateTime[] dateTimesToModify, enRandomOffsetType offsetInterval, int minOffset, int maxOffset)
{
long[] temp = default(long[]);
return(OffsetDateTime(dateTimesToModify, offsetInterval, minOffset, maxOffset, out temp, enDwDateTimeFormat.enDateAndTime));
}
