private PFList <RandomName> GetCurrentRandomNames(PFList <DataTableRandomizerColumnSpec> colSpecs, PFList <PFList <RandomName> > randomNameLists)
{
PFList <RandomName> currentRandomNames = new PFList <RandomName>();
currentRandomNames.Clear();
for (int nameInx = 0; nameInx < randomNameLists.Count; nameInx++)
{
PFList <RandomName> randNames = randomNameLists[nameInx];
int randNum = _randNumber.GenerateRandomInt(0, randNames.Count - 1);
RandomName randName = randNames[randNum];
currentRandomNames.Add(randName);
}
for (int specInx = 0; specInx < colSpecs.Count; specInx++)
{
DataTableRandomizerColumnSpec spec = colSpecs[specInx];
//if (spec.RandomDataType == enRandomDataType.RandomNamesAndLocationsFile)
//{
// spec.CurrentValueIndex = spec.RandomDataListIndex;
//}
}
return(currentRandomNames);
}
public void RandomDocumentTest(int minNumParagraphs, int maxNumParagraphs, int minNumSentencesPerParagraph, int maxNumSentencesPerParagraph, string documentSubject)
{
RandomNumber rn = new RandomNumber();
RandomDocument rd = new RandomDocument();
int numParagraphs = 0;
string doc = string.Empty;
try
{
_msg.Length = 0;
_msg.Append("RandomDocumentTest started ...\r\n");
Program._messageLog.WriteLine(_msg.ToString());
_str.Length = 0;
numParagraphs = rn.GenerateRandomInt(minNumParagraphs, maxNumParagraphs);
doc = rd.GenerateDocument(numParagraphs, minNumSentencesPerParagraph, maxNumSentencesPerParagraph, documentSubject);
_str.Append(doc);
Program._messageLog.WriteLine(_str.ToString());
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
Program._messageLog.WriteLine(_msg.ToString());
AppMessages.DisplayErrorMessage(_msg.ToString(), _saveErrorMessagesToAppLog);
}
finally
{
_msg.Length = 0;
_msg.Append("\r\n... RandomDocumentTest finished.");
Program._messageLog.WriteLine(_msg.ToString());
}
}
/// <summary>
/// Generates random strings containing repeating characters.
/// </summary>
/// <param name="randStringType">enRandomStringType enumeration used to define output format.</param>
/// <param name="numRows">Number of DataTable rows to generate containing random strings.</param>
/// <param name="minRepeatOutputLength">Minimum number of times character is repeated.</param>
/// <param name="maxRepeatOutputLength">Maximum number of times character is repeated.</param>
/// <param name="minNumRepeats">Minimum number of strings containing repeating characters to generate for each output row.</param>
/// <param name="maxNumRepeats">Minimum number of strings containing repeating characters to generate for each output row.</param>
/// <returns>ADO.NET DataTable containing the generated strings with repeating characgters.</returns>
public DataTable CreateRandomRepeatingCharacterDataTable(enRandomStringType randStringType, int numRows, string minRepeatOutputLength, string maxRepeatOutputLength, string minNumRepeats, string maxNumRepeats)
{
DataTable dt = new DataTable();
RandomNumber rn = new RandomNumber();
StringBuilder randString = new StringBuilder();
try
{
int minimumRepeatOutputLength = Convert.ToInt32(minRepeatOutputLength);
int maximumRepeatOutputLength = Convert.ToInt32(maxRepeatOutputLength);
int minimumNumberOfRepeats = Convert.ToInt32(minNumRepeats);
int maximumNumberOfRepeats = Convert.ToInt32(maxNumRepeats);
DataColumn dc = new DataColumn("RandomValue");
dc.DataType = Type.GetType("System.String");
dt.Columns.Add(dc);
for (int i = 0; i < numRows; i++)
{
DataRow dr = dt.NewRow();
int numStrings = rn.GenerateRandomInt(minimumNumberOfRepeats, maximumNumberOfRepeats);
randString.Length = 0;
for (int s = 0; s < numStrings; s++)
{
int size = rn.GenerateRandomInt(minimumRepeatOutputLength, maximumRepeatOutputLength);
string str = getRandomRepeatedCharacter[(int)randStringType](size);
randString.Append(str);
randString.Append(" ");
}
dr[0] = randString.ToString();
dt.Rows.Add(dr);
}
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append("Error in CreateRandomRepeatingCharacterDataTable routine.\r\n");
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
throw new System.Exception(_msg.ToString());
}
finally
{
;
}
return(dt);
}
public void RandomParagraphsTest(int minNumParagraphs, int maxNumParagraphs, int minNumSentencesPerParagraph, int maxNumSentencesPerParagraph)
{
RandomNumber rn = new RandomNumber();
RandomDocument rd = new RandomDocument();
int numParagraphs = 0;
int numSentences = 0;
string paragraph = string.Empty;
try
{
_msg.Length = 0;
_msg.Append("RandomParagraphsTest started ...\r\n");
Program._messageLog.WriteLine(_msg.ToString());
_str.Length = 0;
numParagraphs = rn.GenerateRandomInt(minNumParagraphs, maxNumParagraphs);
for (int p = 0; p < numParagraphs; p++)
{
numSentences = rn.GenerateRandomInt(minNumSentencesPerParagraph, maxNumSentencesPerParagraph);
paragraph = rd.GenerateParagraph(numSentences);
_str.Append(paragraph);
_str.Append(Environment.NewLine);
_str.Append(Environment.NewLine);
}
Program._messageLog.WriteLine(_str.ToString());
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
Program._messageLog.WriteLine(_msg.ToString());
AppMessages.DisplayErrorMessage(_msg.ToString(), _saveErrorMessagesToAppLog);
}
finally
{
_msg.Length = 0;
_msg.Append("\r\n... RandomParagraphsTest finished.");
Program._messageLog.WriteLine(_msg.ToString());
}
}
/// <summary>
/// Creates a DataTable containing a set of random char array values. Includes extra data (string and hex representations) for displaying the char array on a form with a grid.
/// </summary>
/// <param name="numRows">Num of rows with char array values to generate.</param>
/// <param name="minArrayLength">Minimum length for each generated char array.</param>
/// <param name="maxArrayLength">Maximum length for each generated char array.</param>
/// <returns>ADO.NET DataTable containing the set of random values.</returns>
/// <remarks>This routine shows the generated char arrays in alternate string and hex formats.</remarks>
public DataTable CreateCharArrayPreviewDataTable(int numRows, string minArrayLength, string maxArrayLength)
{
DataTable dt = new DataTable();
RandomNumber rn = new RandomNumber();
RandomBytes rb = new RandomBytes();
try
{
int minimumArrayLength = Convert.ToInt32(minArrayLength);
int maximumArrayLength = Convert.ToInt32(maxArrayLength);
DataColumn dc0 = new DataColumn("RandomValue");
dc0.DataType = Type.GetType("System.String");
//dc0.DataType = Type.GetType("System.Char[]"); //Grid displays no column for System.Char[]
dt.Columns.Add(dc0);
DataColumn dc1 = new DataColumn("StringRepresentation");
dc1.DataType = Type.GetType("System.String");
dt.Columns.Add(dc1);
DataColumn dc2 = new DataColumn("HexRepresentation");
dc2.DataType = Type.GetType("System.String");
dt.Columns.Add(dc2);
for (int i = 0; i < numRows; i++)
{
DataRow dr = dt.NewRow();
int arrayLength = rn.GenerateRandomInt(minimumArrayLength, maximumArrayLength);
char[] c = rb.GenerateRandomChars(arrayLength);
string s1 = PFTextObjects.PFTextProcessor.ConvertCharArrayToString(c);
string s2 = PFTextObjects.PFTextProcessor.ConvertCharArrayToHexString(c);
dr[0] = "System.Char[] Array";
dr[1] = s1;
dr[2] = s2;
dt.Rows.Add(dr);
}
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append("Error in CreateCharArrayPreviewDataTable routine.\r\n");
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
throw new System.Exception(_msg.ToString());
}
finally
{
;
}
return(dt);
}
public void RandomSentencesTest(int minNumSentences, int maxNumSentences)
{
RandomNumber rn = new RandomNumber();
RandomSentence rs = new RandomSentence();
int numSentences = 0;
try
{
_msg.Length = 0;
_msg.Append("RandomSentencesTest started ...\r\n");
Program._messageLog.WriteLine(_msg.ToString());
numSentences = rn.GenerateRandomInt(minNumSentences, maxNumSentences);
for (int i = 0; i < numSentences; i++)
{
_msg.Length = 0;
_msg.Append((i + 1).ToString());
_msg.Append(": ");
_msg.Append(rs.GenerateSentence());
Program._messageLog.WriteLine(_msg.ToString());
}
_msg.Length = 0;
_msg.Append("\r\nAll:\r\n");
_msg.Append(rs.GenerateSentences(numSentences));
Program._messageLog.WriteLine(_msg.ToString());
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
Program._messageLog.WriteLine(_msg.ToString());
AppMessages.DisplayErrorMessage(_msg.ToString(), _saveErrorMessagesToAppLog);
}
finally
{
_msg.Length = 0;
_msg.Append("\r\n... RandomSentencesTest finished.");
Program._messageLog.WriteLine(_msg.ToString());
}
}
private string GetAreaCode(enCountry country)
{
string areaCode = string.Empty;
double minValue = 1.0;
double maxValue = 100.0;
if (country == enCountry.UnitedStates)
{
areaCode = "000";
}
else if (country == enCountry.Canada)
{
areaCode = "000";
}
else if (country == enCountry.Mexico)
{
Double randNum = _rn.GenerateRandomNumber(minValue, maxValue);
if (randNum < 25.0)
{
areaCode = "55";
}
else if (randNum < 50.0)
{
areaCode = "81";
}
else if (randNum < 75.0)
{
areaCode = "33";
}
else
{
areaCode = _rn.GenerateRandomInt(100, 899).ToString("000");
}
}
else
{
areaCode = "000";
}
return(areaCode);
}
/// <summary>
/// Creates a DataTable containing a set of random byte array values.
/// </summary>
/// <param name="numRows">Num of rows with byte array values to generate.</param>
/// <param name="minArrayLength">Minimum length for each generated byte array.</param>
/// <param name="maxArrayLength">Maximum length for each generated byte array.</param>
/// <returns>ADO.NET DataTable containing the set of random values.</returns>
public DataTable CreateByteArrayDataTable(int numRows, string minArrayLength, string maxArrayLength)
{
DataTable dt = new DataTable();
RandomNumber rn = new RandomNumber();
RandomBytes rb = new RandomBytes();
try
{
int minimumArrayLength = Convert.ToInt32(minArrayLength);
int maximumArrayLength = Convert.ToInt32(maxArrayLength);
DataColumn dc0 = new DataColumn("RandomValue");
dc0.DataType = Type.GetType("System.Byte[]");
dt.Columns.Add(dc0);
for (int i = 0; i < numRows; i++)
{
DataRow dr = dt.NewRow();
int arrayLength = rn.GenerateRandomInt(minimumArrayLength, maximumArrayLength);
byte[] b = rb.GenerateRandomBytes(arrayLength);
dr[0] = b;
dt.Rows.Add(dr);
}
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append("Error in CreateByteArrayDataTable routine.\r\n");
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
throw new System.Exception(_msg.ToString());
}
finally
{
;
}
return(dt);
}
/// <summary>
/// Routine to create random sentences.
/// </summary>
/// <param name="numRows">Number of output data rows containing random sentences.</param>
/// <param name="minNumSentences">Minimum number of random sentences per data row.</param>
/// <param name="maxNumSentences">Maximum number of random sentences per data row.</param>
/// <returns>ADO.NET DataTable containing the random sentences.</returns>
public DataTable CreateRandomSentencesDataTable(int numRows, string minNumSentences, string maxNumSentences)
{
DataTable dt = new DataTable();
RandomNumber rn = new RandomNumber();
RandomSentence randSentence = new RandomSentence();
try
{
int minimumNumberOfSentences = Convert.ToInt32(minNumSentences);
int maximumNumberOfSentences = Convert.ToInt32(maxNumSentences);
DataColumn dc = new DataColumn("RandomValue");
dc.DataType = Type.GetType("System.String");
dt.Columns.Add(dc);
for (int i = 0; i < numRows; i++)
{
DataRow dr = dt.NewRow();
int numSentences = rn.GenerateRandomInt(minimumNumberOfSentences, maximumNumberOfSentences);
string str = randSentence.GenerateSentences(numSentences);
dr[0] = str;
dt.Rows.Add(dr);
}
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append("Error in CreateRandomSentencesDataTable routine.\r\n");
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
throw new System.Exception(_msg.ToString());
}
finally
{
;
}
return(dt);
}
public static void DelimitedLineTextFileTests(int numRowsToOutput)
{
PFTextFile textFile = new PFTextFile(@"c:\temp\DelimitedText.txt", PFFileOpenOperation.OpenFileForWrite);
PFDelimitedDataLine line = new PFDelimitedDataLine(5);
RandomString dat = new RandomString();
RandomNumber siz = new RandomNumber();
int num = 0;
string str = string.Empty;
try
{
line.LineTerminator = "\r\n";
line.ColumnSeparator = ",";
line.SetColumnDefinition(0, "FirstColumn", 10);
line.SetColumnDefinition(1, "SecondColumn", 15);
line.SetColumnDefinition(2, "ColumnThree", 5);
line.SetColumnDefinition(3, "ColumnFour", 35);
line.SetColumnDefinition(4, "FifthColumn", 25);
textFile.WriteData(line.OutputColumnNames());
for (int rowNum = 0; rowNum < numRowsToOutput; rowNum++)
{
for (int inx = 0; inx < 5; inx++)
{
num = siz.GenerateRandomInt(1, line.ColumnDefinitions.ColumnDefinition[inx].ColumnLength);
str = dat.GetStringAL(num);
line.ColumnData.ColumnDataValue[inx].Data = str;
}
textFile.WriteData(line.OutputColumnData());
}
textFile.CloseFile();
line.SaveToXmlFile(@"c:\temp\DelimitedText.xml");
//read textfile
textFile.OpenFile(@"c:\temp\DelimitedText.txt", PFFileOpenOperation.OpenFileToRead);
string input = textFile.ReadLine();
line.VerifyColumnNames(input);
Program._messageLog.WriteLine(line.ColumnDefinitions.ToString());
input = textFile.ReadLine();
line.ParseData(input);
Program._messageLog.WriteLine(line.ColumnData.ToString());
textFile.CloseFile();
//double check loading of xml schema works
PFDelimitedDataLine line2 = PFDelimitedDataLine.LoadFromXmlFile(@"c:\temp\DelimitedText.xml");
Program._messageLog.WriteLine(line2.ToXmlString());
PFTextFile textFile2 = new PFTextFile(@"c:\temp\DelimitedText2.txt", PFFileOpenOperation.OpenFileForWrite);
char[] tst = { 'a', 'b', 'c', 'd', 'e' };
//line2.LineTerminator = "\r\n";
line2.ColumnSeparator = ",";
line2.SetColumnDefinition(0, "Column One", 10);
line2.SetColumnDefinition(1, "2ndColumn", 15);
line2.SetColumnDefinition(2, "Column Three", 5);
line2.SetColumnDefinition(3, "Column Four", 35);
line2.SetColumnDefinition(4, "5thColumn", 25);
textFile2.WriteData(line2.OutputColumnNames());
for (int rowNum = 0; rowNum < numRowsToOutput; rowNum++)
{
for (int inx = 0; inx < 5; inx++)
{
num = siz.GenerateRandomInt(1, line2.ColumnDefinitions.ColumnDefinition[inx].ColumnLength);
str = new string(tst[inx], num);
line2.ColumnData.ColumnDataValue[inx].Data = str;
}
textFile2.WriteData(line2.OutputColumnData());
}
textFile2.CloseFile();
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
Program._messageLog.WriteLine(_msg.ToString());
AppMessages.DisplayErrorMessage(_msg.ToString(), _saveErrorMessagesToAppLog);
}
finally
{
if (textFile != null)
{
textFile = null;
}
;
}
}//end DelimitedLineTextFileTests
public void RandomChaptersTest(int numChapters, int minNumParagraphsPerChapter, int maxNumParagraphsPerChapter,
int minNumSentencesPerParagraph, int maxNumSentencesPerParagraph,
string pChapterHeadings)
{
RandomNumber rn = new RandomNumber();
RandomDocument rd = new RandomDocument();
int numParagraphs = 0;
string chap = string.Empty;
string[] chapterHeadings = null;
int chapHeadingInx = -1;
int chapHeadingMaxInx = -1;
try
{
_msg.Length = 0;
_msg.Append("RandomChaptersTest started ...\r\n");
Program._messageLog.WriteLine(_msg.ToString());
if (pChapterHeadings.Trim().Length > 0)
{
chapterHeadings = pChapterHeadings.Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
chapHeadingMaxInx = chapterHeadings.Length - 1;
}
chapHeadingInx = -1;
for (int ch = 0; ch < numChapters; ch++)
{
numParagraphs = rn.GenerateRandomInt(minNumParagraphsPerChapter, maxNumParagraphsPerChapter);
if (chapterHeadings == null)
{
_str.Length = 0;
_str.Append("Chapter ");
_str.Append((ch + 1).ToString());
_str.Append(Environment.NewLine);
_str.Append(Environment.NewLine);
chap = rd.GenerateChapter(numParagraphs, minNumSentencesPerParagraph, maxNumSentencesPerParagraph);
_str.Append(chap);
chap = _str.ToString();
}
else
{
chapHeadingInx++;
if (chapHeadingInx > chapHeadingMaxInx)
{
//More chapters are being generated than there are defined chapter headings
_str.Length = 0;
_str.Append("Chapter ");
_str.Append((ch + 1).ToString());
chap = rd.GenerateChapter(_str.ToString(), numParagraphs, minNumSentencesPerParagraph, maxNumSentencesPerParagraph);
}
else
{
chap = rd.GenerateChapter(chapterHeadings[chapHeadingInx], numParagraphs, minNumSentencesPerParagraph, maxNumSentencesPerParagraph);
}
}
Program._messageLog.WriteLine(chap);
}
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
Program._messageLog.WriteLine(_msg.ToString());
AppMessages.DisplayErrorMessage(_msg.ToString(), _saveErrorMessagesToAppLog);
}
finally
{
_msg.Length = 0;
_msg.Append("\r\n... RandomChaptersTest finished.");
Program._messageLog.WriteLine(_msg.ToString());
}
}
private DataTable CreateOrderTransactionDatesPreviewTable()
{
DataTable dt = new DataTable();
RandomNumber rnd = new RandomNumber();
int numPreviewDates = 10;
DateTime earliestDate = DateTime.MinValue;
DateTime latestDate = DateTime.MinValue;
DateTime currDate = DateTime.MinValue;
bool includeWeekendDays = this.chkIncludeWeekendDays.Checked;
int minNumSalesOrdersPerDate = 1;
int maxNumSalesOrdersPerDate = 1;
int minNumPurchaseOrdersPerDate = 1;
int maxNumPurchaseOrdersPerDate = 1;
TimeSpan minTimePerDate = TimeSpan.MinValue;
TimeSpan maxTimePerDate = TimeSpan.MinValue;
int minSecondsPerDate = 1;
int maxSecondsPerDate = 1;
int numSalesOrdersForDate = 0;
int numPurchaseOrdersForDate = 0;
int numSecondsForTx = 0;
TimeSpan txTime = TimeSpan.MinValue;
StringBuilder timeList = new StringBuilder();
string errMsg = VerifyFormValues();
if (errMsg.Length > 0)
{
WriteToMessageLog(errMsg);
AppMessages.DisplayErrorMessage(errMsg);
return(null);
}
DataColumn dc0 = new DataColumn();
dc0.ColumnName = "DayNum";
dc0.DataType = Type.GetType("System.Int32");
dc0.AutoIncrement = true;
dc0.AutoIncrementSeed = 1;
dc0.AutoIncrementStep = 1;
DataColumn dc1 = new DataColumn();
dc1.ColumnName = "DayOfWeek";
dc1.DataType = Type.GetType("System.String");
dc1.MaxLength = 255;
DataColumn dc2 = new DataColumn();
dc2.ColumnName = "DateAndTime";
dc2.DataType = Type.GetType("System.DateTime");
DataColumn dc3 = new DataColumn();
dc3.ColumnName = "NumSalesOrders";
dc3.DataType = Type.GetType("System.Int32");
DataColumn dc4 = new DataColumn();
dc4.ColumnName = "NumPurchaseOrders";
dc4.DataType = Type.GetType("System.Int32");
DataColumn dc5 = new DataColumn();
dc5.ColumnName = "Tx Times";
dc5.DataType = Type.GetType("System.String");
dc5.MaxLength = Int16.MaxValue;
dt.Columns.Add(dc0);
dt.Columns.Add(dc1);
dt.Columns.Add(dc2);
dt.Columns.Add(dc3);
dt.Columns.Add(dc4);
dt.Columns.Add(dc5);
numPreviewDates = AppTextGlobals.ConvertStringToInt(this.txtNumPreviewDates.Text, -1);
earliestDate = AppTextGlobals.ConvertStringToDateTime(this.txtEarliestTransactionDate.Text, DateTime.MinValue);
latestDate = AppTextGlobals.ConvertStringToDateTime(this.txtLatestTransactionDate.Text, DateTime.MinValue);
currDate = earliestDate;
minNumSalesOrdersPerDate = AppTextGlobals.ConvertStringToInt(this.txtMinNumSalesOrdersPerDate.Text, 1);
maxNumSalesOrdersPerDate = AppTextGlobals.ConvertStringToInt(this.txtMaxNumSalesOrdersPerDate.Text, 1);
minNumPurchaseOrdersPerDate = AppTextGlobals.ConvertStringToInt(this.txtMinNumPurchaseOrdersPerDate.Text, 1);
maxNumPurchaseOrdersPerDate = AppTextGlobals.ConvertStringToInt(this.txtMaxNumPurchaseOrdersPerDate.Text, 1);
minTimePerDate = AppTextGlobals.ConvertStringToTimeSpan(this.txtMinTimePerDate.Text, "00:00:00");
maxTimePerDate = AppTextGlobals.ConvertStringToTimeSpan(this.txtMaxTimePerDate.Text, "00:00:00");
minSecondsPerDate = (int)minTimePerDate.TotalSeconds;
maxSecondsPerDate = (int)maxTimePerDate.TotalSeconds;
for (int r = 0; r < numPreviewDates; r++)
{
numSalesOrdersForDate = rnd.GenerateRandomInt(minNumSalesOrdersPerDate, maxNumSalesOrdersPerDate);
numPurchaseOrdersForDate = rnd.GenerateRandomInt(minNumPurchaseOrdersPerDate, maxNumPurchaseOrdersPerDate);
DataRow dr = dt.NewRow();
dr[1] = currDate.DayOfWeek.ToString();
dr[2] = currDate;
dr[3] = numSalesOrdersForDate;
dr[4] = numPurchaseOrdersForDate;
timeList.Length = 0;
for (int so = 0; so < numSalesOrdersForDate; so++)
{
numSecondsForTx = rnd.GenerateRandomInt(minSecondsPerDate, maxSecondsPerDate);
DateTime txDate = currDate.AddSeconds(numSecondsForTx);
timeList.Append("SO at ");
timeList.Append(txDate.ToString("HH:mm:ss"));
timeList.Append(", ");
}
for (int po = 0; po < numPurchaseOrdersForDate; po++)
{
numSecondsForTx = rnd.GenerateRandomInt(minSecondsPerDate, maxSecondsPerDate);
DateTime txDate = currDate.AddSeconds(numSecondsForTx);
timeList.Append("PO at ");
timeList.Append(txDate.ToString("HH:mm:ss"));
timeList.Append(", ");
}
dr[5] = timeList.ToString().TrimEnd(' ').TrimEnd(',');
dt.Rows.Add(dr);
//increment counters and dates to continue loop
currDate = currDate.AddDays(1);
if (currDate > latestDate)
{
break;
}
if (currDate.DayOfWeek == DayOfWeek.Sunday &&
includeWeekendDays == false)
{
currDate = currDate.AddDays(1);
}
else if (currDate.DayOfWeek == DayOfWeek.Saturday &&
includeWeekendDays == false)
{
currDate = currDate.AddDays(2);
}
else
{
//keep the previously calculated date
;
}
}
return(dt);
}
public void GenerateRandomWords()
{
string randomDataFilePath = string.Empty;
PFList <string> wordList = new PFList <string>();
int numWordsOutput = 0;
int maxNumWordsToOutput = 0;
string word = string.Empty;
RandomNumber rn = new RandomNumber();
int minRNum = 0;
int maxRNum = -1;
int numWordsOnLine = 0;
int maxWordsPerLine = 10;
try
{
_msg.Length = 0;
_msg.Append("GenerateRandomWords started ...\r\n");
Program._messageLog.WriteLine(_msg.ToString());
if (_frm.txtRandomDataXmlFilesFolder.Text.Trim().Length == 0)
{
_msg.Length = 0;
_msg.Append("You must specify the folder containing the random data XML files.");
throw new System.Exception(_msg.ToString());
}
if (_frm.cboRandomDataXmlFile.Text.Trim().Length == 0)
{
_msg.Length = 0;
_msg.Append("You must specify the file containing the random data.");
throw new System.Exception(_msg.ToString());
}
randomDataFilePath = Path.Combine(_frm.txtRandomDataXmlFilesFolder.Text, _frm.cboRandomDataXmlFile.Text);
if (File.Exists(randomDataFilePath) == false)
{
_msg.Length = 0;
_msg.Append("Unable to find file: ");
_msg.Append(randomDataFilePath);
throw new System.Exception(_msg.ToString());
}
wordList = PFList <string> .LoadFromXmlFile(randomDataFilePath);
_msg.Length = 0;
_msg.Append("Num words in list ");
_msg.Append(_frm.cboRandomDataXmlFile.Text);
_msg.Append(": ");
_msg.Append(wordList.Count.ToString("#,##0"));
_msg.Append(Environment.NewLine);
Program._messageLog.WriteLine(_msg.ToString());
maxNumWordsToOutput = Convert.ToInt32(_frm.txtNumWordsToOutput.Text);
numWordsOutput = 0;
minRNum = 0;
maxRNum = wordList.Count - 1;
numWordsOnLine = 0;
_msg.Length = 0;
while (numWordsOutput < maxNumWordsToOutput)
{
word = wordList[rn.GenerateRandomInt(minRNum, maxRNum)];
numWordsOutput++;
numWordsOnLine++;
_msg.Append(word);
_msg.Append(" ");
if (numWordsOnLine >= maxWordsPerLine)
{
Program._messageLog.WriteLine(_msg.ToString());
_msg.Length = 0;
numWordsOnLine = 0;
}
}
if (_msg.Length > 0)
{
Program._messageLog.WriteLine(_msg.ToString());
_msg.Length = 0;
}
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
Program._messageLog.WriteLine(_msg.ToString());
AppMessages.DisplayErrorMessage(_msg.ToString(), _saveErrorMessagesToAppLog);
}
finally
{
_msg.Length = 0;
_msg.Append("\r\n... GenerateRandomWords finished.");
Program._messageLog.WriteLine(_msg.ToString());
}
}
/// <summary>
/// Creates DataTable containing list of random words.
/// </summary>
/// <param name="numRows">Number of rows containg random words to generate.</param>
/// <param name="minNumWords">Minimum number of random words per row.</param>
/// <param name="maxNumWords">Maximum number of random words per row.</param>
/// <param name="randWordOutputFormat">Format for the random words (upper and lower case formats).</param>
/// <returns>ADO.NET DataTable.</returns>
public DataTable CreateRandomWordsDataTable(int numRows, string minNumWords, string maxNumWords, enRandomWordOutputFormat randWordOutputFormat)
{
DataTable dt = new DataTable();
RandomNumber rn = new RandomNumber();
PFRandomWord randWord = new PFRandomWord();
StringBuilder words = new StringBuilder();
try
{
int minimumNumberOfWords = Convert.ToInt32(minNumWords);
int maximumNumberOfWords = Convert.ToInt32(maxNumWords);
DataColumn dc = new DataColumn("RandomValue");
dc.DataType = Type.GetType("System.String");
dt.Columns.Add(dc);
for (int i = 0; i < numRows; i++)
{
DataRow dr = dt.NewRow();
int numWords = rn.GenerateRandomInt(minimumNumberOfWords, maximumNumberOfWords);
words.Length = 0;
for (int s = 0; s < numWords; s++)
{
string str = randWord.GetWord();
switch (randWordOutputFormat)
{
case enRandomWordOutputFormat.enUCLC:
if (str.Length > 1)
{
str = str.Substring(0, 1).ToUpper() + str.Substring(1, str.Length - 1);
}
else
{
str = str.Substring(0, 1).ToUpper();
}
break;
case enRandomWordOutputFormat.enLC:
str = str.ToLower();
break;
case enRandomWordOutputFormat.enUC:
str = str.ToUpper();
break;
default:
break;
}
words.Append(str);
words.Append(" ");
}
dr[0] = words.ToString();
dt.Rows.Add(dr);
}
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append("Error in CreateRandomStringsDataTable routine.\r\n");
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
throw new System.Exception(_msg.ToString());
}
finally
{
;
}
return(dt);
}
/// <summary>
/// Routine to create a set of random strings.
/// </summary>
/// <param name="randStringType">Enumeration describing the format of the strings to be generated. (e.g. AlphaNumeric, Alpha Only etc.)</param>
/// <param name="numRows">Number of DataTable rows to generate containing random strings.</param>
/// <param name="minNumStrings">Minimum number of strings to generate for each output row.</param>
/// <param name="maxNumStrings">Maximum number of strings to generate for each output row.</param>
/// <param name="stringMinimumLength">Minimum length of strings to generate for each output row.</param>
/// <param name="stringMaximumLength">Maximum length of strings to generate for each output row.</param>
/// <param name="regexPattern">Regex pattern to use when generating a string. Assign empty string to this property to bypass regex processing.</param>
/// <param name="regexReplacement">Replacement place holders for the regex generation. Assign empty string to this property to bypass regex processing.</param>
/// <returns>ADO.NET DataTable containing the generated random strings.</returns>
/// <remarks>Example of how regex is used by this routine: Regex.Replace(str, @"(\w{4})(\w{4})(\w{4})", @"$1-$2-$3"); </remarks>
/// <remarks>Leave regexPattern and regexReplacement blank if you do not wish to use regex.</remarks>
public DataTable CreateRandomStringsDataTable(enRandomStringType randStringType,
int numRows,
string minNumStrings,
string maxNumStrings,
string stringMinimumLength,
string stringMaximumLength,
string regexPattern,
string regexReplacement)
{
DataTable dt = new DataTable();
RandomNumber rn = new RandomNumber();
StringBuilder randString = new StringBuilder();
try
{
int minimumNumberOfStrings = Convert.ToInt32(minNumStrings);
int maximumNumberOfStrings = Convert.ToInt32(maxNumStrings);
int minimumLength = Convert.ToInt32(stringMinimumLength);
int maximumLength = Convert.ToInt32(stringMaximumLength);
DataColumn dc = new DataColumn("RandomValue");
dc.DataType = Type.GetType("System.String");
dt.Columns.Add(dc);
for (int i = 0; i < numRows; i++)
{
DataRow dr = dt.NewRow();
int numStrings = rn.GenerateRandomInt(minimumNumberOfStrings, maximumNumberOfStrings);
randString.Length = 0;
for (int s = 0; s < numStrings; s++)
{
int size = rn.GenerateRandomInt(minimumLength, maximumLength);
string str = getRandomString[(int)randStringType](size);
//str = Regex.Replace(str, @"(\w{4})(\w{4})(\w{4})", @"$1-$2-$3");
if (regexPattern.Trim().Length > 0)
{
if (regexReplacement.Trim().Length > 0)
{
str = Regex.Replace(str, regexPattern, regexReplacement);
}
}
randString.Append(str);
randString.Append(" ");
}
dr[0] = randString.ToString();
dt.Rows.Add(dr);
}
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append("Error in CreateRandomStringsDataTable routine.\r\n");
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
throw new System.Exception(_msg.ToString());
}
finally
{
;
}
return(dt);
}
/// <summary>
/// Routine to generate a random word.
/// </summary>
/// <returns>String containing the generated word.</returns>
public string GetWord()
{
return(_words[_rn.GenerateRandomInt(_minListInx, _maxListInx)]);
}
/// <summary>
/// Routine to generate sentences containing random words organized into chapters and books.
/// </summary>
/// <param name="bookTitle">Title text to be inserted at the beginning of the book's text.</param>
/// <param name="appendTheEndToBook">Phrase to be appended to the book text.</param>
/// <param name="numChapters">Total number of chapters to produce for the book.</param>
/// <param name="pChapterTitles">Array of strings containing titles for chapters. Omit or set to null to allow generation of default chapter titles.</param>
/// <param name="minNumParagraphsPerChapter">Minimum number of paragraphs to generate for a chapter.</param>
/// <param name="maxNumParagraphsPerChapter">Maximum number of paragraphs to generate for a chapter.</param>
/// <param name="minNumSentencesPerParagraph">Minimum number of sentences in a paragraph.</param>
/// <param name="maxNumSentencesPerParagraph">Maximum number of sentences in a paragraph.</param>
/// <returns>String containing random text in chapter and book format.</returns>
public string GenerateBook(string bookTitle,
string appendTheEndToBook,
int numChapters,
string[] pChapterTitles,
int minNumParagraphsPerChapter,
int maxNumParagraphsPerChapter,
int minNumSentencesPerParagraph,
int maxNumSentencesPerParagraph)
{
StringBuilder book = new StringBuilder();
string[] chapterTitles = null;
int rndMin = 0;
int rndMax = 0;
//int rndNum = 0;
if (String.IsNullOrEmpty(bookTitle) == false)
{
book.Append(bookTitle);
}
else
{
book.Append("Book");
}
book.Append(Environment.NewLine);
book.Append(Environment.NewLine);
if (pChapterTitles == null)
{
chapterTitles = InitChapterTitles(numChapters);
}
else
{
chapterTitles = pChapterTitles;
}
int maxChapterTitleInx = chapterTitles.Length - 1;
string chapterTitle = string.Empty;
for (int c = 0; c < numChapters; c++)
{
if (c > maxChapterTitleInx)
{
chapterTitle = "Chapter " + (c + 1).ToString();
}
else
{
chapterTitle = chapterTitles[c];
}
rndMin = minNumParagraphsPerChapter;
rndMax = maxNumParagraphsPerChapter;
int numParagraphs = _rnd.GenerateRandomInt(rndMin, rndMax);
book.Append(GenerateChapter(chapterTitle, numParagraphs, minNumSentencesPerParagraph, maxNumSentencesPerParagraph));
}//end chapter loop
if (String.IsNullOrEmpty(appendTheEndToBook) == false)
{
book.Append(Environment.NewLine);
book.Append(Environment.NewLine);
book.Append(appendTheEndToBook);
}
return(book.ToString());
}
/// <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>
/// Routine to create random documents.
/// </summary>
/// <param name="numRows">Number of data rows to generate containing random sentences.</param>
/// <param name="minNumParagraphs">Minimum number of paragraphs in a data row.</param>
/// <param name="maxNumParagraphs">Maximum number of paragraphs in a data row.</param>
/// <param name="minNumSentencesPerParagraph">Minimum number of sentences per paragraph.</param>
/// <param name="maxNumSentencesPerParagraph">Maximum number of sentences per paragraph.</param>
/// <param name="includeDocumentTitle">If true, a line containing a random phrase that serves as document title is included at the beginning of each random document. If false, no title is generated.</param>
/// <returns>ADO.NET DataTable containing the random documents.</returns>
public DataTable CreateRandomDocumentDataTable(int numRows, string minNumParagraphs, string maxNumParagraphs, string minNumSentencesPerParagraph, string maxNumSentencesPerParagraph, bool includeDocumentTitle)
{
DataTable dt = new DataTable();
RandomNumber rn = new RandomNumber();
PFRandomWord randWord = new PFRandomWord();
RandomDocument randDocument = new RandomDocument();
StringBuilder title = new StringBuilder();
try
{
int minimumNumberOfParagraphs = Convert.ToInt32(minNumParagraphs);
int maximumNumberOfParagraphs = Convert.ToInt32(maxNumParagraphs);
int minimumNumberOfSentencesPerParagraph = Convert.ToInt32(minNumSentencesPerParagraph);
int maximumNumberOfSentencesPerParagraph = Convert.ToInt32(maxNumSentencesPerParagraph);
DataColumn dc = new DataColumn("RandomValue");
dc.DataType = Type.GetType("System.String");
dt.Columns.Add(dc);
for (int i = 0; i < numRows; i++)
{
DataRow dr = dt.NewRow();
title.Length = 0;
if (includeDocumentTitle)
{
int numWordsInTitle = rn.GenerateRandomInt((int)3, (int)7);
for (int t = 0; t < numWordsInTitle; t++)
{
if (t > 0)
{
title.Append(" ");
}
string temp = randWord.GetWord();
temp = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(temp.ToLower());
title.Append(temp);
}
}
int numParagraphs = rn.GenerateRandomInt(minimumNumberOfParagraphs, maximumNumberOfParagraphs);
string str = randDocument.GenerateDocument(numParagraphs, minimumNumberOfSentencesPerParagraph, maximumNumberOfSentencesPerParagraph, title.ToString());
dr[0] = str;
dt.Rows.Add(dr);
}
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append("Error in CreateRandomDocumentDataTable routine.\r\n");
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
throw new System.Exception(_msg.ToString());
}
finally
{
;
}
return(dt);
}
