コード例 #1
0
        private void txtEnterVehicleNumber_TextChanged(object sender, TextChangedEventArgs e)
        {
            //setting local variables
            string strValueForValidation;
            int    intBJCLength;
            int    intRecordsReturned;

            //data validation
            strValueForValidation = txtEnterVehicleNumber.Text;
            intBJCLength          = strValueForValidation.Length;
            ControlsEnabled(true);

            if (intBJCLength >= 4)
            {
                MainWindow.gstrVehicleNumber = strValueForValidation;

                TheFindActiveVehicleMainByVehicleNumberDataSet = TheVehicleMainClass.FindActiveVehicleMainByVehicleNumber(MainWindow.gstrVehicleNumber);

                intRecordsReturned = TheFindActiveVehicleMainByVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber.Rows.Count;

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

                    TheFindVehicleMainInShopByVehicleIDDataSet = TheVehiclesInShopClass.FindVehicleMainInShopByVehicleID(MainWindow.gintVehicleID);

                    intRecordsReturned = TheFindVehicleMainInShopByVehicleIDDataSet.FindVehicleMainInShopByVehicleID.Rows.Count;

                    if (intRecordsReturned > 0)
                    {
                        TheMessagesClass.ErrorMessage("Vehicle Is In Shop, Inspection Cannot Be Processed");
                        ControlsEnabled(false);
                        return;
                    }
                }
                else if (intBJCLength >= 6)
                {
                    if (intRecordsReturned == 0)
                    {
                        TheMessagesClass.ErrorMessage("Vehicle Not Found");
                        return;
                    }
                }
            }
        }
コード例 #2
0
        private void expProcess_Expanded_1(object sender, RoutedEventArgs e)
        {
            int      intVehicleCounter;
            int      intVehicleNumberOfRecords;
            int      intAutomileCounter;
            int      intAutomileNumberOfRecords;
            int      intVehicleID;
            string   strVehicleNumber;
            string   strAutomileVehicleNumber;
            bool     blnItemFound;
            bool     blnItemEntered;
            int      intThirdCounter;
            string   strInOrOut;
            string   strManager;
            string   strFullName;
            string   strAssignedOffice;
            DateTime datStartDate;
            DateTime datEndDate;
            int      intRecordsReturned;
            int      intManagerID;

            try
            {
                expProcess.IsExpanded = false;

                //loading the vehicle data set
                TheFindActiveVehicleMainDataSet = TheVehicleMainClass.FindActiveVehicleMain();
                TheVehicleCurrentStatusDataSet.vehiclecurrentstatus.Rows.Clear();
                TheShortedCurrentVehicleDataSet.shortenlist.Rows.Clear();

                datStartDate = DateTime.Now;
                datStartDate = TheDateSearchClass.RemoveTime(datStartDate);
                datEndDate   = TheDateSearchClass.AddingDays(datStartDate, 1);

                intVehicleNumberOfRecords  = TheFindActiveVehicleMainDataSet.FindActiveVehicleMain.Rows.Count - 1;
                intAutomileNumberOfRecords = TheAutomileImportDataSet.automileimport.Rows.Count - 1;
                gintThirdCounter           = 0;
                gintThirdNumberOfRecords   = 0;

                for (intVehicleCounter = 0; intVehicleCounter <= intVehicleNumberOfRecords; intVehicleCounter++)
                {
                    intVehicleID = TheFindActiveVehicleMainDataSet.FindActiveVehicleMain[intVehicleCounter].VehicleID;

                    if (intVehicleID != 9076)
                    {
                        strVehicleNumber = TheFindActiveVehicleMainDataSet.FindActiveVehicleMain[intVehicleCounter].VehicleNumber;

                        strAssignedOffice = TheFindActiveVehicleMainDataSet.FindActiveVehicleMain[intVehicleCounter].AssignedOffice;

                        TheFindCurrentAssignedVehicleMainByVehicleIDDataSet = TheVehicleAssignmentClass.FindCurrentAssignedVehicleMainByVehicleID(intVehicleID);

                        strFullName  = TheFindCurrentAssignedVehicleMainByVehicleIDDataSet.FindCurrentAssignedVehicleMainByVehicleID[0].FirstName + " ";
                        strFullName += TheFindCurrentAssignedVehicleMainByVehicleIDDataSet.FindCurrentAssignedVehicleMainByVehicleID[0].LastName;
                        intManagerID = TheFindCurrentAssignedVehicleMainByVehicleIDDataSet.FindCurrentAssignedVehicleMainByVehicleID[0].ManagerID;

                        TheFindEnmployeeByEmployeeIDDataSet = TheEmployeeClass.FindEmployeeByEmployeeID(intManagerID);

                        strManager  = TheFindEnmployeeByEmployeeIDDataSet.FindEmployeeByEmployeeID[0].FirstName + " ";
                        strManager += TheFindEnmployeeByEmployeeIDDataSet.FindEmployeeByEmployeeID[0].LastName;
                        strInOrOut  = "UNKNOWN";

                        if (TheFindCurrentAssignedVehicleMainByVehicleIDDataSet.FindCurrentAssignedVehicleMainByVehicleID[0].LastName == "WAREHOUSE")
                        {
                            strManager = "FLEET MANAGER";
                        }

                        TheFindVehicleInShopByVehicleIDDataSet = TheVehiclesInShopClass.FindVehicleMainInShopByVehicleID(intVehicleID);

                        TheFindVehicleInYardByVehicleIDAndDateRangeDataSet = TheVehicleInYardClass.FindVehiclesInYardByVehicleIDAndDateRange(intVehicleID, datStartDate, datEndDate);

                        intRecordsReturned = TheFindVehicleInYardByVehicleIDAndDateRangeDataSet.FindVehiclesInYardByVehicleIDAndDateRange.Rows.Count;

                        if (intRecordsReturned > 0)
                        {
                            strInOrOut = "IN YARD";
                        }

                        blnItemEntered = false;

                        for (intAutomileCounter = 0; intAutomileCounter <= intAutomileNumberOfRecords; intAutomileCounter++)
                        {
                            strAutomileVehicleNumber = TheAutomileImportDataSet.automileimport[intAutomileCounter].VehicleNumber;

                            blnItemFound = strAutomileVehicleNumber.Contains(strVehicleNumber);

                            if (blnItemFound == true)
                            {
                                strInOrOut = TheAutomileImportDataSet.automileimport[intAutomileCounter].IsInside;

                                if (strInOrOut == "YES")
                                {
                                    strInOrOut = "IN YARD";
                                }
                                else if (strInOrOut == "NO")
                                {
                                    strInOrOut = "OUT";
                                }

                                if (gintThirdCounter > 0)
                                {
                                    for (intThirdCounter = 0; gintThirdCounter <= gintThirdNumberOfRecords; intThirdCounter++)
                                    {
                                        if (strVehicleNumber == TheVehicleCurrentStatusDataSet.vehiclecurrentstatus[intThirdCounter].VehicleNumber)
                                        {
                                            if (strInOrOut == "YES")
                                            {
                                                TheVehicleCurrentStatusDataSet.vehiclecurrentstatus[intThirdCounter].InOrOut = "IN YARD";
                                            }
                                            else if (strInOrOut == "NO")
                                            {
                                                TheVehicleCurrentStatusDataSet.vehiclecurrentstatus[intThirdCounter].InOrOut = strInOrOut;
                                            }

                                            blnItemEntered = true;
                                        }
                                    }
                                }
                            }
                        }


                        intRecordsReturned = TheFindVehicleInShopByVehicleIDDataSet.FindVehicleMainInShopByVehicleID.Rows.Count;

                        if (intRecordsReturned > 0)
                        {
                            strInOrOut = "IN SHOP";
                        }

                        if (blnItemEntered == false)
                        {
                            VehicleCurrentStatusDataSet.vehiclecurrentstatusRow NewVehicleRow = TheVehicleCurrentStatusDataSet.vehiclecurrentstatus.NewvehiclecurrentstatusRow();

                            NewVehicleRow.AssignedOffice = strAssignedOffice;
                            NewVehicleRow.Manager        = strManager;
                            NewVehicleRow.Driver         = strFullName;
                            NewVehicleRow.InOrOut        = strInOrOut;
                            NewVehicleRow.VehicleNumber  = strVehicleNumber;

                            TheVehicleCurrentStatusDataSet.vehiclecurrentstatus.Rows.Add(NewVehicleRow);

                            ShortedCurrentVehicleDataSet.shortenlistRow SecondVehicleRow = TheShortedCurrentVehicleDataSet.shortenlist.NewshortenlistRow();

                            SecondVehicleRow.Driver        = strFullName;
                            SecondVehicleRow.VehicleNumber = strVehicleNumber;
                            SecondVehicleRow.InOrOut       = strInOrOut;

                            TheShortedCurrentVehicleDataSet.shortenlist.Rows.Add(SecondVehicleRow);
                        }
                    }
                }

                TheMessagesClass.InformationMessage("Processing the Report Is Completed");

                dgrResults.ItemsSource = TheVehicleCurrentStatusDataSet.vehiclecurrentstatus;
            }
            catch (Exception Ex)
            {
                TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Four Thirty Report // Main Window // Process Expander " + Ex.Message);

                TheMessagesClass.ErrorMessage(Ex.ToString());
            }
        }
コード例 #3
0
        private void TxtVehicleNumber_TextChanged(object sender, TextChangedEventArgs e)
        {
            string strVehicleNumber;
            int    intLength;
            bool   blnItemFound = false;
            int    intCounter;
            int    intNumberOfRecords;
            int    intRecordsReturned;

            try
            {
                strVehicleNumber = txtVehicleNumber.Text;
                intLength        = strVehicleNumber.Length;

                if (intLength == 4)
                {
                    blnItemFound = FindVehicle(strVehicleNumber);
                }
                else if (intLength == 6)
                {
                    blnItemFound = FindVehicle(strVehicleNumber);
                    if (blnItemFound == false)
                    {
                        TheMessagesClass.InformationMessage("Vehicle Number Not Found");
                        return;
                    }
                }

                if (blnItemFound == true)
                {
                    TheFindVehicleMainInShopByVehicleIDDataSet = TheVehiclesInShopClass.FindVehicleMainInShopByVehicleID(MainWindow.gintVehicleID);

                    intRecordsReturned = TheFindVehicleMainInShopByVehicleIDDataSet.FindVehicleMainInShopByVehicleID.Rows.Count;

                    if (intRecordsReturned > 0)
                    {
                        TheMessagesClass.ErrorMessage("THE VEHICLE IS STILL IN THE SHOP");
                        ResetControls();
                        return;
                    }

                    TheOpenVehicleProblemsDataSet.openvehicleproblem.Rows.Clear();

                    TheFindVehicleMainProblemReadyForInvoicingDataSet = TheVehicleProblemClass.FindVehicleMainProblemReadyForInvoicing(MainWindow.gintVehicleID);

                    intNumberOfRecords = TheFindVehicleMainProblemReadyForInvoicingDataSet.FindVehicleMainProblemReadyForInvoicing.Rows.Count - 1;

                    if (intNumberOfRecords > -1)
                    {
                        for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
                        {
                            OpenVehicleProblemsDataSet.openvehicleproblemRow NewProblemRow = TheOpenVehicleProblemsDataSet.openvehicleproblem.NewopenvehicleproblemRow();

                            NewProblemRow.Problem     = TheFindVehicleMainProblemReadyForInvoicingDataSet.FindVehicleMainProblemReadyForInvoicing[intCounter].Problem;
                            NewProblemRow.ProblemDate = TheFindVehicleMainProblemReadyForInvoicingDataSet.FindVehicleMainProblemReadyForInvoicing[intCounter].TransactionDAte;
                            NewProblemRow.ProblemID   = TheFindVehicleMainProblemReadyForInvoicingDataSet.FindVehicleMainProblemReadyForInvoicing[intCounter].ProblemID;
                            NewProblemRow.Status      = TheFindVehicleMainProblemReadyForInvoicingDataSet.FindVehicleMainProblemReadyForInvoicing[intCounter].ProblemStatus;
                            NewProblemRow.Vendor      = TheFindVehicleMainProblemReadyForInvoicingDataSet.FindVehicleMainProblemReadyForInvoicing[intCounter].VendorName;
                            NewProblemRow.Selected    = false;

                            TheOpenVehicleProblemsDataSet.openvehicleproblem.Rows.Add(NewProblemRow);
                        }
                    }

                    dgrResults.ItemsSource      = TheOpenVehicleProblemsDataSet.openvehicleproblem;
                    cboVendor.IsEnabled         = true;
                    cboAttachInvoice.IsEnabled  = true;
                    mitProcessInvoice.IsEnabled = true;
                }
            }
            catch (Exception Ex)
            {
                TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // Invoice Vehicle Problems // Vehicle Number Text Box " + Ex.Message);

                TheMessagesClass.ErrorMessage(Ex.ToString());
            }
        }
コード例 #4
0
        private void mitGenerateReport_Click(object sender, RoutedEventArgs e)
        {
            int      intCounter;
            int      intNumberOfRecords;
            int      intVehicleID;
            int      intRecordsReturned;
            DateTime datStartDate = DateTime.Now;
            DateTime datEndDate;
            string   strFirstNamed = "";
            string   strLastName   = "";

            try
            {
                TheVehicleExceptionDataSet.vehicleexception.Rows.Clear();

                datStartDate = TheDateSearchClass.RemoveTime(datStartDate);

                datEndDate = TheDateSearchClass.AddingDays(datStartDate, 1);

                TheFindActiveVehicleMainDataSet = TheVehicleMainClass.FindActiveVehicleMain();

                intNumberOfRecords = TheFindActiveVehicleMainDataSet.FindActiveVehicleMain.Rows.Count - 1;

                for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
                {
                    intVehicleID = TheFindActiveVehicleMainDataSet.FindActiveVehicleMain[intCounter].VehicleID;

                    TheFindDailyVehicleInspectionByVehicleIDAndDateRangeDataSete = TheInspectionClass.FindDailyVehicleInspectionByVehicleIDAndDateRange(intVehicleID, datStartDate, datEndDate);

                    intRecordsReturned = TheFindDailyVehicleInspectionByVehicleIDAndDateRangeDataSete.FindDailyVehicleInspectionsByVehicleIDAndDateRange.Rows.Count;

                    if (intRecordsReturned == 0)
                    {
                        TheFindVehicleInYardByVehicleIDAndDateRangeDataSet = TheVehicleInYardClass.FindVehiclesInYardByVehicleIDAndDateRange(intVehicleID, datStartDate, datEndDate);

                        intRecordsReturned = TheFindVehicleInYardByVehicleIDAndDateRangeDataSet.FindVehiclesInYardByVehicleIDAndDateRange.Rows.Count;

                        if (intRecordsReturned == 0)
                        {
                            TheFindVehicleMainInShopByVehicleIDDataSet = TheVehicleInShopClass.FindVehicleMainInShopByVehicleID(intVehicleID);

                            intRecordsReturned = TheFindVehicleMainInShopByVehicleIDDataSet.FindVehicleMainInShopByVehicleID.Rows.Count;

                            if (intRecordsReturned == 0)
                            {
                                TheFindcurrentAssignedVehicleMainByVehicleIDDataSet = TheVehicleAssignmentClass.FindCurrentAssignedVehicleMainByVehicleID(intVehicleID);

                                intRecordsReturned = TheFindcurrentAssignedVehicleMainByVehicleIDDataSet.FindCurrentAssignedVehicleMainByVehicleID.Rows.Count;

                                if (intRecordsReturned == 0)
                                {
                                    strLastName   = "NOT ASSIGNED";
                                    strFirstNamed = "NOT ASSIGNED";
                                }
                                else
                                {
                                    strLastName   = TheFindcurrentAssignedVehicleMainByVehicleIDDataSet.FindCurrentAssignedVehicleMainByVehicleID[0].LastName;
                                    strFirstNamed = TheFindcurrentAssignedVehicleMainByVehicleIDDataSet.FindCurrentAssignedVehicleMainByVehicleID[0].FirstName;
                                }

                                VehicleExceptionDataSet.vehicleexceptionRow NewVehicleRow = TheVehicleExceptionDataSet.vehicleexception.NewvehicleexceptionRow();

                                NewVehicleRow.AssignedOffice = TheFindActiveVehicleMainDataSet.FindActiveVehicleMain[intCounter].AssignedOffice;
                                NewVehicleRow.FirstName      = strFirstNamed;
                                NewVehicleRow.LastName       = strLastName;
                                NewVehicleRow.VehicleID      = intVehicleID;
                                NewVehicleRow.VehicleNumber  = TheFindActiveVehicleMainDataSet.FindActiveVehicleMain[intCounter].VehicleNumber;

                                TheVehicleExceptionDataSet.vehicleexception.Rows.Add(NewVehicleRow);
                            }
                        }
                    }
                }

                dgrResults.ItemsSource = TheVehicleExceptionDataSet.vehicleexception;
            }
            catch (Exception Ex)
            {
                TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // Vehicle Exception Report // Generate The Report Menu Item " + Ex.Message);

                TheMessagesClass.ErrorMessage(Ex.ToString());
            }
        }