private void ResetControls()
        {
            int intCounter;
            int intNumberOfRecords;

            txtAddedNotes.Text         = "";
            txtEnterVehicleNumber.Text = "";
            txtProblem.Text            = "";
            cboSelectVendor.Items.Clear();

            TheFindVendorSortedDataSet = TheVendersClass.FindVendorsSortedByVendorName();

            intNumberOfRecords = TheFindVendorSortedDataSet.FindVendorsSortedByVendorName.Rows.Count - 1;

            cboSelectVendor.Items.Add("Select Vendor");

            for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
            {
                cboSelectVendor.Items.Add(TheFindVendorSortedDataSet.FindVendorsSortedByVendorName[intCounter].VendorName);
            }

            cboSelectVendor.SelectedIndex = 0;

            lblSelectVendor.Visibility = Visibility.Hidden;
            cboSelectVendor.Visibility = Visibility.Hidden;

            TheFindOpenVehicleMainProblemsByVehicleIDDataSet = TheVehicleProblemClass.FindOpenVehicleMainProblemsByVehicleID(0);

            dgrOpenProblems.ItemsSource = TheFindOpenVehicleMainProblemsByVehicleIDDataSet.FindOpenVehicleMainProblemsByVehicleID;

            mitProcessProblem.IsEnabled = false;
        }
        private void ResetControls()
        {
            int intCounter;
            int intNumberOfRecords;

            txtVehicleNumber.Text = "";
            TheFindOpenvehicleMainProblemByVehicleIDDataSet = TheVehicleProblemClass.FindOpenVehicleMainProblemsByVehicleID(0);

            dgrResults.ItemsSource = TheFindOpenvehicleMainProblemByVehicleIDDataSet.FindOpenVehicleMainProblemsByVehicleID;

            mitProcess.IsEnabled       = false;
            dgrResults.IsEnabled       = false;
            txtVehicleNumber.IsEnabled = false;

            //this will load the combo box
            TheFindVendorsSoredByVendorNameDataSet = TheVendorsClass.FindVendorsSortedByVendorName();

            intNumberOfRecords = TheFindVendorsSoredByVendorNameDataSet.FindVendorsSortedByVendorName.Rows.Count - 1;

            cboVendors.Items.Clear();
            cboVendors.Items.Add("Select Vendor");

            for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
            {
                cboVendors.Items.Add(TheFindVendorsSoredByVendorNameDataSet.FindVendorsSortedByVendorName[intCounter].VendorName);
            }

            cboVendors.SelectedIndex = 0;
        }
        private void txtVehicleNumber_TextChanged(object sender, TextChangedEventArgs e)
        {
            string strVehicleNumber;
            int    intLength;
            int    intRecordsReturned;
            bool   blnVehicleFound;

            strVehicleNumber = txtVehicleNumber.Text;
            intLength        = strVehicleNumber.Length;
            blnVehicleFound  = false;
            if (intLength == 4)
            {
                TheFindActiveVehicleMainByVehicleNumberDataSet = TheVehicleMainClass.FindActiveVehicleMainByVehicleNumber(strVehicleNumber);

                intRecordsReturned = TheFindActiveVehicleMainByVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber.Rows.Count;

                if (intRecordsReturned > 0)
                {
                    blnVehicleFound          = true;
                    MainWindow.gintVehicleID = TheFindActiveVehicleMainByVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber[0].VehicleID;
                }
            }
            else if (intLength == 6)
            {
                TheFindActiveVehicleMainByVehicleNumberDataSet = TheVehicleMainClass.FindActiveVehicleMainByVehicleNumber(strVehicleNumber);

                intRecordsReturned = TheFindActiveVehicleMainByVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber.Rows.Count;

                if (intRecordsReturned > 0)
                {
                    blnVehicleFound          = true;
                    MainWindow.gintVehicleID = TheFindActiveVehicleMainByVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber[0].VehicleID;
                }
                else
                {
                    TheMessagesClass.ErrorMessage("Vehicle Number Not Found");
                    return;
                }
            }
            else if (intLength > 6)
            {
                TheMessagesClass.ErrorMessage("To Many Characters for a Vehicle Number");
                return;
            }

            if (blnVehicleFound == true)
            {
                TheFindOpenvehicleMainProblemByVehicleIDDataSet = TheVehicleProblemClass.FindOpenVehicleMainProblemsByVehicleID(MainWindow.gintVehicleID);

                dgrResults.ItemsSource = TheFindOpenvehicleMainProblemByVehicleIDDataSet.FindOpenVehicleMainProblemsByVehicleID;

                dgrResults.IsEnabled = true;
            }
        }
        public FindOpenVehicleMainProblemsByVehicleIDDataSet FindOpenVehicleMainProblemsByVehicleID(int intVehicleID)
        {
            try
            {
                aFindOpenVehicleMainProblemsByVehicleIDDataSet      = new FindOpenVehicleMainProblemsByVehicleIDDataSet();
                aFindOpenVehicleMainProblemsByVehicleIDTableAdapter = new FindOpenVehicleMainProblemsByVehicleIDDataSetTableAdapters.FindOpenVehicleMainProblemsByVehicleIDTableAdapter();
                aFindOpenVehicleMainProblemsByVehicleIDTableAdapter.Fill(aFindOpenVehicleMainProblemsByVehicleIDDataSet.FindOpenVehicleMainProblemsByVehicleID, intVehicleID);
            }
            catch (Exception Ex)
            {
                TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Vehicle Problem Class // Find Open Vehicle Problems By Vehicle ID " + Ex.Message);
            }

            return(aFindOpenVehicleMainProblemsByVehicleIDDataSet);
        }
        private void rdoPassed_Checked(object sender, RoutedEventArgs e)
        {
            int intRecordsReturned;

            TheFindOpenVehicleMainProblemsByVehicleIDDataSet = TheVehicleProblemClass.FindOpenVehicleMainProblemsByVehicleID(MainWindow.gintVehicleID);

            intRecordsReturned = TheFindOpenVehicleMainProblemsByVehicleIDDataSet.FindOpenVehicleMainProblemsByVehicleID.Rows.Count;

            if (intRecordsReturned > 0)
            {
                TheMessagesClass.ErrorMessage("There are open vehicle problems, the inspection cannot be processed");
                rdoPassedServiceRequired.IsChecked = true;
                return;
            }

            MainWindow.gstrInspectionStatus = "PASSED";
            gstrVehicleStatus = "NO PROBLEM";
        }
        private void ResetControls()
        {
            //setting local variables
            int intCounter;
            int intNumberOfRecords;

            //setting controls
            txtEnterVehicleNumber.Text     = "";
            txtVehicleInyard.Text          = "";
            txtVehicleUpdate.Text          = "";
            gblnOrderselected              = false;
            cboWorkComplete.SelectedIndex  = 0;
            cboVehicleInShop.SelectedIndex = 0;
            btnLoadDocuments.IsEnabled     = false;


            //setting combo box
            cboSelectVendor.Items.Clear();

            TheFindVendorsSortedByVendorNameDataSet = TheVendorsClass.FindVendorsSortedByVendorName();

            intNumberOfRecords = TheFindVendorsSortedByVendorNameDataSet.FindVendorsSortedByVendorName.Rows.Count - 1;

            cboSelectVendor.Items.Add("Select Vendor");

            for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
            {
                cboSelectVendor.Items.Add(TheFindVendorsSortedByVendorNameDataSet.FindVendorsSortedByVendorName[intCounter].VendorName);
            }

            cboSelectVendor.SelectedIndex = 0;
            mitUpdateProblem.IsEnabled    = false;

            //clearing grid
            TheFindOpenVehicleMainProblemsByVehicleIDDataSet = TheVehicleProblemsClass.FindOpenVehicleMainProblemsByVehicleID(0);
            dgrOpenProblems.ItemsSource = TheFindOpenVehicleMainProblemsByVehicleIDDataSet.FindOpenVehicleMainProblemsByVehicleID;
        }
        private void txtEnterVehicleNumber_TextChanged(object sender, TextChangedEventArgs e)
        {
            int    intLength;
            string strVehicleNumber;
            int    intRecordsReturned;

            try
            {
                strVehicleNumber = txtEnterVehicleNumber.Text;
                intLength        = strVehicleNumber.Length;
                if (intLength == 4)
                {
                    TheFindActiveVehicleMainByVehicleNumberDataSet = TheVehicleMainClass.FindActiveVehicleMainByVehicleNumber(strVehicleNumber);

                    intRecordsReturned = TheFindActiveVehicleMainByVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber.Rows.Count;

                    if (intRecordsReturned > 0)
                    {
                        MainWindow.gintVehicleID = TheFindActiveVehicleMainByVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber[0].VehicleID;

                        TheFindOpenVehicleMainProblemsByVehicleIDDataSet = TheVehicleProblemClass.FindOpenVehicleMainProblemsByVehicleID(MainWindow.gintVehicleID);

                        dgrOpenProblems.ItemsSource = TheFindOpenVehicleMainProblemsByVehicleIDDataSet.FindOpenVehicleMainProblemsByVehicleID;

                        mitProcessProblem.IsEnabled = true;
                    }
                }
                if (intLength == 6)
                {
                    TheFindActiveVehicleMainByVehicleNumberDataSet = TheVehicleMainClass.FindActiveVehicleMainByVehicleNumber(strVehicleNumber);

                    intRecordsReturned = TheFindActiveVehicleMainByVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber.Rows.Count;

                    if (intRecordsReturned > 0)
                    {
                        MainWindow.gintVehicleID = TheFindActiveVehicleMainByVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber[0].VehicleID;

                        TheFindOpenVehicleMainProblemsByVehicleIDDataSet = TheVehicleProblemClass.FindOpenVehicleMainProblemsByVehicleID(MainWindow.gintVehicleID);

                        dgrOpenProblems.ItemsSource = TheFindOpenVehicleMainProblemsByVehicleIDDataSet.FindOpenVehicleMainProblemsByVehicleID;

                        mitProcessProblem.IsEnabled = true;
                    }
                    else
                    {
                        TheMessagesClass.ErrorMessage("Vehicle Number Not Found");
                        return;
                    }
                }
                if (intLength > 6)
                {
                    TheMessagesClass.ErrorMessage("To Many Characters for a Vehicle Number");
                    return;
                }
            }
            catch (Exception Ex)
            {
                TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // New Vehicle Problem // Enter Vehicle Number Text Change Event " + Ex.Message);

                TheMessagesClass.ErrorMessage(Ex.ToString());
            }
        }
        private void txtEnterVehicleNumber_TextChanged(object sender, TextChangedEventArgs e)
        {
            //setting local variables
            string strVehicleNumber;
            int    intLength;
            int    intRecordsReturned;

            try
            {
                strVehicleNumber             = txtEnterVehicleNumber.Text;
                MainWindow.gstrVehicleNumber = strVehicleNumber;
                intLength = strVehicleNumber.Length;
                if (intLength == 4)
                {
                    TheFindActivehicleMainByVehicleNumberDataSet = TheVehicleMainClass.FindActiveVehicleMainByVehicleNumber(strVehicleNumber);

                    intRecordsReturned = TheFindActivehicleMainByVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber.Rows.Count;

                    if (intRecordsReturned > 0)
                    {
                        MainWindow.gintVehicleID = TheFindActivehicleMainByVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber[0].VehicleID;

                        TheFindOpenVehicleMainProblemsByVehicleIDDataSet = TheVehicleProblemsClass.FindOpenVehicleMainProblemsByVehicleID(MainWindow.gintVehicleID);

                        dgrOpenProblems.ItemsSource = TheFindOpenVehicleMainProblemsByVehicleIDDataSet.FindOpenVehicleMainProblemsByVehicleID;

                        TheFindVehiclesInShopByVehlcleIDDataSet = TheVehiclesInShopClass.FindVehiclesInShopByVehicleID(MainWindow.gintVehicleID);

                        intRecordsReturned = TheFindVehiclesInShopByVehlcleIDDataSet.FindVehiclesInShopByVehicleID.Rows.Count;

                        if (intRecordsReturned > 0)
                        {
                            txtVehicleInyard.Text = "YES With " + TheFindVehiclesInShopByVehlcleIDDataSet.FindVehiclesInShopByVehicleID[0].VendorName;
                        }
                        else
                        {
                            txtVehicleInyard.Text = "Not In Shop";
                        }
                    }
                }
                else if (intLength == 6)
                {
                    TheFindActivehicleMainByVehicleNumberDataSet = TheVehicleMainClass.FindActiveVehicleMainByVehicleNumber(strVehicleNumber);

                    intRecordsReturned = TheFindActivehicleMainByVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber.Rows.Count;

                    if (intRecordsReturned > 0)
                    {
                        MainWindow.gintVehicleID = TheFindActivehicleMainByVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber[0].VehicleID;

                        TheFindOpenVehicleMainProblemsByVehicleIDDataSet = TheVehicleProblemsClass.FindOpenVehicleMainProblemsByVehicleID(MainWindow.gintVehicleID);

                        dgrOpenProblems.ItemsSource = TheFindOpenVehicleMainProblemsByVehicleIDDataSet.FindOpenVehicleMainProblemsByVehicleID;

                        TheFindVehiclesInShopByVehlcleIDDataSet = TheVehiclesInShopClass.FindVehiclesInShopByVehicleID(MainWindow.gintVehicleID);

                        intRecordsReturned = TheFindVehiclesInShopByVehlcleIDDataSet.FindVehiclesInShopByVehicleID.Rows.Count;

                        if (intRecordsReturned > 0)
                        {
                            txtVehicleInyard.Text = "YES With " + TheFindVehiclesInShopByVehlcleIDDataSet.FindVehiclesInShopByVehicleID[0].VendorName;
                        }
                        else
                        {
                            txtVehicleInyard.Text = "Not In Shop";
                        }
                    }
                    else
                    {
                        TheMessagesClass.ErrorMessage("Vehicle Not Found");
                        return;
                    }
                }
                else if (intLength > 6)
                {
                    TheMessagesClass.ErrorMessage("Vehicle Number Entered has to Many Characters");
                    return;
                }
            }
            catch (Exception Ex)
            {
                TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // Update Vehicle Problem // Enter Vehicle Textbox " + Ex.Message);

                TheMessagesClass.ErrorMessage(Ex.ToString());
            }
        }
        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            //setting up to load the combo box
            gintProblemID = 0;
            int intCounter;
            int intNumberOfRecords;

            try
            {
                //HideTextBoxes();

                cboMultipleProblems.Items.Add("Select");
                cboMultipleProblems.Items.Add("Yes");
                cboMultipleProblems.Items.Add("No");
                cboMultipleProblems.SelectedIndex = 0;

                ExistingOpenProblemsDataSet.openordersRow FirstRow = TheExistingOpenProblemsDataSet.openorders.NewopenordersRow();

                FirstRow.ProblemID = -1;
                FirstRow.Problem   = "NEW WORK ORDER";

                TheExistingOpenProblemsDataSet.openorders.Rows.Add(FirstRow);

                TheFindOpenVehicleMainProblemsByVehicleIDDataSet = TheVehicleProblemClass.FindOpenVehicleMainProblemsByVehicleID(MainWindow.gintVehicleID);

                intNumberOfRecords = TheFindOpenVehicleMainProblemsByVehicleIDDataSet.FindOpenVehicleMainProblemsByVehicleID.Rows.Count - 1;

                MainWindow.TheFindSortedEmployeeManagersDataSet = TheEmployeeClass.FindSortedEmployeeManagers();

                if (intNumberOfRecords > -1)
                {
                    for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
                    {
                        ExistingOpenProblemsDataSet.openordersRow NewOrderRow = TheExistingOpenProblemsDataSet.openorders.NewopenordersRow();

                        NewOrderRow.Problem   = TheFindOpenVehicleMainProblemsByVehicleIDDataSet.FindOpenVehicleMainProblemsByVehicleID[intCounter].Problem;
                        NewOrderRow.ProblemID = TheFindOpenVehicleMainProblemsByVehicleIDDataSet.FindOpenVehicleMainProblemsByVehicleID[intCounter].ProblemID;

                        TheExistingOpenProblemsDataSet.openorders.Rows.Add(NewOrderRow);
                    }
                }

                cboSelectManager.Items.Add("Select Manager");

                intNumberOfRecords = MainWindow.TheFindSortedEmployeeManagersDataSet.FindSortedEmployeeManagers.Rows.Count - 1;

                for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
                {
                    string strFirstName = MainWindow.TheFindSortedEmployeeManagersDataSet.FindSortedEmployeeManagers[intCounter].FirstName;
                    string strLastName  = MainWindow.TheFindSortedEmployeeManagersDataSet.FindSortedEmployeeManagers[intCounter].LastName;

                    cboSelectManager.Items.Add(strFirstName + " " + strLastName);
                }

                TheFindEmployeeByDepartmentDataSet = TheEmployeeClass.FindEmployeeByDepartment("WAREHOUSE");
                cboSelectEmployee.Items.Add("Select Fleet Employee");

                intNumberOfRecords = TheFindEmployeeByDepartmentDataSet.FindEmployeeByDepartment.Rows.Count - 1;

                for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
                {
                    cboSelectEmployee.Items.Add(TheFindEmployeeByDepartmentDataSet.FindEmployeeByDepartment[intCounter].FirstName + " " + TheFindEmployeeByDepartmentDataSet.FindEmployeeByDepartment[intCounter].LastName);
                }

                cboSelectEmployee.SelectedIndex = 0;
                cboSelectManager.SelectedIndex  = 0;
                dgrWorkOrders.ItemsSource       = TheExistingOpenProblemsDataSet.openorders;
                SetReadOnlyControls(false);
            }
            catch (Exception Ex)
            {
                TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // Vehicle Inspection Problem // Window Loaded " + Ex.Message);

                TheMessagesClass.ErrorMessage(Ex.ToString());
            }
        }
        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            int    intCounter;
            int    intNumberOfRecords;
            string strFullName;

            try
            {
                //setting up the controls
                cboNewProblem.Items.Add("Select New Problems");
                cboNewProblem.Items.Add("Yes");
                cboNewProblem.Items.Add("No");
                cboNewProblem.SelectedIndex = 0;

                cboMultipleProblems.Items.Add("Select Multiple Problems");
                cboMultipleProblems.Items.Add("Yes");
                cboMultipleProblems.Items.Add("No");
                cboMultipleProblems.SelectedIndex = 0;

                TheFindSortedEmployeeManagersDataSet = TheEmployeeClass.FindSortedEmployeeManagers();

                intNumberOfRecords = TheFindSortedEmployeeManagersDataSet.FindSortedEmployeeManagers.Rows.Count - 1;
                cboSelectManager.Items.Add("Select Manager");

                for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
                {
                    cboSelectManager.Items.Add(TheFindSortedEmployeeManagersDataSet.FindSortedEmployeeManagers[intCounter].FullName);
                }

                cboSelectManager.SelectedIndex = 0;

                TheFindEmployeeByDepartmentDataSet = TheEmployeeClass.FindEmployeeByDepartment("WAREHOUSE");

                intNumberOfRecords = TheFindEmployeeByDepartmentDataSet.FindEmployeeByDepartment.Rows.Count - 1;

                cboSelectFleetEmployee.Items.Add("Select Fleet Employee");

                for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
                {
                    strFullName  = TheFindEmployeeByDepartmentDataSet.FindEmployeeByDepartment[intCounter].FirstName + " ";
                    strFullName += TheFindEmployeeByDepartmentDataSet.FindEmployeeByDepartment[intCounter].LastName;

                    cboSelectFleetEmployee.Items.Add(strFullName);
                }

                cboSelectFleetEmployee.SelectedIndex = 0;

                TheFindOpenVehicleMainProblemsByVehicleIDDataSet = TheVehicleProblemClass.FindOpenVehicleMainProblemsByVehicleID(MainWindow.gintVehicleID);

                intNumberOfRecords = TheFindOpenVehicleMainProblemsByVehicleIDDataSet.FindOpenVehicleMainProblemsByVehicleID.Rows.Count - 1;

                if (intNumberOfRecords > -1)
                {
                    for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
                    {
                        ExistingOpenProblemsDataSet.openproblemsRow NewProblemRow = TheExistingOpenProblemsDataSet.openproblems.NewopenproblemsRow();

                        NewProblemRow.Problem   = TheFindOpenVehicleMainProblemsByVehicleIDDataSet.FindOpenVehicleMainProblemsByVehicleID[intCounter].Problem;
                        NewProblemRow.ProblemID = TheFindOpenVehicleMainProblemsByVehicleIDDataSet.FindOpenVehicleMainProblemsByVehicleID[intCounter].ProblemID;

                        TheExistingOpenProblemsDataSet.openproblems.Rows.Add(NewProblemRow);
                    }
                }

                dgrWorkOrders.ItemsSource = TheExistingOpenProblemsDataSet.openproblems;
            }
            catch (Exception Ex)
            {
                TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Daily Vehicle Data Entry // Vehicle Inspection Problem // Window Loaded " + Ex.Message);

                TheMessagesClass.ErrorMessage(Ex.ToString());
            }
        }
        private bool ProcessDailyVehicleInspection()
        {
            string   strValueForValidation;
            bool     blnThereIsAProblem = false;
            bool     blnFatalError      = false;
            string   strErrorMessage    = "";
            DateTime datTransactionDate = DateTime.Now;
            int      intRecordsReturned;
            string   strVehicleNumber;

            try
            {
                strValueForValidation = txtEnterDate.Text;
                blnThereIsAProblem    = TheDataValidationClass.VerifyDateData(strValueForValidation);
                if (blnThereIsAProblem == true)
                {
                    blnFatalError    = true;
                    strErrorMessage += "The Date is not a Date\n";
                }
                else
                {
                    datTransactionDate = Convert.ToDateTime(strValueForValidation);
                }
                strValueForValidation = txtEnterID.Text;
                blnThereIsAProblem    = TheDataValidationClass.VerifyIntegerData(strValueForValidation);
                if (cboSelectEmployee.SelectedIndex < 1)
                {
                    blnFatalError    = true;
                    strErrorMessage += "The Employee Was Not Selected\n";
                }
                strVehicleNumber = txtVehicleNumber.Text;
                if (strVehicleNumber.Length < 4)
                {
                    blnFatalError    = true;
                    strErrorMessage += "Vehicle Number is not Long Enough\n";
                }
                else
                {
                    TheFindActiveVehicleMainByVehicleNumberDataSet = TheVehicleMainClass.FindActiveVehicleMainByVehicleNumber(strVehicleNumber);

                    intRecordsReturned = TheFindActiveVehicleMainByVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber.Rows.Count;

                    if (intRecordsReturned < 1)
                    {
                        blnFatalError    = true;
                        strErrorMessage += "The Vehicle Was Not Found\n";
                    }
                    else
                    {
                        gintVehicleID = TheFindActiveVehicleMainByVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber[0].VehicleID;
                    }
                }
                strValueForValidation = txtOdometer.Text;
                blnThereIsAProblem    = TheDataValidationClass.VerifyIntegerData(strValueForValidation);
                if (blnThereIsAProblem == true)
                {
                    blnFatalError    = true;
                    strErrorMessage += "The Odometer is not a Integer\n";
                }
                else
                {
                    gintOdometerReading = Convert.ToInt32(strValueForValidation);
                }

                if (blnFatalError == true)
                {
                    TheMessagesClass.ErrorMessage(strErrorMessage);
                    return(blnFatalError);
                }

                TheFindDailyVehicleInspectionForGPSDataSet = TheInspectionsClass.FindDailyVehicleInspectionForGPS(gintVehicleID, datTransactionDate, gintEmployeeID, gstrInspectionStatus, gintOdometerReading);

                intRecordsReturned = TheFindDailyVehicleInspectionForGPSDataSet.FindDailyVehicleInspectionForGPS.Rows.Count;

                if (intRecordsReturned > 0)
                {
                    blnFatalError = true;
                    TheMessagesClass.ErrorMessage("This Inspection Has Been Entered\n");
                    return(blnFatalError);
                }

                if (gstrInspectionStatus == "PASSED")
                {
                    TheFindOpenVehicleMainProblemsByVehicleIDDataSet = TheVehicleProblemClass.FindOpenVehicleMainProblemsByVehicleID(gintVehicleID);

                    intRecordsReturned = TheFindOpenVehicleMainProblemsByVehicleIDDataSet.FindOpenVehicleMainProblemsByVehicleID.Rows.Count;

                    if (intRecordsReturned > 0)
                    {
                        blnFatalError = true;
                        TheMessagesClass.ErrorMessage("There are Open Vehicle Problems, The Inspection Will Not Be Processed");
                        return(blnFatalError);
                    }
                }

                blnFatalError = TheInspectionsClass.InsertDailyVehicleInspection(gintVehicleID, datTransactionDate, gintEmployeeID, gstrInspectionStatus, gintOdometerReading);

                if (blnFatalError == true)
                {
                    throw new Exception();
                }

                blnFatalError = TheVehicleHistoryClass.InsertVehicleHistory(gintVehicleID, gintEmployeeID, gintWarehouseEmployeeID);

                if (blnFatalError == true)
                {
                    throw new Exception();
                }

                TheFindDailyVehicleInspectionForGPSDataSet = TheInspectionsClass.FindDailyVehicleInspectionForGPS(gintVehicleID, datTransactionDate, gintEmployeeID, gstrInspectionStatus, gintOdometerReading);

                gintInspectionID = TheFindDailyVehicleInspectionForGPSDataSet.FindDailyVehicleInspectionForGPS[0].TransactionID;

                blnFatalError = TheInspectGPSClass.InsertInspectGPS(gintInspectionID, "DAILY", gblnGPSInstalled);

                if (blnFatalError == true)
                {
                    throw new Exception();
                }

                blnFatalError = TheVehicleMainClass.UpdateVehicleMainEmployeeID(gintVehicleID, gintEmployeeID);

                if (blnFatalError == true)
                {
                    throw new Exception();
                }

                if (gstrInspectionStatus == "PASSED SERVICE REQUIRED")
                {
                    VehicleInspectionProblem VehicleInspectionProblem = new VehicleInspectionProblem();
                    VehicleInspectionProblem.ShowDialog();
                }
            }
            catch (Exception Ex)
            {
                TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Daily Vehicle Data Entry // Main Window // Process Daily Vehicle Inspection " + Ex.Message);

                blnFatalError = true;
            }

            return(blnFatalError);
        }