예제 #1
0
        private void bwCheckOutsoleCode_DoWork(object sender, DoWorkEventArgs e)
        {
            var sizeRunList = SizeRunController.SelectIsEnable().Where(w => String.IsNullOrEmpty(w.OutsoleSize) == true).ToList();
            var orderList   = OrdersController.Select();

            Dispatcher.Invoke(new Action(() =>
            {
                if (sizeRunList.Count == 0)
                {
                    MessageBox.Show("Empty !", "Checking Result", MessageBoxButton.OK, MessageBoxImage.Information);
                    this.Cursor = null;
                    btnCheckOutsoleCodeNotYetUpdateSizeOutsole.IsEnabled = true;
                    return;
                }

                var productNoList   = sizeRunList.Select(s => s.ProductNo).Distinct().ToList();
                var outsoleCodeList = orderList.Where(w => productNoList.Contains(w.ProductNo)).Select(s => s.OutsoleCode).Distinct().ToList();
                MessageBox.Show(String.Format("Outsole Code List:\n{0}", String.Join("\n", outsoleCodeList)), "Checking Result", MessageBoxButton.OK, MessageBoxImage.Information);
            }));
        }
        private void bwLoadData_DoWork(object sender, DoWorkEventArgs e)
        {
            outsoleMaterialList        = OutsoleMaterialController.Select();
            outsoleReleaseMaterialList = OutsoleReleaseMaterialController.SelectByOutsoleMaterial();
            outsoleOutputList          = OutsoleOutputController.SelectByAssemblyMaster();
            outsoleMasterList          = OutsoleMasterController.Select();
            orderList           = OrdersController.Select();
            outsoleSupplierList = OutsoleSuppliersController.Select();
            assemblyReleaseList = AssemblyReleaseController.SelectByAssemblyMaster();
            sizeRunList         = SizeRunController.SelectIsEnable();

            inventoryByOSCodeList = ReportController.InventoryByOutsoleCode();
            inventoryByOSLineList = ReportController.InventoryByOutsoleLine();

            foreach (var inven in inventoryByOSCodeList)
            {
                inven.ProductNoList = orderList.Where(w => w.OutsoleCode == inven.OutsoleCode).Select(s => s.ProductNo).Distinct().ToList();
            }
            foreach (var inven in inventoryByOSLineList)
            {
                inven.ProductNoList = outsoleMasterList.Where(w => w.OutsoleLine == inven.OutsoleLine).Select(s => s.ProductNo).Distinct().ToList();
                inven.OutsoleCode   = inven.OutsoleLine;
            }
        }
        private void bwLoadData_DoWork(object sender, DoWorkEventArgs e)
        {
            assemblyMasterList          = AssemblyMasterController.Select();
            sewingOutputList            = SewingOutputController.SelectByAssemblyMaster();
            outsoleOutputList           = OutsoleOutputController.SelectByAssemblyMaster();
            assemblyReleaseList         = AssemblyReleaseController.SelectByAssemblyMaster();
            orderList                   = OrdersController.Select();
            sockliningInputList         = SockliningInputController.SelectByAssemblyMaster();
            sizeRunList                 = SizeRunController.SelectIsEnable();
            rawMaterialViewModelNewList = RawMaterialController.Select_1();

            List <UpperWHInventoryViewModel> upperWHInventoryList   = new List <UpperWHInventoryViewModel>();
            List <UpperWHInventoryViewModel> upperWHInventoryList_1 = new List <UpperWHInventoryViewModel>();
            var POList = orderList.Select(s => s.ProductNo).Distinct().ToList();

            foreach (var productNo in POList)
            {
                var assemblyMaster_PO  = assemblyMasterList.FirstOrDefault(w => w.ProductNo == productNo);
                var assemblyRelease_PO = assemblyReleaseList.Where(w => w.ProductNo == productNo).ToList();
                var sewingOutput_PO    = sewingOutputList.Where(w => w.ProductNo == productNo).ToList();
                var outsoleOutput_PO   = outsoleOutputList.Where(w => w.ProductNo == productNo).ToList();
                var sockliningInput_PO = sockliningInputList.Where(w => w.ProductNo == productNo).ToList();
                var sizeNoList         = sizeRunList.Where(w => w.ProductNo == productNo).Select(s => s.SizeNo).ToList();

                int qtyUpper_PO = 0, qtyOutsole_PO = 0, qtySocklining_PO = 0, qtyMatch_PO = 0, qtyMatchWithSocklining_PO = 0;
                foreach (var sizeNo in sizeNoList)
                {
                    int qtyAssemblyRelease_Size = assemblyRelease_PO.Where(w => w.SizeNo == sizeNo).Sum(s => s.Quantity);
                    int qtySewingOutput_Size    = sewingOutput_PO.Where(w => w.SizeNo == sizeNo).Sum(s => s.Quantity);
                    int qtyOutsoleOutput_Size   = outsoleOutput_PO.Where(w => w.SizeNo == sizeNo).Sum(s => s.Quantity);
                    int qtySocklining_Size      = sockliningInput_PO.Where(w => w.SizeNo == sizeNo).Sum(s => s.Quantity);

                    int qtyUpper = qtySewingOutput_Size - qtyAssemblyRelease_Size;
                    if (qtyUpper < 0)
                    {
                        qtyUpper = 0;
                    }
                    qtyUpper_PO += qtyUpper;

                    int qtyOutsole = qtyOutsoleOutput_Size - qtyAssemblyRelease_Size;
                    if (qtyOutsole < 0)
                    {
                        qtyOutsole = 0;
                    }
                    qtyOutsole_PO += qtyOutsole;

                    int qtySocklining = qtySocklining_Size - qtyAssemblyRelease_Size;
                    if (qtySocklining < 0)
                    {
                        qtySocklining = 0;
                    }
                    qtySocklining_PO += qtySocklining;

                    int qtyMatch = Math.Min(qtySewingOutput_Size, qtyOutsoleOutput_Size) - qtyAssemblyRelease_Size;
                    if (qtyMatch < 0)
                    {
                        qtyMatch = 0;
                    }
                    qtyMatch_PO += qtyMatch;

                    List <Int32> materialList = new List <Int32>();
                    materialList.Add(qtySewingOutput_Size > 0 ? qtySewingOutput_Size : 0);
                    materialList.Add(qtyOutsoleOutput_Size > 0 ? qtyOutsoleOutput_Size : 0);
                    materialList.Add(qtySocklining_Size > 0 ? qtySocklining_Size : 0);

                    int qtyMatchWithSocklining = materialList.Min() - qtyAssemblyRelease_Size;
                    if (qtyMatchWithSocklining < 0)
                    {
                        qtyMatchWithSocklining = 0;
                    }
                    qtyMatchWithSocklining_PO += qtyMatchWithSocklining;
                }

                string assemblyLine_PO   = assemblyMaster_PO != null ? assemblyMaster_PO.AssemblyLine : "";
                var    upperInventory_PO = new UpperWHInventoryViewModel()
                {
                    AssemblyLine           = assemblyLine_PO,
                    SewingOutput           = qtyUpper_PO,
                    OutsoleOutput          = qtyOutsole_PO,
                    SockliningInput        = qtySocklining_PO,
                    Matching               = qtyMatch_PO,
                    MatchingWithSocklining = qtyMatchWithSocklining_PO,
                };
                upperWHInventoryList.Add(upperInventory_PO);
            }

            var assemblyLineList = upperWHInventoryList.Select(s => s.AssemblyLine).Distinct().ToList();

            if (assemblyLineList.Count() > 0)
            {
                assemblyLineList = assemblyLineList.OrderBy(o => o).ToList();
            }
            var regex = new Regex(@"\D");
            var assemblyLineCustomList = assemblyLineList.Select(s => new { Line = s, LineNumber = regex.IsMatch(s) ? regex.Replace(s, "") : s }).ToList();

            if (assemblyLineCustomList.Count() > 0)
            {
                assemblyLineCustomList = assemblyLineCustomList.OrderBy(o => String.IsNullOrEmpty(o.LineNumber) ? 100 : Int32.Parse(o.LineNumber)).ThenBy(th => th.Line).ToList();
            }

            foreach (var assemblyLineCustom in assemblyLineCustomList)
            {
                var assemblyLine = assemblyLineCustom.Line;
                var upperWHInventoryByAssemblyLine = upperWHInventoryList.Where(w => w.AssemblyLine == assemblyLine).ToList();
                var productNoList_Assembly         = assemblyMasterList.Where(w => w.AssemblyLine == assemblyLine).Select(s => s.ProductNo).Distinct().ToList();
                var upperInventory = new UpperWHInventoryViewModel()
                {
                    AssemblyLine    = assemblyLine,
                    ProductNoList   = productNoList_Assembly,
                    SewingOutput    = upperWHInventoryByAssemblyLine.Sum(s => s.SewingOutput),
                    OutsoleOutput   = upperWHInventoryByAssemblyLine.Sum(s => s.OutsoleOutput),
                    SockliningInput = upperWHInventoryByAssemblyLine.Sum(s => s.SockliningInput),
                    Matching        = upperWHInventoryByAssemblyLine.Sum(s => s.Matching),
                };
                upperWHInventoryViewList.Add(upperInventory);

                var upperInventory_1 = new UpperWHInventoryViewModel()
                {
                    AssemblyLine    = assemblyLine,
                    ProductNoList   = productNoList_Assembly,
                    SewingOutput    = upperWHInventoryByAssemblyLine.Sum(s => s.SewingOutput),
                    OutsoleOutput   = upperWHInventoryByAssemblyLine.Sum(s => s.OutsoleOutput),
                    SockliningInput = upperWHInventoryByAssemblyLine.Sum(s => s.SockliningInput),
                    Matching        = upperWHInventoryByAssemblyLine.Sum(s => s.MatchingWithSocklining),
                };
                upperWHInventoryViewList_WithSocklining.Add(upperInventory_1);
            }
        }
        private void bwLoad_DoWork(object sender, DoWorkEventArgs e)
        {
            outsoleSupplierList = OutsoleSuppliersController.Select();
            sizeRunList         = SizeRunController.SelectByOutsoleRawMaterial();
            sizeRunAllList      = SizeRunController.SelectIsEnable();

            sewingMasterList    = SewingMasterController.Select();
            outsoleMaterialList = OutsoleMaterialController.Select().Where(w => productNoList.Contains(w.ProductNo) && w.OutsoleSupplierId == supplierID).ToList();

            // additional.
            var productNoList_OutsoleCode  = orderList.Where(w => w.OutsoleCode == outsoleCode).Select(s => s.ProductNo).ToList();
            var sizeRunAllList_OutsoleCode = sizeRunAllList.Where(w => productNoList_OutsoleCode.Contains(w.ProductNo)).ToList();

            DataTable dt = new DataTable();

            Dispatcher.Invoke(new Action(() =>
            {
                dgInventory.Columns.Clear();

                dt.Columns.Add("ProductNo", typeof(String));
                DataGridTextColumn columnProductNo = new DataGridTextColumn();
                columnProductNo.Header             = "PO No.";
                columnProductNo.Width = 100;

                //Style
                Style styleColumnProductNo = new Style(typeof(DataGridCell));

                Setter setterColumnProductNoForeground   = new Setter();
                setterColumnProductNoForeground.Property = DataGridCell.ForegroundProperty;
                setterColumnProductNoForeground.Value    = Brushes.Black;
                styleColumnProductNo.Setters.Add(setterColumnProductNoForeground);

                Setter setterColumnProductNoBackground   = new Setter();
                setterColumnProductNoBackground.Property = DataGridCell.BackgroundProperty;
                setterColumnProductNoBackground.Value    = new Binding("ProductNoBackground");
                styleColumnProductNo.Setters.Add(setterColumnProductNoBackground);

                columnProductNo.CellStyle = styleColumnProductNo;

                columnProductNo.Binding    = new Binding("ProductNo");
                columnProductNo.FontWeight = FontWeights.Bold;

                DataColumn columnProductNoBackground   = new DataColumn("ProductNoBackground", typeof(SolidColorBrush));
                columnProductNoBackground.DefaultValue = Brushes.Transparent;
                dt.Columns.Add(columnProductNoBackground);

                dgInventory.Columns.Add(columnProductNo);

                Binding bindingWidth1 = new Binding();
                bindingWidth1.Source  = columnProductNo;
                bindingWidth1.Path    = new PropertyPath("ActualWidth");
                ColumnDefinition cd1  = new ColumnDefinition();
                cd1.SetBinding(ColumnDefinition.WidthProperty, bindingWidth1);
                gridTotal.ColumnDefinitions.Add(cd1);

                dt.Columns.Add("ArticleNo", typeof(String));
                DataGridTextColumn column1_1_1 = new DataGridTextColumn();
                column1_1_1.Header             = "Article No.";
                column1_1_1.Binding            = new Binding("ArticleNo");
                //column1_1_1.FontWeight = FontWeights.Bold;
                dgInventory.Columns.Add(column1_1_1);
                Binding bindingWidth1_1_1 = new Binding();
                bindingWidth1_1_1.Source  = column1_1_1;
                bindingWidth1_1_1.Path    = new PropertyPath("ActualWidth");
                ColumnDefinition cd1_1_1  = new ColumnDefinition();
                cd1_1_1.SetBinding(ColumnDefinition.WidthProperty, bindingWidth1_1_1);
                gridTotal.ColumnDefinitions.Add(cd1_1_1);

                dt.Columns.Add("OrderETD", typeof(DateTime));
                DataGridTextColumn column1_1 = new DataGridTextColumn();
                column1_1.Header             = "Order EFD";
                // Style
                Style styleOrderETD = new Style(typeof(DataGridCell));
                styleOrderETD.Setters.Add(new Setter(TextBlock.TextAlignmentProperty, TextAlignment.Center));
                column1_1.CellStyle = styleOrderETD;

                Binding binding      = new Binding();
                binding.Path         = new PropertyPath("OrderETD");
                binding.StringFormat = "dd-MMM";
                column1_1.Binding    = binding;
                column1_1.FontWeight = FontWeights.Bold;
                dgInventory.Columns.Add(column1_1);
                Binding bindingWidth1_1 = new Binding();
                bindingWidth1_1.Source  = column1_1;
                bindingWidth1_1.Path    = new PropertyPath("ActualWidth");
                ColumnDefinition cd1_1  = new ColumnDefinition();
                cd1_1.SetBinding(ColumnDefinition.WidthProperty, bindingWidth1_1);
                gridTotal.ColumnDefinitions.Add(cd1_1);

                dt.Columns.Add("DeliveryETD", typeof(DateTime));
                DataGridTextColumn column1_1_A = new DataGridTextColumn();
                column1_1_A.Header             = "Delivery EFD";
                Binding bindingEDTSupp         = new Binding();
                bindingEDTSupp.Path            = new PropertyPath("DeliveryETD");
                bindingEDTSupp.StringFormat    = "dd-MMM";
                column1_1_A.Binding            = bindingEDTSupp;
                column1_1_A.FontWeight         = FontWeights.Bold;

                // Style
                Style styleDeliveryETD = new Style(typeof(DataGridCell));
                styleDeliveryETD.Setters.Add(new Setter(TextBlock.TextAlignmentProperty, TextAlignment.Center));
                column1_1_A.CellStyle = styleDeliveryETD;

                dgInventory.Columns.Add(column1_1_A);
                Binding bindingWidth1_1_A = new Binding();
                bindingWidth1_1_A.Source  = column1_1_A;
                bindingWidth1_1_A.Path    = new PropertyPath("ActualWidth");
                ColumnDefinition cd1_1_A  = new ColumnDefinition();
                cd1_1_A.SetBinding(ColumnDefinition.WidthProperty, bindingWidth1_1_A);
                gridTotal.ColumnDefinitions.Add(cd1_1_A);

                dt.Columns.Add("SewingStartDate", typeof(DateTime));
                DataGridTextColumn column1_1_B  = new DataGridTextColumn();
                column1_1_B.Header              = "Sewing Start";
                Binding bindingSewingStart      = new Binding();
                bindingSewingStart.Path         = new PropertyPath("SewingStartDate");
                bindingSewingStart.StringFormat = "dd-MMM";
                column1_1_B.Binding             = bindingSewingStart;
                column1_1_B.FontWeight          = FontWeights.Bold;

                // Style
                Style styleSewingStart = new Style(typeof(DataGridCell));
                styleDeliveryETD.Setters.Add(new Setter(TextBlock.TextAlignmentProperty, TextAlignment.Center));
                column1_1_B.CellStyle = styleDeliveryETD;

                dgInventory.Columns.Add(column1_1_B);
                Binding bindingWidthSewingStart = new Binding();
                bindingWidthSewingStart.Source  = column1_1_B;
                bindingWidthSewingStart.Path    = new PropertyPath("ActualWidth");
                ColumnDefinition cdSewingStart  = new ColumnDefinition();
                cdSewingStart.SetBinding(ColumnDefinition.WidthProperty, bindingWidthSewingStart);
                gridTotal.ColumnDefinitions.Add(cdSewingStart);

                dt.Columns.Add("Quantity", typeof(Int32));
                DataGridTextColumn column1_2 = new DataGridTextColumn();
                column1_2.Header             = "Quantity";
                Binding bindingQuantity      = new Binding();
                bindingQuantity.Path         = new PropertyPath("Quantity");
                //binding.StringFormat = "dd-MMM";
                column1_2.Binding = bindingQuantity;
                //column1_2.FontWeight = FontWeights.Bold;
                dgInventory.Columns.Add(column1_2);
                Binding bindingWidth1_2 = new Binding();
                bindingWidth1_2.Source  = column1_2;
                bindingWidth1_2.Path    = new PropertyPath("ActualWidth");
                ColumnDefinition cd1_2  = new ColumnDefinition();
                cd1_2.SetBinding(ColumnDefinition.WidthProperty, bindingWidth1_2);
                gridTotal.ColumnDefinitions.Add(cd1_2);


                dt.Columns.Add("Release", typeof(Int32));
                DataGridTextColumn column1_3 = new DataGridTextColumn();
                column1_3.Header             = "Release";
                Binding bindingRelease       = new Binding();
                bindingRelease.Path          = new PropertyPath("Release");
                column1_3.Binding            = bindingRelease;
                dgInventory.Columns.Add(column1_3);
                Binding bindingWidth1_3 = new Binding();
                bindingWidth1_3.Source  = column1_3;
                bindingWidth1_3.Path    = new PropertyPath("ActualWidth");
                ColumnDefinition cd1_3  = new ColumnDefinition();
                cd1_3.SetBinding(ColumnDefinition.WidthProperty, bindingWidth1_3);
                gridTotal.ColumnDefinitions.Add(cd1_3);

                dt.Columns.Add("QuantityDelivery", typeof(Int32));
                DataGridTextColumn column1_4 = new DataGridTextColumn();
                column1_4.Header             = "Delivery Qty";
                // Style
                Style styleQtyDelivery = new Style(typeof(DataGridCell));
                styleQtyDelivery.Setters.Add(new Setter(TextBlock.TextAlignmentProperty, TextAlignment.Center));
                Setter setterBackgroundDelivery   = new Setter();
                setterBackgroundDelivery.Property = DataGridCell.ForegroundProperty;
                setterBackgroundDelivery.Value    = new Binding("QuantityDeliveryForeground");
                styleQtyDelivery.Setters.Add(setterBackgroundDelivery);
                column1_4.CellStyle = styleQtyDelivery;

                Binding bindingQtyDelivery = new Binding();
                bindingQtyDelivery.Path    = new PropertyPath("QuantityDelivery");
                column1_4.Binding          = bindingQtyDelivery;
                dgInventory.Columns.Add(column1_4);
                Binding bindingWidth1_4 = new Binding();
                bindingWidth1_4.Source  = column1_4;
                bindingWidth1_4.Path    = new PropertyPath("ActualWidth");
                ColumnDefinition cd1_4  = new ColumnDefinition();
                cd1_4.SetBinding(ColumnDefinition.WidthProperty, bindingWidth1_4);
                gridTotal.ColumnDefinitions.Add(cd1_4);

                DataColumn columnDeliveryForeground   = new DataColumn("QuantityDeliveryForeground", typeof(SolidColorBrush));
                columnDeliveryForeground.DefaultValue = Brushes.Black;
                dt.Columns.Add(columnDeliveryForeground);

                dgInventory.FrozenColumnCount = 8;

                var regex = new Regex("[a-z]|[A-Z]");
                //sizeNoList = outsoleMaterialList.Where(w => w.Quantity != 0 || w.QuantityReject != 0).Select(s => s.SizeNo).Distinct().OrderBy(s => regex.IsMatch(s) ? Double.Parse(regex.Replace(s, "")) : Double.Parse(s)).ToList();
                sizeNoList = outsoleMaterialList.Select(s => s.SizeNo).Distinct().OrderBy(s => regex.IsMatch(s) ? Double.Parse(regex.Replace(s, "100")) : Double.Parse(s)).ToList();
                for (int i = 0; i <= sizeNoList.Count - 1; i++)
                {
                    var sizeRun_Size = sizeRunAllList_OutsoleCode.FirstOrDefault(w => w.SizeNo == sizeNoList[i]);
                    //OutsoleSuppliersModel outsoleSupplier = outsoleSupplierList[i];
                    string sizeNoBinding = sizeNoList[i].Contains(".") ? sizeNoList[i].Replace(".", "") : sizeNoList[i];
                    dt.Columns.Add(String.Format("Column{0}", sizeNoBinding), typeof(Int32));
                    DataGridTextColumn column = new DataGridTextColumn();
                    //column.SetValue(TagProperty, sizeRun.SizeNo);
                    string outsoleSize = "", midsoleSize = "";
                    if (sizeRun_Size != null)
                    {
                        outsoleSize = sizeRun_Size.OutsoleSize;
                        midsoleSize = sizeRun_Size.MidsoleSize;
                    }
                    column.Header  = String.Format("{0}\n{1}\n", sizeNoList[i], outsoleSize);
                    column.Width   = 35;
                    column.Binding = new Binding(String.Format("Column{0}", sizeNoBinding));

                    Style style = new Style(typeof(DataGridCell));
                    style.Setters.Add(new Setter(TextBlock.TextAlignmentProperty, TextAlignment.Center));

                    Setter setterBackground   = new Setter();
                    setterBackground.Property = DataGridCell.BackgroundProperty;
                    setterBackground.Value    = new Binding(String.Format("Column{0}Background", sizeNoBinding));

                    Setter setterForeground   = new Setter();
                    setterForeground.Property = DataGridCell.ForegroundProperty;
                    setterForeground.Value    = new Binding(String.Format("Column{0}Foreground", sizeNoBinding));

                    Setter setterToolTip   = new Setter();
                    setterToolTip.Property = DataGridCell.ToolTipProperty;
                    setterToolTip.Value    = new Binding(String.Format("Column{0}ToolTip", sizeNoBinding));

                    style.Setters.Add(setterBackground);
                    style.Setters.Add(setterForeground);
                    style.Setters.Add(setterToolTip);

                    column.CellStyle = style;
                    dgInventory.Columns.Add(column);
                    Binding bindingWidth = new Binding();
                    bindingWidth.Source  = column;
                    bindingWidth.Path    = new PropertyPath("ActualWidth");
                    ColumnDefinition cd  = new ColumnDefinition();
                    cd.SetBinding(ColumnDefinition.WidthProperty, bindingWidth);
                    gridTotal.ColumnDefinitions.Add(cd);

                    DataColumn columnBackground   = new DataColumn(String.Format("Column{0}Background", sizeNoBinding), typeof(SolidColorBrush));
                    columnBackground.DefaultValue = Brushes.Transparent;

                    DataColumn columnForeground   = new DataColumn(String.Format("Column{0}Foreground", sizeNoBinding), typeof(SolidColorBrush));
                    columnForeground.DefaultValue = Brushes.Black;

                    DataColumn columnToolTip = new DataColumn(String.Format("Column{0}ToolTip", sizeNoBinding), typeof(String));

                    dt.Columns.Add(columnBackground);
                    dt.Columns.Add(columnForeground);
                    dt.Columns.Add(columnToolTip);
                }

                dt.Columns.Add("TotalBalance", typeof(Int32));
                DataGridTextColumn columnTotalBalance = new DataGridTextColumn();
                columnTotalBalance.Header             = "  OrderSize\nOutsoleSize\n     Total";
                columnTotalBalance.Binding            = new Binding("TotalBalance");
                Style styleBalance = new Style(typeof(DataGridCell));
                styleBalance.Setters.Add(new Setter(TextBlock.TextAlignmentProperty, TextAlignment.Center));
                columnTotalBalance.CellStyle = styleBalance;

                dgInventory.Columns.Add(columnTotalBalance);
                Binding bindingWidthTotalBalance = new Binding();
                bindingWidthTotalBalance.Source  = columnTotalBalance;
                bindingWidthTotalBalance.Path    = new PropertyPath("ActualWidth");
                ColumnDefinition cdTotalBalance  = new ColumnDefinition();
                cdTotalBalance.SetBinding(ColumnDefinition.WidthProperty, bindingWidthTotalBalance);
                gridTotal.ColumnDefinitions.Add(cdTotalBalance);
            }));

            foreach (string productNo in productNoList)
            {
                string test = "";
                if (productNo == "108-2918A")
                {
                    test = productNo;
                }
                var outsoleMaterialDetailList = OutsoleMaterialDetailController.Select(productNo).Where(w => w.OutsoleSupplierId == supplierID).ToList();
                var order = orderList.FirstOrDefault(f => f.ProductNo == productNo);

                var dr = dt.NewRow();

                if (order == null)
                {
                    continue;
                }
                dr["ProductNo"] = productNo;

                //HighLightPO
                int qtyOutsoleMaterialDetail = outsoleMaterialDetailList.Sum(s => s.Quantity);
                if (qtyOutsoleMaterialDetail >= order.Quantity)
                {
                    dr["ProductNoBackground"] = Brushes.Green;
                }
                else if (qtyOutsoleMaterialDetail != 0 && qtyOutsoleMaterialDetail < order.Quantity)
                {
                    dr["ProductNoBackground"] = Brushes.Yellow;
                }

                dr["ArticleNo"] = order.ArticleNo;
                dr["Quantity"]  = order.Quantity;
                dr["OrderETD"]  = order.ETD;

                var sewingMasterModel = sewingMasterList.Where(w => w.ProductNo == productNo).FirstOrDefault();
                if (sewingMasterModel != null)
                {
                    dr["SewingStartDate"] = sewingMasterModel.SewingStartDate;
                }

                var outsoleRawMaterialModel = outsoleRawMaterialList.Where(w => w.ProductNo == productNo && w.OutsoleSupplierId == supplierID).FirstOrDefault();
                var dtTemp = new DateTime(2000, 01, 01);
                if (outsoleRawMaterialModel != null)
                {
                    dr["DeliveryETD"] = outsoleRawMaterialModel.ETD;
                    dtTemp            = outsoleRawMaterialModel.ETD;
                }

                int qtyDelivery = 0;
                foreach (string sizeNo in sizeNoList)
                {
                    string sizeNoBinding          = sizeNo.Contains(".") ? sizeNo.Replace(".", "") : sizeNo;
                    var    outsoleMaterialRecieve = outsoleMaterialList.Where(w => w.ProductNo == productNo && w.SizeNo == sizeNo).FirstOrDefault();

                    int qtyDeliveryPerSize = 0;
                    int qtyRejectPerSize   = 0;
                    if (outsoleMaterialRecieve != null)
                    {
                        qtyDeliveryPerSize = outsoleMaterialRecieve.Quantity;
                        qtyRejectPerSize   = outsoleMaterialRecieve.QuantityReject;
                    }
                    int qtyPerSize = 0;
                    if (sizeRunList.Where(w => w.ProductNo == productNo).Count() > 0)
                    {
                        qtyPerSize = sizeRunList.Where(w => w.ProductNo == productNo && w.SizeNo == sizeNo).Select(s => s.Quantity).FirstOrDefault();
                    }

                    int qtyBalance = qtyPerSize - qtyDeliveryPerSize;

                    if (ShowOnlyBalance == true)
                    {
                        if (qtyBalance > 0 && dtTemp != dtDefault)
                        {
                            dr[String.Format("Column{0}", sizeNoBinding)] = qtyBalance;
                            var dtNow = DateTime.Now;
                            if (outsoleMaterialRecieve != null)
                            {
                                if (outsoleMaterialRecieve.ModifiedTime.Date < dtNow.Date)
                                {
                                    dr[String.Format("Column{0}Background", sizeNoBinding)] = Brushes.Tomato;
                                }
                                if (outsoleMaterialRecieve.ModifiedTime.Date == dtNow.Date)
                                {
                                    dr[String.Format("Column{0}Background", sizeNoBinding)] = Brushes.Green;
                                }
                                dr[String.Format("Column{0}Foreground", sizeNoBinding)] = Brushes.Black;
                            }
                        }
                    }
                    else
                    {
                        if (qtyRejectPerSize > 0)
                        {
                            dr[String.Format("Column{0}", sizeNoBinding)]           = qtyRejectPerSize;
                            dr[String.Format("Column{0}Foreground", sizeNoBinding)] = Brushes.Red;
                        }

                        if (qtyBalance > 0 && dtTemp != dtDefault)
                        {
                            dr[String.Format("Column{0}", sizeNoBinding)] = qtyBalance + qtyRejectPerSize;
                            var dtNow = DateTime.Now;
                            if (outsoleMaterialRecieve != null)
                            {
                                if (outsoleMaterialRecieve.ModifiedTime.Date < dtNow.Date)
                                {
                                    dr[String.Format("Column{0}Background", sizeNoBinding)] = Brushes.Tomato;
                                }
                                if (outsoleMaterialRecieve.ModifiedTime.Date == dtNow.Date)
                                {
                                    dr[String.Format("Column{0}Background", sizeNoBinding)] = Brushes.Green;
                                }
                                dr[String.Format("Column{0}Foreground", sizeNoBinding)] = Brushes.Black;
                            }

                            if (qtyRejectPerSize > 0)
                            {
                                dr[String.Format("Column{0}Background", sizeNoBinding)] = Brushes.Yellow;
                                dr[String.Format("Column{0}ToolTip", sizeNoBinding)]    = String.Format("Balance: {0}\nReject: {1}", qtyBalance, qtyRejectPerSize);
                            }
                        }
                    }
                    qtyDelivery += qtyDeliveryPerSize;
                }

                int totalRelease = outsoleReleaseMaterialList.Where(w => w.ProductNo == productNo).Sum(s => s.Quantity);

                if (order.Quantity != qtyDelivery && qtyDelivery != 0)
                {
                    dr["QuantityDeliveryForeground"] = Brushes.Red;
                }

                dr["Release"]          = totalRelease;
                dr["QuantityDelivery"] = qtyDelivery;

                int totalDelivery = outsoleMaterialList.Where(w => w.ProductNo == productNo).Sum(s => s.Quantity);
                int totalReject   = outsoleMaterialList.Where(w => w.ProductNo == productNo).Sum(s => s.QuantityReject);

                if (order.Quantity - totalDelivery + totalReject > 0)
                {
                    dr["TotalBalance"] = order.Quantity - totalDelivery + totalReject;
                }

                if (ShowOnlyBalance == true)
                {
                    if (order.Quantity != totalDelivery)
                    {
                        dt.Rows.Add(dr);
                    }
                }
                else
                {
                    dt.Rows.Add(dr);
                }
            }

            Dispatcher.Invoke(new Action(() =>
            {
                TextBlock lblTotal  = new TextBlock();
                lblTotal.Text       = "TOTAL";
                lblTotal.Margin     = new Thickness(1, 0, 0, 0);
                lblTotal.FontWeight = FontWeights.Bold;
                Border bdrTotal     = new Border();
                Grid.SetColumn(bdrTotal, 2);
                Grid.SetColumnSpan(bdrTotal, 5);
                bdrTotal.BorderThickness = new Thickness(1, 0, 1, 1);
                bdrTotal.BorderBrush     = Brushes.Black;
                bdrTotal.Child           = lblTotal;
                gridTotal.Children.Add(bdrTotal);

                TextBlock lblQuantityTotal     = new TextBlock();
                lblQuantityTotal.Text          = dt.Compute("Sum(Quantity)", "").ToString();
                lblQuantityTotal.Margin        = new Thickness(1, 0, 0, 0);
                lblQuantityTotal.FontWeight    = FontWeights.Bold;
                lblQuantityTotal.TextAlignment = TextAlignment.Center;

                Border bdrQuantityTotal = new Border();
                Grid.SetColumn(bdrQuantityTotal, 7);
                bdrQuantityTotal.BorderThickness = new Thickness(0, 0, 1, 1);
                bdrQuantityTotal.BorderBrush     = Brushes.Black;
                bdrQuantityTotal.Child           = lblQuantityTotal;
                gridTotal.Children.Add(bdrQuantityTotal);
                dgInventory.ItemsSource = dt.AsDataView();

                TextBlock lblReleaseTotal     = new TextBlock();
                lblReleaseTotal.Text          = dt.Compute("Sum(Release)", "").ToString();
                lblReleaseTotal.Margin        = new Thickness(1, 0, 0, 0);
                lblReleaseTotal.FontWeight    = FontWeights.Bold;
                lblReleaseTotal.TextAlignment = TextAlignment.Center;

                Border bdrReleaseTotal = new Border();
                Grid.SetColumn(bdrReleaseTotal, 8);
                bdrReleaseTotal.BorderThickness = new Thickness(0, 0, 1, 1);
                bdrReleaseTotal.BorderBrush     = Brushes.Black;
                bdrReleaseTotal.Child           = lblReleaseTotal;
                gridTotal.Children.Add(bdrReleaseTotal);
                dgInventory.ItemsSource = dt.AsDataView();

                TextBlock lblQuantityDelivery     = new TextBlock();
                lblQuantityDelivery.Text          = dt.Compute("Sum(QuantityDelivery)", "").ToString();
                lblQuantityDelivery.Margin        = new Thickness(1, 0, 0, 0);
                lblQuantityDelivery.FontWeight    = FontWeights.Bold;
                lblQuantityDelivery.TextAlignment = TextAlignment.Center;

                Border bdrQuantityDeliveryTotal = new Border();
                Grid.SetColumn(bdrQuantityDeliveryTotal, 9);
                bdrQuantityDeliveryTotal.BorderThickness = new Thickness(0, 0, 1, 1);
                bdrQuantityDeliveryTotal.BorderBrush     = Brushes.Black;
                bdrQuantityDeliveryTotal.Child           = lblQuantityDelivery;
                gridTotal.Children.Add(bdrQuantityDeliveryTotal);
                dgInventory.ItemsSource = dt.AsDataView();

                for (int i = 0; i <= sizeNoList.Count - 1; i++)
                {
                    Border brTemp = new Border();
                    Grid.SetColumn(brTemp, 10 + i);
                    gridTotal.Children.Add(brTemp);
                }

                TextBlock txtTotalBalance     = new TextBlock();
                txtTotalBalance.Text          = dt.Compute("Sum(TotalBalance)", "").ToString();
                txtTotalBalance.Margin        = new Thickness(1, 0, 0, 0);
                txtTotalBalance.FontWeight    = FontWeights.Bold;
                txtTotalBalance.TextAlignment = TextAlignment.Center;

                Border brTotalBalance = new Border();
                Grid.SetColumn(brTotalBalance, 10 + sizeNoList.Count());
                brTotalBalance.BorderThickness = new Thickness(1, 0, 1, 1);
                brTotalBalance.BorderBrush     = Brushes.Black;
                brTotalBalance.Child           = txtTotalBalance;
                gridTotal.Children.Add(brTotalBalance);

                dgInventory.ItemsSource = dt.AsDataView();
            }));

            dtExportExcel = dt;
        }
        private void bwLoad_DoWork(object sender, DoWorkEventArgs e)
        {
            Dispatcher.Invoke(new Action(() =>
            {
                lblStatus.Text = String.Format("Creating Columns");
            }));

            outsoleMaterialList        = OutsoleMaterialController.Select();
            outsoleReleaseMaterialList = OutsoleReleaseMaterialController.SelectByOutsoleMaterial();
            supplierList = OutsoleSuppliersController.Select();
            ordersList   = OrdersController.Select();
            sizeRunList  = SizeRunController.SelectIsEnable();

            osDeliverySummaryList = ReportController.GetOSDeliverySummary();

            var productNoList   = ordersList.Select(s => s.ProductNo).Distinct().ToList();
            var outsoleCodeList = osDeliverySummaryList.Select(s => s.OutsoleCode).Distinct().ToList();

            // Create Column
            DataTable dt = new DataTable();

            Dispatcher.Invoke(new Action(() =>
            {
                // Column OutsoleCode
                dt.Columns.Add("OutsoleCode", typeof(String));
                DataGridTemplateColumn colOutsoleCode = new DataGridTemplateColumn();
                colOutsoleCode.Header       = String.Format("Outsole Code");
                DataTemplate templateOSCode = new DataTemplate();
                FrameworkElementFactory tblOSCodeFactory = new FrameworkElementFactory(typeof(TextBlock));
                templateOSCode.VisualTree = tblOSCodeFactory;
                tblOSCodeFactory.SetValue(TextBlock.TextProperty, "");
                tblOSCodeFactory.SetBinding(TextBlock.TextProperty, new Binding(String.Format("OutsoleCode")));
                tblOSCodeFactory.SetValue(TextBlock.FontWeightProperty, FontWeights.SemiBold);
                tblOSCodeFactory.SetValue(TextBlock.VerticalAlignmentProperty, VerticalAlignment.Center);
                tblOSCodeFactory.SetValue(TextBlock.PaddingProperty, new Thickness(3, 0, 0, 0));
                colOutsoleCode.CellTemplate            = templateOSCode;
                colOutsoleCode.ClipboardContentBinding = new Binding(String.Format("OutsoleCode"));
                dgWHDelivery.Columns.Add(colOutsoleCode);

                // Column OutsoleCode
                dt.Columns.Add("OrderQuantity", typeof(String));
                DataGridTemplateColumn colOrderQty = new DataGridTemplateColumn();
                colOrderQty.Header                 = String.Format("Order Quantity");
                DataTemplate templateOrderQty      = new DataTemplate();
                FrameworkElementFactory tblOderQty = new FrameworkElementFactory(typeof(TextBlock));
                templateOrderQty.VisualTree        = tblOderQty;
                tblOderQty.SetValue(TextBlock.TextProperty, "");
                tblOderQty.SetBinding(TextBlock.TextProperty, new Binding(String.Format("OrderQuantity")));
                tblOderQty.SetValue(TextBlock.VerticalAlignmentProperty, VerticalAlignment.Center);
                tblOderQty.SetValue(TextBlock.PaddingProperty, new Thickness(3, 0, 0, 0));
                colOrderQty.CellTemplate            = templateOrderQty;
                colOrderQty.ClipboardContentBinding = new Binding(String.Format("OrderQuantity"));
                dgWHDelivery.Columns.Add(colOrderQty);

                // Column WHQuantity
                dt.Columns.Add("WHQuantity", typeof(String));
                DataGridTemplateColumn colWHQuantity = new DataGridTemplateColumn();
                colWHQuantity.Header                  = String.Format("WH Quantity");
                DataTemplate templateWHQuantity       = new DataTemplate();
                FrameworkElementFactory tblWHQuantity = new FrameworkElementFactory(typeof(TextBlock));
                templateWHQuantity.VisualTree         = tblWHQuantity;
                tblWHQuantity.SetBinding(TextBlock.TextProperty, new Binding(String.Format("WHQuantity")));
                tblWHQuantity.SetValue(TextBlock.VerticalAlignmentProperty, VerticalAlignment.Center);
                tblWHQuantity.SetValue(TextBlock.PaddingProperty, new Thickness(3, 0, 0, 0));
                colWHQuantity.CellTemplate            = templateWHQuantity;
                colWHQuantity.ClipboardContentBinding = new Binding(String.Format("WHQuantity"));
                dgWHDelivery.Columns.Add(colWHQuantity);

                // Column WHQuantity
                dt.Columns.Add("Reject", typeof(String));
                DataGridTemplateColumn colReject = new DataGridTemplateColumn();
                colReject.Header                  = String.Format("Reject");
                DataTemplate templateReject       = new DataTemplate();
                FrameworkElementFactory tblReject = new FrameworkElementFactory(typeof(TextBlock));
                templateReject.VisualTree         = tblReject;
                tblReject.SetBinding(TextBlock.TextProperty, new Binding(String.Format("Reject")));
                tblReject.SetValue(TextBlock.PaddingProperty, new Thickness(3, 0, 0, 0));
                tblReject.SetValue(TextBlock.VerticalAlignmentProperty, VerticalAlignment.Center);
                colReject.CellTemplate            = templateReject;
                colReject.ClipboardContentBinding = new Binding(String.Format("Reject"));
                dgWHDelivery.Columns.Add(colReject);

                // Column Matching
                dt.Columns.Add("Matching", typeof(String));
                DataGridTemplateColumn colMatching = new DataGridTemplateColumn();
                colMatching.Header                  = String.Format("Matching");
                DataTemplate templateMatching       = new DataTemplate();
                FrameworkElementFactory tblMatching = new FrameworkElementFactory(typeof(TextBlock));
                templateMatching.VisualTree         = tblMatching;
                tblMatching.SetBinding(TextBlock.TextProperty, new Binding(String.Format("Matching")));
                tblMatching.SetValue(TextBlock.PaddingProperty, new Thickness(3, 0, 0, 0));
                tblMatching.SetValue(TextBlock.VerticalAlignmentProperty, VerticalAlignment.Center);
                colMatching.CellTemplate            = templateMatching;
                colMatching.ClipboardContentBinding = new Binding(String.Format("Matching"));
                dgWHDelivery.Columns.Add(colMatching);

                // Column Release
                dt.Columns.Add("Release", typeof(String));
                DataGridTemplateColumn colRelease = new DataGridTemplateColumn();
                colRelease.Header                  = String.Format("Release");
                DataTemplate templateRelease       = new DataTemplate();
                FrameworkElementFactory tblRelease = new FrameworkElementFactory(typeof(TextBlock));
                templateRelease.VisualTree         = tblRelease;
                tblRelease.SetBinding(TextBlock.TextProperty, new Binding(String.Format("Release")));
                tblRelease.SetValue(TextBlock.PaddingProperty, new Thickness(3, 0, 0, 0));
                tblRelease.SetValue(TextBlock.VerticalAlignmentProperty, VerticalAlignment.Center);
                colRelease.CellTemplate            = templateRelease;
                colRelease.ClipboardContentBinding = new Binding(String.Format("Release"));
                dgWHDelivery.Columns.Add(colRelease);

                // Column Suppliers
                int maxNumberOfSupplier = osDeliverySummaryList.Max(m => m.NoOfSupp);
                for (int i = 0; i < maxNumberOfSupplier; i++)
                {
                    dt.Columns.Add(String.Format("Column{0}", i), typeof(String));
                    dt.Columns.Add(String.Format("ColumnSupplierID{0}", i), typeof(Int32));
                    DataGridTemplateColumn colSupplier = new DataGridTemplateColumn();
                    colSupplier.Header                  = String.Format("Supplier {0}", i + 1);
                    DataTemplate templateSupplier       = new DataTemplate();
                    FrameworkElementFactory tblSupplier = new FrameworkElementFactory(typeof(TextBlock));
                    templateSupplier.VisualTree         = tblSupplier;
                    tblSupplier.SetBinding(TextBlock.TextProperty, new Binding(String.Format("Column{0}", i)));
                    tblSupplier.SetValue(TextBlock.PaddingProperty, new Thickness(3, 3, 3, 3));
                    tblSupplier.SetValue(TextBlock.VerticalAlignmentProperty, VerticalAlignment.Center);

                    colSupplier.CellTemplate            = templateSupplier;
                    colSupplier.ClipboardContentBinding = new Binding(String.Format("Column{0}", i));
                    dgWHDelivery.Columns.Add(colSupplier);
                }
            }));

            // Binding Data
            int indexProgressBar = 1;

            Dispatcher.Invoke(new Action(() => {
                progressBar.Maximum = outsoleCodeList.Count();
            }));
            int totalQtyOrder = 0, totalQtyWH = 0, totalQtyReject = 0, totalQtyMatch = 0, totalQtyRelease = 0;

            foreach (var outsoleCode in outsoleCodeList)
            {
                DataRow dr = dt.NewRow();

                var osDeliveryByOScode = osDeliverySummaryList.Where(w => w.OutsoleCode == outsoleCode).ToList();

                dr["OutsoleCode"]   = outsoleCode;
                dr["OrderQuantity"] = string.Format("{0:#,0}", osDeliveryByOScode.Max(m => m.QtyOrder));
                dr["WHQuantity"]    = string.Format("{0:#,0}", osDeliveryByOScode.Max(m => m.QtyWH));
                dr["Reject"]        = string.Format("{0:#,0}", osDeliveryByOScode.Max(m => m.QtyReject));
                dr["Matching"]      = string.Format("{0:#,0}", osDeliveryByOScode.Max(m => m.QtyMatch));
                dr["Release"]       = string.Format("{0:#,0}", osDeliveryByOScode.Max(m => m.QtyRelease));

                totalQtyOrder   += osDeliveryByOScode.Max(m => m.QtyOrder);
                totalQtyWH      += osDeliveryByOScode.Max(m => m.QtyWH);
                totalQtyReject  += osDeliveryByOScode.Max(m => m.QtyReject);
                totalQtyMatch   += osDeliveryByOScode.Max(m => m.QtyMatch);
                totalQtyRelease += osDeliveryByOScode.Max(m => m.QtyRelease);

                var supplierIDList_OSCode = osDeliverySummaryList.Where(w => w.OutsoleCode == outsoleCode).Select(s => s.OutsoleSupplierId).Distinct().ToList();

                for (int i = 0; i < supplierIDList_OSCode.Count(); i++)
                {
                    int supplierID = supplierIDList_OSCode[i];
                    var osDeliverySummaryByOSCodeBySupplier = osDeliverySummaryList.FirstOrDefault(w => w.OutsoleCode == outsoleCode && w.OutsoleSupplierId == supplierID);

                    string numberOfPO = osDeliverySummaryByOSCodeBySupplier.NoOfPO > 0 ?
                                        string.Format("({0:#,0})", osDeliverySummaryByOSCodeBySupplier.NoOfPO) :
                                        "";
                    string quantityDelivery_SupplierString = osDeliverySummaryByOSCodeBySupplier.QtyDelivery > 0 ? string.Format("\nDelivery: {0:#,0}", osDeliverySummaryByOSCodeBySupplier.QtyDelivery)   : "";
                    string reject_SupplierString           = osDeliverySummaryByOSCodeBySupplier.QtyReject > 0 ?   string.Format("\nReject:     {0:#,0}", osDeliverySummaryByOSCodeBySupplier.QtyReject)   : "";
                    string balance_SupplierString          = osDeliverySummaryByOSCodeBySupplier.QtyBalance > 0 ?  string.Format("\nBalance:  {0:#,0}", osDeliverySummaryByOSCodeBySupplier.QtyBalance)    : "";

                    dr[String.Format("Column{0}", i)] = String.Format("{0} {1}{2}{3}{4}",
                                                                      osDeliverySummaryByOSCodeBySupplier.Name,
                                                                      numberOfPO,
                                                                      quantityDelivery_SupplierString,
                                                                      reject_SupplierString,
                                                                      balance_SupplierString);

                    dr[String.Format("ColumnSupplierID{0}", i)] = supplierIDList_OSCode[i];
                }
                dt.Rows.Add(dr);
                Dispatcher.Invoke(new Action(() =>
                {
                    progressBar.Value = indexProgressBar;
                    lblStatus.Text    = String.Format("Writing  {0} rows / {1}", indexProgressBar, outsoleCodeList.Count());
                    Thread.Sleep(50);
                }));
                indexProgressBar++;
            }

            DataRow drTotal = dt.NewRow();

            drTotal["OutsoleCode"]   = "Total";
            drTotal["OrderQuantity"] = string.Format("{0:#,0}", totalQtyOrder);
            drTotal["WHQuantity"]    = string.Format("{0:#,0}", totalQtyWH);
            drTotal["Reject"]        = string.Format("{0:#,0}", totalQtyReject);
            drTotal["Matching"]      = string.Format("{0:#,0}", totalQtyMatch);
            drTotal["Release"]       = string.Format("{0:#,0}", totalQtyRelease);

            dt.Rows.Add(drTotal);
            e.Result = dt;
        }
        private void bwLoad_DoWork(object sender, DoWorkEventArgs e)
        {
            orderList     = OrdersController.Select();
            productNoList = orderList.Select(s => s.ProductNo).Distinct().ToList();

            outsoleMasterList = OutsoleMasterController.Select();
            outsoleOutputList = OutsoleOutputController.SelectByIsEnable();
            sizeRunList       = SizeRunController.SelectIsEnable();

            var regex = new Regex("[a-z]|[A-Z]");

            sizeNoList = new List <String>();

            var sizeNoIsDouble = sizeRunList.Where(w => regex.IsMatch(w.SizeNo) == false).Select(s => s.SizeNo).Distinct().ToList();

            sizeNoIsDouble = sizeNoIsDouble.OrderBy(s => Double.Parse(s)).ToList();
            sizeNoList.AddRange(sizeNoIsDouble);

            var sizeNoIsCharacter = sizeRunList.Where(w => regex.IsMatch(w.SizeNo)).OrderBy(o => o.SizeNo).Select(s => s.SizeNo).Distinct().ToList();

            sizeNoIsCharacter = sizeNoIsCharacter.OrderBy(s => regex.IsMatch(s) ? Double.Parse(regex.Replace(s, "")) : Double.Parse(s)).ToList();
            sizeNoList.AddRange(sizeNoIsCharacter);

            // Collect Data
            outsoleOutputBalanceViewModelList = new List <OutsoleOutputBalanceViewModel>();
            foreach (var po in productNoList)
            {
                var order                = orderList.FirstOrDefault(f => f.ProductNo == po);
                var outsoleMaster_PO     = outsoleMasterList.FirstOrDefault(f => f.ProductNo == po);
                var sizeRun_POList       = sizeRunList.Where(w => w.ProductNo == po).ToList();
                var outsoleOutput_POList = outsoleOutputList.Where(w => w.ProductNo == po).ToList();

                if (order == null || outsoleMaster_PO == null || sizeRun_POList.Count == 0)
                {
                    continue;
                }

                if (outsoleOutput_POList.Sum(s => s.Quantity) >= sizeRun_POList.Sum(s => s.Quantity))
                {
                    continue;
                }

                var outsoleOutputBalanceViewModel = new OutsoleOutputBalanceViewModel()
                {
                    ProductNo   = po,
                    Country     = order.Country,
                    ShoeName    = order.ShoeName,
                    ArticleNo   = order.ArticleNo,
                    ETD         = order.ETD,
                    OutsoleLine = outsoleMaster_PO.OutsoleLine,
                    OutsoleCode = order.OutsoleCode
                };

                var outsoleOutputBalanceValueList = new List <OutsoleOutputBalanceValue>();
                for (int i = 0; i <= sizeNoList.Count - 1; i++)
                {
                    var sizeNoBinding = sizeNoList[i].Contains(".") == true ? sizeNoList[i].Replace(".", "@") : sizeNoList[i];

                    var outsoleOutputBalanceValue = new OutsoleOutputBalanceValue();
                    outsoleOutputBalanceValue.SizeNo    = sizeNoList[i];
                    outsoleOutputBalanceValue.ForeColor = Brushes.Black;

                    var sizeRun_Size = sizeRun_POList.FirstOrDefault(f => f.SizeNo == sizeNoList[i]);
                    if (sizeRun_Size == null)
                    {
                        continue;
                    }

                    //PO not yet make
                    if (outsoleOutput_POList.Count == 0)
                    {
                        outsoleOutputBalanceValue.Value = sizeRun_Size.Quantity;
                    }

                    else
                    {
                        var outsoleOutput_PO_SizeNo = outsoleOutput_POList.FirstOrDefault(f => f.SizeNo == sizeNoList[i]);
                        int osOutput_PO_Size        = outsoleOutput_PO_SizeNo != null ? outsoleOutput_PO_SizeNo.Quantity : 0;
                        int qtyShow = sizeRun_Size.Quantity - osOutput_PO_Size;
                        if (qtyShow > 0)
                        {
                            outsoleOutputBalanceValue.Value = qtyShow;
                        }
                        if (osOutput_PO_Size > 0)
                        {
                            outsoleOutputBalanceValue.ForeColor = Brushes.Red;
                        }
                    }
                    if (outsoleOutputBalanceValue.Value > 0)
                    {
                        outsoleOutputBalanceValueList.Add(outsoleOutputBalanceValue);
                    }
                }
                outsoleOutputBalanceViewModel.Values = outsoleOutputBalanceValueList;
                outsoleOutputBalanceViewModelList.Add(outsoleOutputBalanceViewModel);
            }
        }
        private void bwLoadData_DoWork(object sender, DoWorkEventArgs e)
        {
            outsoleMaterialRejectList = OutsoleMaterialController.SelectReject();
            outsoleSupplierList       = OutsoleSuppliersController.Select();
            orderList = OrdersController.SelectByOutsoleMaterialReject();
            outsoleRawMaterialList = OutsoleRawMaterialController.Select();
            sizeRunList            = SizeRunController.SelectIsEnable();
            def = PrivateDefineController.GetDefine();

            DataTable dt  = new OutsoleMaterialRejectDataSet().Tables["OutsoleMaterialRejectTable"];
            DataTable dt1 = new OutsoleMaterialRejectDataSet().Tables["OutsoleMaterialRejectTable"];

            var regex = new Regex(@"[a-z]|[A-Z]");

            foreach (OutsoleMaterialModel outsoleMaterialReject in outsoleMaterialRejectList)
            {
                var     outsoleSupplier    = outsoleSupplierList.FirstOrDefault(f => f.OutsoleSupplierId == outsoleMaterialReject.OutsoleSupplierId);
                var     order              = orderList.FirstOrDefault(f => f.ProductNo == outsoleMaterialReject.ProductNo);
                var     outsoleRawMaterial = outsoleRawMaterialList.FirstOrDefault(f => f.ProductNo == outsoleMaterialReject.ProductNo && f.OutsoleSupplierId == outsoleMaterialReject.OutsoleSupplierId);
                DataRow dr  = dt.NewRow();
                DataRow dr1 = dt1.NewRow();

                dr["ProductNo"]  = outsoleMaterialReject.ProductNo;
                dr1["ProductNo"] = outsoleMaterialReject.ProductNo;
                var productNoList = new List <String>();
                if (order != null)
                {
                    dr["OutsoleCode"]  = order.OutsoleCode;
                    dr1["OutsoleCode"] = order.OutsoleCode;
                    dr["ETD"]          = order.ETD;
                    dr1["ETD"]         = order.ETD;
                    dr["ArticleNo"]    = order.ArticleNo;
                    dr1["ArticleNo"]   = order.ArticleNo;
                    productNoList      = orderList.Where(w => w.OutsoleCode == order.OutsoleCode).Select(s => s.ProductNo).ToList();
                }
                if (outsoleRawMaterial != null)
                {
                    dr["SupplierETD"]  = outsoleRawMaterial.ETD;
                    dr1["SupplierETD"] = outsoleRawMaterial.ETD;
                }
                if (outsoleSupplier != null)
                {
                    dr["OutsoleSupplier"]  = outsoleSupplier.Name;
                    dr1["OutsoleSupplier"] = outsoleSupplier.Name;
                }

                string sizeNoOutsole      = outsoleMaterialReject.SizeNo;
                var    sizeNo_OutsoleCode = sizeRunList.Where(w => productNoList.Contains(w.ProductNo) && w.SizeNo == sizeNoOutsole).FirstOrDefault();
                if (sizeNo_OutsoleCode != null)
                {
                    if (String.IsNullOrEmpty(sizeNo_OutsoleCode.OutsoleSize) == false)
                    {
                        sizeNoOutsole = sizeNo_OutsoleCode.OutsoleSize;
                    }
                }

                string sizeNoString = regex.IsMatch(sizeNoOutsole) == true?regex.Replace(sizeNoOutsole, "") : sizeNoOutsole;

                double sizeNoDouble = 0;
                Double.TryParse(sizeNoString, out sizeNoDouble);
                dr["SizeNoDouble"]  = sizeNoDouble;
                dr1["SizeNoDouble"] = sizeNoDouble;

                dr["SizeNo"]  = outsoleMaterialReject.SizeNo;
                dr1["SizeNo"] = outsoleMaterialReject.SizeNo;
                if (def.ShowOSSizeValue)
                {
                    dr["SizeOutsole"]  = sizeNoOutsole;
                    dr1["SizeOutsole"] = sizeNoOutsole;
                }


                if (outsoleMaterialReject.QuantityReject > 0)
                {
                    dr["QuantityReject"] = outsoleMaterialReject.QuantityReject;
                    dt.Rows.Add(dr);
                }

                if (outsoleMaterialReject.RejectAssembly > 0)
                {
                    dr1["QuantityReject"] = outsoleMaterialReject.RejectAssembly;
                    dt1.Rows.Add(dr1);
                }
            }
            dtRejectAssemblyStockfit = dt1;
            e.Result = dt;
        }