private void expImportParts_Expanded(object sender, RoutedEventArgs e)
        {
            Excel.Application xlDropOrder;
            Excel.Workbook    xlDropBook;
            Excel.Worksheet   xlDropSheet;
            Excel.Range       range;

            int     intColumnRange = 0;
            int     intCounter;
            int     intNumberOfRecords;
            string  strPartID;
            int     intPartID;
            string  strPartNumber;
            string  strJDEPartNumber;
            string  strPartDescription;
            string  strPartPrice;
            decimal decPartPrice;

            try
            {
                ThePartPriceImportDataSet.partpriceimport.Rows.Clear();

                Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();
                dlg.FileName   = "Document";             // Default file name
                dlg.DefaultExt = ".xlsx";                // Default file extension
                dlg.Filter     = "Excel (.xlsx)|*.xlsx"; // Filter files by extension

                // Show open file dialog box
                Nullable <bool> result = dlg.ShowDialog();

                // Process open file dialog box results
                if (result == true)
                {
                    // Open document
                    string filename = dlg.FileName;
                }

                PleaseWait PleaseWait = new PleaseWait();
                PleaseWait.Show();

                xlDropOrder = new Excel.Application();
                xlDropBook  = xlDropOrder.Workbooks.Open(dlg.FileName, 0, true, 5, "", "", true, Microsoft.Office.Interop.Excel.XlPlatform.xlWindows, "\t", false, false, 0, true, 1, 0);
                xlDropSheet = (Excel.Worksheet)xlDropOrder.Worksheets.get_Item(1);

                range = xlDropSheet.UsedRange;
                intNumberOfRecords = range.Rows.Count;
                intColumnRange     = range.Columns.Count;

                for (intCounter = 2; intCounter <= intNumberOfRecords; intCounter++)
                {
                    strPartID          = Convert.ToString((range.Cells[intCounter, 1] as Excel.Range).Value2).ToUpper();
                    intPartID          = Convert.ToInt32(strPartID);
                    strPartNumber      = Convert.ToString((range.Cells[intCounter, 2] as Excel.Range).Value2).ToUpper();
                    strJDEPartNumber   = Convert.ToString((range.Cells[intCounter, 3] as Excel.Range).Value2).ToUpper();
                    strPartDescription = Convert.ToString((range.Cells[intCounter, 4] as Excel.Range).Value2).ToUpper();
                    strPartPrice       = Convert.ToString((range.Cells[intCounter, 5] as Excel.Range).Value2).ToUpper();
                    decPartPrice       = Convert.ToDecimal(strPartPrice);

                    decPartPrice = Math.Round(decPartPrice, 2);

                    PartPriceImportDataSet.partpriceimportRow NewPartRow = ThePartPriceImportDataSet.partpriceimport.NewpartpriceimportRow();

                    NewPartRow.PartID          = intPartID;
                    NewPartRow.PartNumber      = strPartNumber;
                    NewPartRow.JDEPartNumber   = strJDEPartNumber;
                    NewPartRow.PartDescription = strPartDescription;
                    NewPartRow.PartPrice       = decPartPrice;

                    ThePartPriceImportDataSet.partpriceimport.Rows.Add(NewPartRow);
                }

                dgrParts.ItemsSource = ThePartPriceImportDataSet.partpriceimport;

                PleaseWait.Close();
            }
            catch (Exception Ex)
            {
                TheEventLogClass.InsertEventLogEntry(DateTime.Now, "New Blue Jay ERP // Import Prices // Import Parts  " + Ex.Message);

                TheMessagesClass.ErrorMessage(Ex.ToString());
            }
        }
Exemple #2
0
        private void cboSelectAssetLocation_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            Excel.Application xlDropOrder;
            Excel.Workbook    xlDropBook;
            Excel.Worksheet   xlDropSheet;
            Excel.Range       range;

            int    intColumnRange = 0;
            int    intCounter;
            int    intNumberOfRecords;
            int    intRecordsReturned;
            int    intAssetID;
            string strAssetDescription;
            string strSerialNumber;
            string strAssetType;
            string strBJCNumber;
            bool   blnFatalError   = false;
            string strErrorMessage = "";
            bool   blnItemFound;
            int    intTransactionID;
            string strModel;
            string strManufacturer;
            int    intSelectedIndex;

            try
            {
                PleaseWait PleaseWait = new PleaseWait();
                PleaseWait.Show();

                intSelectedIndex = cboSelectAssetLocation.SelectedIndex - 1;

                if (intSelectedIndex > -1)
                {
                    TheImportWaspToolAssetsDataSet.importassets.Rows.Clear();

                    Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();
                    dlg.FileName   = "Document";             // Default file name
                    dlg.DefaultExt = ".xlsx";                // Default file extension
                    dlg.Filter     = "Excel (.xlsx)|*.xlsx"; // Filter files by extension

                    // Show open file dialog box
                    Nullable <bool> result = dlg.ShowDialog();

                    // Process open file dialog box results
                    if (result == true)
                    {
                        // Open document
                        string filename = dlg.FileName;
                    }

                    MainWindow.gstrAssetLocation = TheFindWaspAssetLocationBySiteDataSet.FindWaspAssetLocationBySite[intSelectedIndex].AssetLocation;
                    if (MainWindow.gstrAssetLocation.Length < 2)
                    {
                        blnFatalError    = true;
                        strErrorMessage += "The Location is not long Enough\n";
                    }
                    else
                    {
                        TheFindWaspAssetLocationByLocationDataSet = TheAssetClass.FindWaspAssetLocationByLocation(MainWindow.gstrAssetLocation);

                        intRecordsReturned = TheFindWaspAssetLocationByLocationDataSet.FindWaspAssetLocationByLocation.Rows.Count;

                        if (intRecordsReturned < 1)
                        {
                            blnFatalError    = true;
                            strErrorMessage += "There is no Such Location\n";
                        }
                    }
                    if (cboSelectLocation.SelectedIndex < 1)
                    {
                        blnFatalError    = true;
                        strErrorMessage += "The Site Has Not Been Selected\n";
                    }
                    if (blnFatalError == true)
                    {
                        TheMessagesClass.ErrorMessage(strErrorMessage);
                        return;
                    }

                    xlDropOrder = new Excel.Application();
                    xlDropBook  = xlDropOrder.Workbooks.Open(dlg.FileName, 0, true, 5, "", "", true, Microsoft.Office.Interop.Excel.XlPlatform.xlWindows, "\t", false, false, 0, true, 1, 0);
                    xlDropSheet = (Excel.Worksheet)xlDropOrder.Worksheets.get_Item(1);

                    range = xlDropSheet.UsedRange;
                    intNumberOfRecords = range.Rows.Count;
                    intColumnRange     = range.Columns.Count;

                    for (intCounter = 1; intCounter <= intNumberOfRecords; intCounter++)
                    {
                        TheWaspAssetIDDataSet = TheAssetClass.GetWaspAssetIDInfo();

                        intAssetID       = TheWaspAssetIDDataSet.waspassetid[0].CreatedAssetID;
                        intTransactionID = TheWaspAssetIDDataSet.waspassetid[0].TransactionID;

                        blnFatalError = TheAssetClass.UpdateWaspAssetID(intTransactionID, intAssetID + 1);

                        blnItemFound = false;
                        strAssetType = "UNKNOWN";

                        if (((range.Cells[intCounter, 2] as Excel.Range).Value2) == null)
                        {
                            intCounter = intNumberOfRecords;
                            break;
                        }
                        else
                        {
                            strAssetDescription = Convert.ToString((range.Cells[intCounter, 2] as Excel.Range).Value2).ToUpper();

                            if (((range.Cells[intCounter, 3] as Excel.Range).Value2) == null)
                            {
                                strSerialNumber = " ";
                            }
                            else
                            {
                                strSerialNumber = Convert.ToString((range.Cells[intCounter, 3] as Excel.Range).Value2).ToUpper();
                            }
                            if (((range.Cells[intCounter, 4] as Excel.Range).Value2) == null)
                            {
                                strBJCNumber = " ";
                            }
                            else
                            {
                                strBJCNumber = Convert.ToString((range.Cells[intCounter, 4] as Excel.Range).Value2).ToUpper();
                            }

                            if (strSerialNumber.Length > 2)
                            {
                                TheFindWaspAssetBySerialNumberDataSet = TheAssetClass.FindWaspAssetsBySerialNumber(strSerialNumber);

                                intRecordsReturned = TheFindWaspAssetBySerialNumberDataSet.FindWaspAssetsBySerialNumber.Rows.Count;

                                if (intRecordsReturned > 0)
                                {
                                    blnItemFound = true;
                                }
                            }
                            if (strBJCNumber.Length > 2)
                            {
                                TheFindWaspAssetByBJCAssetIDDataSet = TheAssetClass.FindWaspAssetByBJCAssetID(strBJCNumber);

                                intRecordsReturned = TheFindWaspAssetByBJCAssetIDDataSet.FindWaspAssetByBJCAssetID.Rows.Count;

                                if (intRecordsReturned > 0)
                                {
                                    blnItemFound = true;
                                }
                            }
                        }

                        if (blnItemFound == false)
                        {
                            if (strBJCNumber.Length > 2)
                            {
                                TheFindActiveToolByToolIDDataSet = TheToolsClass.FindActiveToolByToolID(strBJCNumber);

                                intRecordsReturned = TheFindActiveToolByToolIDDataSet.FindActiveToolByToolID.Rows.Count;

                                if (intRecordsReturned > 0)
                                {
                                    strAssetType        = TheFindActiveToolByToolIDDataSet.FindActiveToolByToolID[0].ToolCategory;
                                    strAssetDescription = TheFindActiveToolByToolIDDataSet.FindActiveToolByToolID[0].ToolDescription;
                                }
                            }

                            ImportWaspToolAssetsDataSet.importassetsRow NewAssetRow = TheImportWaspToolAssetsDataSet.importassets.NewimportassetsRow();

                            NewAssetRow.AssetDescription = strAssetDescription;
                            NewAssetRow.AssetID          = intAssetID;
                            NewAssetRow.AssetType        = strAssetType;
                            NewAssetRow.Location         = MainWindow.gstrAssetLocation;
                            NewAssetRow.Manufacturer     = "UNKNOWN";
                            NewAssetRow.Model            = "UNKNOWN";
                            NewAssetRow.SerialNumber     = strSerialNumber;
                            NewAssetRow.Site             = gstrSite;
                            NewAssetRow.WarehouseID      = MainWindow.gintWarehouseID;
                            NewAssetRow.BJCAssetID       = strBJCNumber;

                            TheImportWaspToolAssetsDataSet.importassets.Rows.Add(NewAssetRow);
                        }
                    }

                    intNumberOfRecords = TheImportWaspToolAssetsDataSet.importassets.Rows.Count;

                    if (intNumberOfRecords > 0)
                    {
                        for (intCounter = 0; intCounter < intNumberOfRecords; intCounter++)
                        {
                            strAssetDescription = TheImportWaspToolAssetsDataSet.importassets[intCounter].AssetDescription;
                            strAssetType        = TheImportWaspToolAssetsDataSet.importassets[intCounter].AssetType;
                            intAssetID          = TheImportWaspToolAssetsDataSet.importassets[intCounter].AssetID;
                            strBJCNumber        = TheImportWaspToolAssetsDataSet.importassets[intCounter].BJCAssetID;
                            strManufacturer     = TheImportWaspToolAssetsDataSet.importassets[intCounter].Manufacturer;
                            strModel            = TheImportWaspToolAssetsDataSet.importassets[intCounter].Model;
                            strSerialNumber     = TheImportWaspToolAssetsDataSet.importassets[intCounter].SerialNumber;

                            blnFatalError = TheAssetClass.InsertWaspAssets(intAssetID, strAssetDescription, strBJCNumber, strAssetType, gstrSite, MainWindow.gstrAssetLocation, MainWindow.gintWarehouseID, DateTime.Now, strSerialNumber, strManufacturer, strModel);

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



                PleaseWait.Close();

                dgrAssets.ItemsSource = TheImportWaspToolAssetsDataSet.importassets;
            }
            catch (Exception Ex)
            {
                TheEventLogClass.InsertEventLogEntry(DateTime.Now, "New Blue Jay ERP // Import Vehicle Assets // Import Excel  " + Ex.Message);

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