/// <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)); }