Beispiel #1
0
        private void DataGrid_Result_LoadingDataSource(object sender, Newegg.Oversea.Silverlight.Controls.Data.LoadingDataEventArgs e)
        {
            OrderCheckItemQueryFilter queryFilter = new OrderCheckItemQueryFilter();

            queryFilter.PagingInfo = new PagingInfo
            {
                PageSize  = int.MaxValue,
                PageIndex = 0,
                SortBy    = ""
            };
            queryFilter.ReferenceType = "PC";
            queryFilter.CompanyCode   = CPApplication.Current.CompanyCode;
            OrderCheckItemFacade facade = new OrderCheckItemFacade(this);

            facade.QueryOrderCheckItem(queryFilter, (obj, args) =>
            {
                if (args.FaultsHandle())
                {
                    return;
                }

                List <OrderCheckItemVM> list       = DynamicConverter <OrderCheckItemVM> .ConvertToVMList(args.Result.Rows);
                dataGridOrderCheckList.ItemsSource = list;
                dataGridOrderCheckList.TotalCount  = list.Count();
            });
        }
        private void DataGrid_Result_LoadingDataSource(object sender, Newegg.Oversea.Silverlight.Controls.Data.LoadingDataEventArgs e)
        {
            OrderCheckItemQueryFilter queryFilter = new OrderCheckItemQueryFilter();

            queryFilter.PagingInfo = new PagingInfo
            {
                PageSize  = e.PageSize,
                PageIndex = e.PageIndex,
                SortBy    = e.SortField
            };
            if (rbtnProductSysNo1.IsChecked.Value)
            {
                viewModel.ReferenceType = "PID";
            }
            else if (rbtnProductType1.IsChecked.Value)
            {
                viewModel.ReferenceType = "PC3";
            }
            queryFilter.ReferenceType    = viewModel.ReferenceType;
            queryFilter.Status           = viewModel.Status;
            queryFilter.ReferenceContent = viewModel.ProductID;
            queryFilter.Description      = (viewModel.Category3No.HasValue ? viewModel.Category3No.ToString() : string.Empty);
            OrderCheckItemFacade facade = new OrderCheckItemFacade(this);

            facade.QueryOrderCheckItem(queryFilter, (obj, args) =>
            {
                if (args.FaultsHandle())
                {
                    return;
                }
                List <OrderCheckItemVM> list         = DynamicConverter <OrderCheckItemVM> .ConvertToVMList(args.Result.Rows);
                this.DataGrid_ResultList.ItemsSource = list;
                DataGrid_ResultList.TotalCount       = args.Result.TotalCount;
            });
        }
        public QueryResult QueryOrderCheckItemList(OrderCheckItemQueryFilter request)
        {
            int totalCount;

            return(new QueryResult()
            {
                Data = ObjectFactory <IOrderCheckItemQueryDA> .Instance.Query(request, out totalCount),
                TotalCount = totalCount
            });
        }
        private void LoadListBoxData()
        {
            CommonDataFacade          commonDataFacade = new CommonDataFacade(this);
            OrderCheckItemQueryFilter queryFilter      = new OrderCheckItemQueryFilter();

            queryFilter.PagingInfo = new PagingInfo
            {
                PageSize  = int.MaxValue,
                PageIndex = 0,
                SortBy    = ""
            };
            queryFilter.ReferenceType = "ST";
            queryFilter.CompanyCode   = CPApplication.Current.CompanyCode;
            OrderCheckItemFacade facade = new OrderCheckItemFacade(this);

            facade.QueryOrderCheckItem(queryFilter, (obj, args) =>
            {
                if (args.FaultsHandle())
                {
                    return;
                }

                rightList = DynamicConverter <OrderCheckItemVM> .ConvertToVMList(args.Result.Rows);
                rightList = FindAll(rightList, x => x.SysNo.HasValue);

                ListBox_SelectedShippingTypeList.ItemsSource = rightList;

                commonDataFacade.GetShippingTypeList(true, (obj2, args2) =>
                {
                    leftList = args2.Result;
                    leftList = FindAll(leftList, x => x.SysNo.HasValue);

                    if (rightList != null && leftList != null)
                    {
                        foreach (OrderCheckItemVM p in rightList)
                        {
                            leftList.Remove(leftList.Where(x => x.SysNo.ToString() == p.ReferenceContent).FirstOrDefault());
                        }
                    }
                    ListBox_ShippingTypeList.ItemsSource = leftList;
                });
            });
        }
        private void DataGrid_Result_LoadingDataSource(object sender, Newegg.Oversea.Silverlight.Controls.Data.LoadingDataEventArgs e)
        {
            OrderCheckItemQueryFilter queryFilter = new OrderCheckItemQueryFilter();

            queryFilter.PagingInfo = new PagingInfo
            {
                PageSize  = e.PageSize,
                PageIndex = e.PageIndex,
                SortBy    = e.SortField
            };
            queryFilter.ReferenceContent = (Combox_ServiceObject.SelectedIndex == 0 ? string.Empty : model.ReferenceContent);
            queryFilter.ReferenceType    = (Combox_DTServiceType.SelectedIndex == 0 ? string.Empty : model.ReferenceType);
            queryFilter.ReferenceTypeIn  = "'DT11','DT12'";
            OrderCheckItemFacade facade = new OrderCheckItemFacade(this);

            facade.QueryOrderCheckItem(queryFilter, (obj, args) =>
            {
                if (args.FaultsHandle())
                {
                    return;
                }
                List <OrderCheckItemVM> list           = DynamicConverter <OrderCheckItemVM> .ConvertToVMList(args.Result.Rows);
                List <CodeNamePair> OrderCheckItemType = new List <CodeNamePair>();
                CodeNamePairHelper.GetList("Customer", "DistributionServiceType", (obj2, args2) =>
                {
                    OrderCheckItemType = args2.Result;
                    foreach (CodeNamePair pair in OrderCheckItemType)
                    {
                        foreach (OrderCheckItemVM itemVM in list)
                        {
                            if (itemVM.ReferenceType.ToString() == pair.Code)
                            {
                                itemVM.ReferenceTypeName = pair.Name;
                            }
                        }
                    }
                });
                DataGrid_DTServiceList.ItemsSource = list;
                DataGrid_DTServiceList.TotalCount  = args.Result.TotalCount;
            });
        }
Beispiel #6
0
        private void DataGrid_Result_LoadingDataSource(object sender, Newegg.Oversea.Silverlight.Controls.Data.LoadingDataEventArgs e)
        {
            OrderCheckItemQueryFilter queryFilter = new OrderCheckItemQueryFilter();

            queryFilter.PagingInfo = new PagingInfo
            {
                PageSize  = e.PageSize,
                PageIndex = e.PageIndex,
                SortBy    = e.SortField
            };
            queryFilter.ReferenceTypeIn = "'CA','CP','CN'";
            facade = new OrderCheckItemFacade(this);
            facade.QueryOrderCheckItem(queryFilter, (obj, args) =>
            {
                if (args.FaultsHandle())
                {
                    return;
                }
                List <OrderCheckItemVM> list           = DynamicConverter <OrderCheckItemVM> .ConvertToVMList(args.Result.Rows);
                List <CodeNamePair> OrderCheckItemType = new List <CodeNamePair>();
                CodeNamePairHelper.GetList("Customer", "KeyWordType", (obj2, args2) =>
                {
                    OrderCheckItemType = args2.Result;  //在顾客端拿到的类型为: List<CodeNamePair>
                    foreach (CodeNamePair pair in OrderCheckItemType)
                    {
                        foreach (OrderCheckItemVM itemVM in list)
                        {
                            if (itemVM.ReferenceType.ToString() == pair.Code)
                            {
                                itemVM.ReferenceTypeName = pair.Name;
                            }
                        }
                    }
                });
                dataGrid1.ItemsSource = list;
                dataGrid1.TotalCount  = args.Result.TotalCount;
            });
        }
Beispiel #7
0
        private void LoadListBoxData()
        {
            OrderCheckItemQueryFilter queryFilter = new OrderCheckItemQueryFilter();

            queryFilter.PagingInfo = new PagingInfo
            {
                PageSize  = int.MaxValue,
                PageIndex = 0,
                SortBy    = ""
            };
            queryFilter.ReferenceType = "FP";
            queryFilter.CompanyCode   = CPApplication.Current.CompanyCode;
            OrderCheckItemFacade facade = new OrderCheckItemFacade(this);

            facade.QueryOrderCheckItem(queryFilter, (obj, args) =>
            {
                if (args.FaultsHandle())
                {
                    return;
                }

                rightList = DynamicConverter <OrderCheckItemVM> .ConvertToVMList(args.Result.Rows);
                ListBox_SelectedPayTypeList.ItemsSource = rightList;

                CodeNamePairHelper.GetList("Customer", "FPType", (obj2, args2) =>
                {
                    leftList = args2.Result;
                    if (rightList != null && leftList != null)
                    {
                        foreach (OrderCheckItemVM p in rightList)
                        {
                            leftList.Remove(leftList.Where(x => x.Code == p.ReferenceContent).FirstOrDefault());
                        }
                    }
                    ListBox_PayTypeList.ItemsSource = leftList;
                });
            });
        }
Beispiel #8
0
        private void DataGrid_Result_LoadingDataSource(object sender, Newegg.Oversea.Silverlight.Controls.Data.LoadingDataEventArgs e)
        {
            OrderCheckItemQueryFilter queryFilter = new OrderCheckItemQueryFilter();

            queryFilter.PagingInfo = new PagingInfo
            {
                PageSize  = e.PageSize,
                PageIndex = e.PageIndex,
                SortBy    = e.SortField
            };
            amountType.ForEach(item =>
            {
                queryFilter.ReferenceTypeIn += string.Format("'{0}',", item.Code);
            });
            queryFilter.ReferenceTypeIn = queryFilter.ReferenceTypeIn.TrimEnd(',');
            OrderCheckItemFacade facade = new OrderCheckItemFacade(this);

            facade.QueryOrderCheckItem(queryFilter, (obj, args) =>
            {
                if (args.FaultsHandle())
                {
                    return;
                }
                List <OrderCheckItemVM> list = DynamicConverter <OrderCheckItemVM> .ConvertToVMList(args.Result.Rows);
                foreach (CodeNamePair pair in amountType)
                {
                    foreach (OrderCheckItemVM itemVM in list)
                    {
                        if (itemVM.ReferenceType.ToString() == pair.Code)
                        {
                            itemVM.ReferenceTypeName = pair.Name;
                        }
                    }
                }
                dataGridAmount.ItemsSource = list;
                dataGridAmount.TotalCount  = args.Result.TotalCount;
            });
        }
Beispiel #9
0
        private void DataGrid_Result_LoadingDataSource(object sender, Newegg.Oversea.Silverlight.Controls.Data.LoadingDataEventArgs e)
        {
            OrderCheckItemQueryFilter queryFilter = new OrderCheckItemQueryFilter();

            queryFilter.PagingInfo = new PagingInfo
            {
                PageSize  = e.PageSize,
                PageIndex = e.PageIndex,
                SortBy    = e.SortField
            };
            queryFilter.ReferenceType = "SA";
            OrderCheckItemFacade facade = new OrderCheckItemFacade(this);

            facade.QueryOrderCheckItem(queryFilter, (obj, args) =>
            {
                if (args.FaultsHandle())
                {
                    return;
                }
                List <OrderCheckItemVM> list          = DynamicConverter <OrderCheckItemVM> .ConvertToVMList(args.Result.Rows);
                dataGridAutoCheckTimeList.ItemsSource = list;
                dataGridAutoCheckTimeList.TotalCount  = args.Result.TotalCount;
            });
        }
Beispiel #10
0
        public void QueryOrderCheckItem(OrderCheckItemQueryFilter request, EventHandler <RestClientEventArgs <dynamic> > callback)
        {
            string relativeUrl = "/CustomerService/OrderCheckItem/Query";

            restClient.QueryDynamicData(relativeUrl, request, callback);
        }
Beispiel #11
0
        public virtual DataTable Query(OrderCheckItemQueryFilter queryCriteria, out int totalCount)
        {
            PagingInfoEntity pagingEntity = new PagingInfoEntity();

            pagingEntity.SortField     = queryCriteria.PagingInfo.SortBy;
            pagingEntity.MaximumRows   = queryCriteria.PagingInfo.PageSize;
            pagingEntity.StartRowIndex = queryCriteria.PagingInfo.PageIndex * queryCriteria.PagingInfo.PageSize;
            var cmd = DataCommandManager.CreateCustomDataCommandFromConfig("GetOrderCheckItem");

            using (var sqlBuilder = new DynamicQuerySqlBuilder(cmd.CommandText, cmd, pagingEntity, "a.SysNo DESC"))
            {
                if (string.Compare(queryCriteria.ReferenceType, "PC3") == 0)
                {
                    if (queryCriteria.C1SysNo.HasValue)
                    {
                        string subQuerySQLC1 = @"SELECT [Category3Sysno]
                        FROM  OverseaContentManagement.dbo.V_CM_CategoryInfo with(nolock)
                        WHERE [Category1Sysno] = " + queryCriteria.C1SysNo;

                        sqlBuilder.ConditionConstructor.AddSubQueryCondition(QueryConditionRelationType.AND,
                                                                             "a.Description",
                                                                             QueryConditionOperatorType.In,
                                                                             subQuerySQLC1
                                                                             );
                    }
                    else if (queryCriteria.C2SysNo.HasValue)
                    {
                        string subQuerySQLC1 = @"SELECT [Category3Sysno]
                        FROM  OverseaContentManagement.dbo.V_CM_CategoryInfo with(nolock)
                        WHERE [Category2Sysno] = " + queryCriteria.C2SysNo;

                        sqlBuilder.ConditionConstructor.AddSubQueryCondition(QueryConditionRelationType.AND,
                                                                             "a.Description",
                                                                             QueryConditionOperatorType.In,
                                                                             subQuerySQLC1
                                                                             );
                    }
                }
                if (!string.IsNullOrEmpty(queryCriteria.ReferenceTypeIn) &&
                    string.Compare(queryCriteria.ReferenceTypeIn, "'DT11','DT12'") == 0)
                {
                    sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND,
                                                                 "a.sysno",
                                                                 DbType.Int32, "@sysno",
                                                                 QueryConditionOperatorType.Equal,
                                                                 queryCriteria.SysNo);
                }
                sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND,
                                                             "a.ReferenceType",
                                                             DbType.String, "@ReferenceType",
                                                             QueryConditionOperatorType.Equal,
                                                             queryCriteria.ReferenceType);

                sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND,
                                                             "a.ReferenceContent",
                                                             DbType.String, "@ReferenceContent",
                                                             QueryConditionOperatorType.Equal,
                                                             queryCriteria.ReferenceContent);

                sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND,
                                                             "a.Status",
                                                             DbType.String, "@Status",
                                                             QueryConditionOperatorType.Equal,
                                                             queryCriteria.Status);

                sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND,
                                                             "a.Description",
                                                             DbType.String, "@Description",
                                                             QueryConditionOperatorType.Equal,
                                                             queryCriteria.Description);

                sqlBuilder.ConditionConstructor.AddSubQueryCondition(QueryConditionRelationType.AND,
                                                                     "a.ReferenceType",
                                                                     QueryConditionOperatorType.In,
                                                                     queryCriteria.ReferenceTypeIn);
                sqlBuilder.ConditionConstructor.AddCondition(
                    QueryConditionRelationType.AND,
                    "a.CompanyCode", DbType.AnsiStringFixedLength, "@CompanyCode",
                    QueryConditionOperatorType.Equal,
                    queryCriteria.CompanyCode);
                cmd.CommandText = sqlBuilder.BuildQuerySql();
                DataTable dt = cmd.ExecuteDataTable(4, typeof(OrderCheckStatus));
                totalCount = Convert.ToInt32(cmd.GetParameterValue("@TotalCount"));
                return(dt);
            }
        }