Esempio n. 1
0
        //properties

        //methods

        /// <summary>
        /// Loads DataTable containing the custom values specified in the list file defined in the RandomCustomValuesDataRequest definition.
        /// </summary>
        /// <param name="numRows">Number of output rows to generate. (IGNORED by this routine. Routine takes all the rows in the custom values file.)</param>
        /// <param name="dataRequest">RandomCustomValuesDataRequest object contains the name of the file that contains the custom values.</param>
        /// <returns>ADO.NET DataTable containing the custom values.</returns>
        /// <remarks>Random values are containing in a presiously generated file.</remarks>
        public DataTable CreateRandomDataTable(int numRows, RandomCustomValuesDataRequest dataRequest)
        {
            DataSet   ds = new DataSet();
            DataTable dt = null;

            string dataFilePath = Path.Combine(dataRequest.ListFolder, dataRequest.ListName + ".xml");

            ds.ReadXml(dataFilePath);
            dt           = ds.Tables[0];
            dt.TableName = dataRequest.ListName;

            return(dt);
        }
Esempio n. 2
0
        private string VerifySelectionCriteriaFormat(RandomCustomValuesDataRequest dataRequest)
        {
            string        verifiedSelectionCriteria = dataRequest.SelectionCriteria;
            List <string> compareToValues           = new List <string>();

            string[] nonCriteriaWords = { "not", "in", "like" };
            if (dataRequest.SelectionFieldType == "System.String")
            {
                char[]   seps  = { ' ', '(', ')', ',' };
                string[] words = dataRequest.SelectionCriteria.Split(seps);
                foreach (string word in words)
                {
                    bool wordIsCriteria = true;
                    foreach (string excludeWord in nonCriteriaWords)
                    {
                        if (word.ToLower() == excludeWord.ToLower())
                        {
                            wordIsCriteria = false;
                        }
                    }
                    if (word.Trim().Length == 0)
                    {
                        wordIsCriteria = false;
                    }
                    if (wordIsCriteria && word.StartsWith("'") == false)
                    {
                        compareToValues.Add(word);
                    }
                }
                foreach (string word in compareToValues)
                {
                    verifiedSelectionCriteria = verifiedSelectionCriteria.Replace(word, "'" + word + "'");
                }
            }



            return(verifiedSelectionCriteria);
        }
Esempio n. 3
0
        /// <summary>
        /// Creates DataTable containing the custom values specified in the RandomCustomValuesDataRequest definition.
        /// </summary>
        /// <param name="numRows">Number of output rows to generate.</param>
        /// <param name="rdr">RandomCustomValuesDataRequest object contains the definition for the custom values.</param>
        /// <param name="summaryDataTable">DataTable that will contain the summary values (i.e. how many times each value appears in the result table).</param>
        /// <param name="showInstalledDatabaseProvidersOnly">Instructs custom values routines to only allow connections from the list installed database providers.</param>
        /// <param name="defaultOutputDatabaseType">Default database type to show if user is prompted for connection information.</param>
        /// <param name="defaultOutputDatabaseConnectionString">Default connection string to use if user is prompted for connection information.</param>
        /// <param name="defaultDataGridExportFolder">Default folder for storing any output requested by user from the result grids that are displayed.</param>
        /// <returns>ADO.NET DataTable containing the custom values.</returns>
        /// <remarks>New set of values are generated and stored by this routine.</remarks>
        public DataTable CreateRandomCustomValuesDataTable(int numRows,
                                                           RandomCustomValuesDataRequest rdr,
                                                           out DataTable summaryDataTable,
                                                           bool showInstalledDatabaseProvidersOnly,
                                                           string defaultOutputDatabaseType,
                                                           string defaultOutputDatabaseConnectionString,
                                                           string defaultDataGridExportFolder)
        {
            DataTable         summaryTable  = new DataTable();
            DataListProcessor _appProcessor = new DataListProcessor();
            DataTable         listTable     = null;

            try
            {
                _appProcessor.ShowInstalledDatabaseProvidersOnly    = showInstalledDatabaseProvidersOnly;
                _appProcessor.DefaultOutputDatabaseType             = defaultOutputDatabaseType;
                _appProcessor.DefaultOutputDatabaseConnectionString = defaultOutputDatabaseConnectionString;
                _appProcessor.GridExportFolder = defaultDataGridExportFolder;

                summaryTable = _appProcessor.GetCustomRandomDataFile(rdr, numRows, false, false);
            }
            catch (System.Exception ex)
            {
                _msg.Length = 0;
                _msg.Append("Error in CreateRandomCustomValuesDataTable routine.\r\n");
                _msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
                throw new System.Exception(_msg.ToString());
            }
            finally
            {
                ;
            }

            summaryDataTable = summaryTable;
            listTable        = CreateCustomValuesListTable(summaryTable);

            return(listTable);
        }
Esempio n. 4
0
        /// <summary>
        /// Produces DataTable containing custom random data.
        /// </summary>
        /// <param name="dataRequest">Object containg the definition for the custom data request.</param>
        /// <param name="maxTotalFrequency">Maximum total frequencies for random values.</param>
        /// <param name="outputToXmlFile">Set to true to store random values in an XML file.</param>
        /// <param name="outputToGrid">Set to true to output random values to a DataGridView object.</param>
        /// <returns>DataTable containing random values.</returns>
        /// <remakrs>Custom random data is generated by running custom queries against a database.</remakrs>
        public DataTable GetCustomRandomDataFile(RandomCustomValuesDataRequest dataRequest, int maxTotalFrequency, bool outputToXmlFile, bool outputToGrid)
        {
            bool generateResult         = true;
            CustomDataListGenerator gen = new CustomDataListGenerator(dataRequest.DbPlatform);
            Stopwatch sw = new Stopwatch();
            string    sqlUsedToGenerateDataValues = string.Empty;
            DataTable customListDataTableValues   = null;

            sw.Start();


            try
            {
                if (dataRequest.DbTableName.Length == 0 ||
                    dataRequest.DbFieldName.Length == 0)
                {
                    _msg.Length = 0;
                    _msg.Append("You must connect to the database and define a table name and field to use.");
                    throw new System.Exception(_msg.ToString());
                }

                if (dataRequest.SelectionCriteria.Trim().Length > 0 &&
                    dataRequest.SelectionCondition.Trim().Length > 0 &&
                    dataRequest.SelectionField.Trim().Length > 0)
                {
                    dataRequest.SelectionCriteria = VerifySelectionCriteriaFormat(dataRequest);
                }
                else
                {
                    dataRequest.SelectionCriteria  = string.Empty;
                    dataRequest.SelectionCondition = string.Empty;
                    dataRequest.SelectionField     = string.Empty;
                }

                //XML & related file locations are set in the gen.GenerateCustomRandomDataList routine
                gen.MaxTotalFrequencyCount = maxTotalFrequency;
                generateResult             = gen.GenerateCustomRandomDataList(dataRequest, outputToXmlFile, out sqlUsedToGenerateDataValues, out customListDataTableValues);

                if (generateResult == false)
                {
                    _msg.Length = 0;
                    _msg.Append("Attempt to generate custom random data list ");
                    _msg.Append(dataRequest.ListName);
                    _msg.Append(" failed.");
                    throw new System.Exception(_msg.ToString());
                }

                _msg.Length = 0;
                _msg.Append("SQL statement for data retrieval:");
                _msg.Append(Environment.NewLine);
                _msg.Append(sqlUsedToGenerateDataValues);
                _msg.Append(Environment.NewLine);
                WriteToMessageLog(_msg.ToString());

                sw.Stop();

                if (outputToGrid)
                {
                    string filterColumnName = customListDataTableValues.Columns[0].ColumnName;
                    PFDataOutputGrid.DataOutputGridProcessor grid = new PFDataOutputGrid.DataOutputGridProcessor();
                    grid.ShowInstalledDatabaseProvidersOnly    = this.ShowInstalledDatabaseProvidersOnly;
                    grid.DefaultOutputDatabaseType             = this.DefaultOutputDatabaseType;
                    grid.DefaultOutputDatabaseConnectionString = this.DefaultOutputDatabaseConnectionString;
                    if (_gridExportFolder != _defaultGridExportFolder)
                    {
                        grid.DefaultGridExportFolder = _gridExportFolder;
                    }
                    else
                    {
                        grid.DefaultGridExportFolder = Path.Combine(_defaultGridExportFolder, "Custom");
                    }
                    grid.GridColumnFilters.Add(new PFDataOutputGrid.GridColumnFilter(filterColumnName, PFDataOutputGrid.enFilterType.ComboBoxColumnFilter));
                    grid.WriteDataToGrid(customListDataTableValues);
                    grid = null;

                    //string customDataFileName = Path.Combine(dataRequest.ListFolder, dataRequest.ListName + ".xml");
                    //DataSet customData = new DataSet();
                    //customData.ReadXml(customDataFileName);
                    //customData.Tables[0].TableName = dataRequest.ListName;
                    //customData.Tables[0].Columns[0].ColumnName = "CustomDataValue";
                    DataTable customListTable = CreateCustomListTableForGridOutput(customListDataTableValues);
                    customListTable.TableName             = dataRequest.ListName;
                    customListTable.Columns[0].ColumnName = "CustomDataValue";

                    grid = new PFDataOutputGrid.DataOutputGridProcessor();
                    grid.ShowInstalledDatabaseProvidersOnly    = this.ShowInstalledDatabaseProvidersOnly;
                    grid.DefaultOutputDatabaseType             = this.DefaultOutputDatabaseType;
                    grid.DefaultOutputDatabaseConnectionString = this.DefaultOutputDatabaseConnectionString;
                    filterColumnName = customListTable.Columns[0].ColumnName;
                    grid.GridColumnFilters.Add(new PFDataOutputGrid.GridColumnFilter(filterColumnName, PFDataOutputGrid.enFilterType.ComboBoxColumnFilter));
                    grid.WriteDataToGrid(customListTable);
                    grid = null;
                }
            }
            catch (System.Exception ex)
            {
                _msg.Length = 0;
                _msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
                WriteToMessageLog(_msg.ToString());
                AppMessages.DisplayErrorMessage(_msg.ToString(), _saveErrorMessagesToAppLog);
            }
            finally
            {
                if (sw.StopwatchIsRunning)
                {
                    sw.Stop();
                }

                _msg.Length = 0;
                _msg.Append(Environment.NewLine);
                _msg.Append("Random custom data list generation finished.");
                _msg.Append(Environment.NewLine);
                _msg.Append("Elapsed time for data generation: ");
                _msg.Append(sw.FormattedElapsedTime);
                _msg.Append(Environment.NewLine);
                WriteToMessageLog(_msg.ToString());
            }

            return(customListDataTableValues);
        }