示例#1
0
 public void ProcessRequest(HttpContext context)
 {
     //清空之前数据
     context.Response.Clear();
     //检测是否含有session
     if (context.Session.Count < 5)
     {
         //跳转
         context.Response.Redirect("/Account/Login", true);
         //停止加载后续内容
         context.Response.End();
         //直接返回
         return;
     }
     //执行基类的方法
     if (!base.CheckIsLogin(context))
     {
         return;
     }
     //当前使用的查询参数类型
     var parField = ParameterField.None;
     //用户传入的生产编号
     string productNum = context.Request["pnum"];
     string custName = string.Empty;
     string custNum = string.Empty;
     string remark = string.Empty;
     string dCustName = string.Empty;
     string dOrderId = string.Empty;
     string dProductNum = string.Empty;
     string dCustNum = string.Empty;
     string dOrderNum = string.Empty;
     string dSpecification = string.Empty;
     string dBatchNum = string.Empty;
     //检测生产编号
     if (productNum != null && productNum.Length > 0)
     {
         //查询字段类型为生产编号
         parField = ParameterField.ProductNum;
         //设置参数值
         productNum = "%" + productNum.Trim().Replace("*", "%") + "%";
         ////检测第二个字符是否P或者S
         //if (productNum.Length > 3)
         //{
         //    //取得前缀
         //    string prefix = string.Empty;
         //    //如果第一个字符为小数点转换为P-
         //    if (productNum.StartsWith("."))
         //    {
         //        prefix = "P-";
         //        productNum = productNum.Substring(1);
         //    }
         //    else if (productNum.Substring(0, 2) == "P-" || productNum.Substring(0, 2) == "F-")
         //    {
         //        prefix = productNum.Substring(0, 2);
         //        productNum = productNum.Substring(2);
         //    }
         //    if (productNum.Substring(1, 1) != "P" && productNum.Substring(1, 1) != "S")
         //    {
         //        //生产编号自动加入2PI
         //        prefix += "2PI";
         //    }
         //    productNum = prefix + productNum;
         //}
     }
     else
     {
         //用户传入的客户名称
         custName = context.Request["cname"];
         if (custName != null && custName.Length > 0)
         {
             //查询字段类型为客户名称
             parField = ParameterField.CustName;
             //设置参数值
             custName = "%" + custName.Trim().Replace("*", "%") + "%";
         }
         else
         {
             //用户传入的客户料号
             custNum = context.Request["cnum"];
             if (custNum != null && custNum.Length > 0)
             {
                 //查询字段类型为客户料号
                 parField = ParameterField.CustNum;
                 //设置参数值
                 custNum = "%" + custNum.Trim().Replace("*", "%") + "%";
             }
             else
             {
                 //用户传入的备注
                 remark = context.Request["remark"];
                 if (remark != null && remark.Length > 0)
                 {
                     //查询字段类型为备注
                     parField = ParameterField.Remark;
                     //设置参数值
                     remark = "%" + remark.Trim().Replace("*", "%") + "%";
                 }
                 else
                 {
                     //用户传入的送货单中的客户名称
                     dCustName = context.Request["dcname"];
                     if (dCustName != null && dCustName.Length > 0)
                     {
                         //查询字段类型为送货单中的客户名称
                         parField = ParameterField.DeliveryCustName;
                         //设置参数值
                         dCustName = "%" + dCustName.Trim().Replace("*", "%") + "%";
                     }
                     else
                     {
                         //用户传入的送货单中的订单序号
                         dOrderId = context.Request["doid"];
                         if (dOrderId != null && dOrderId.Length > 0)
                         {
                             //查询字段类型为送货单中的订单序号
                             parField = ParameterField.DeliveryOrderId;
                             //设置参数值
                             dOrderId = dOrderId.Trim();
                         }
                         else
                         {
                             //用户传入的送货单中的生产编号
                             dProductNum = context.Request["dpnum"];
                             if (dProductNum != null && dProductNum.Length > 0)
                             {
                                 //查询字段类型为送货单中的生产编号
                                 parField = ParameterField.DeliveryProductNum;
                                 //设置参数值
                                 dProductNum = "%" + dProductNum.Trim().Replace("*", "%") + "%";
                             }
                             else
                             {
                                 //用户传入的送货单中的客户料号
                                 dCustNum = context.Request["dcnum"];
                                 if (dCustNum != null && dCustNum.Length > 0)
                                 {
                                     //查询字段类型为送货单中的客户料号
                                     parField = ParameterField.DeliveryCustNum;
                                     //设置参数值
                                     dCustNum = "%" + dCustNum.Trim().Replace("*", "%") + "%";
                                 }
                                 else
                                 {
                                     //用户传入的送货单中的订单编号
                                     dOrderNum = context.Request["donum"];
                                     if (dOrderNum != null && dOrderNum.Length > 0)
                                     {
                                         //查询字段类型为送货单中的订单编号
                                         parField = ParameterField.DeliveryOrderNum;
                                         //设置参数值
                                         dOrderNum = "%" + dOrderNum.Trim().Replace("*", "%") + "%";
                                     }
                                     else
                                     {
                                         //用户传入的送货单中的规格
                                         dSpecification = context.Request["dspecifi"];
                                         if (dSpecification != null && dSpecification.Length > 0)
                                         {
                                             //查询字段类型为送货单中的规格
                                             parField = ParameterField.DeliverySpecification;
                                             //设置参数值
                                             dSpecification = "%" + dSpecification.Trim().Replace("*", "%") + "%";
                                         }
                                         else
                                         {
                                             //用户传入的送货单中的批号
                                             dBatchNum = context.Request["dbatch"];
                                             if (dBatchNum != null && dBatchNum.Length > 0)
                                             {
                                                 //查询字段类型为送货单中的批号
                                                 parField = ParameterField.DeliveryBatchNum;
                                                 //设置参数值
                                                 dBatchNum = "%" + dBatchNum.Trim().Replace("*", "%") + "%";
                                             }
                                         }
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
         }
     }
     //当前未使用特定的三种字段类型之一进行查询则不输出值直接退出
     if (parField == ParameterField.None)
     {
         return;
     }
     //用户传入的送货单类型
     string billType = context.Request["btype"];
     byte iBillType = 0;
     //检测送货单类型
     if (billType == null || billType.Length == 0 || !byte.TryParse(billType, out iBillType) || iBillType < 0 || iBillType > 3)
     {
         if (parField == ParameterField.DeliveryCustName ||
             parField == ParameterField.DeliveryCustNum ||
             parField == ParameterField.DeliveryOrderId ||
             parField == ParameterField.DeliveryOrderNum ||
             parField == ParameterField.DeliveryProductNum ||
             parField == ParameterField.DeliverySpecification ||
             parField == ParameterField.DeliveryBatchNum
         )
         {
             context.Response.Write("未提供送货单类型参数或者参数错误!");
             return;
         }
     }
     //待输出到浏览器的数据
     string strResult = string.Empty;
     //检测查询类型
     switch (parField)
     {
         //使用生产编号进行查询
         case ParameterField.ProductNum:
             //数据适配器
             using (var da = new t_pmc_orderTableAdapter())
             {
                 //将查询到的结果保存到泛型变量中
                 var l = new List<OrderLiItem>();
                 //获取数据
                 var tab = da.GetDataLikeProductNum(productNum);
                 //获取单据数据
                 AddOrderListItem(tab, ref l);
                 //如果在客户清单中查询到数据
                 if (l.Count > 0)
                 {
                     //将泛型变量各项目放入数组
                     var itms = new OrderLiItem[l.Count];
                     //复制泛型变量的内容到数组
                     l.CopyTo(itms);
                     //循环重新设置单只数
                     foreach (var itm in itms)
                     {
                         //将实例加入li
                         strResult += itm.ToString();
                     }
                 }
             }
             break;
         //客户名称
         case ParameterField.CustName:
             //数据适配器
             using (var da = new t_pmc_custTableAdapter())
             {
                 //将查询到的结果保存到泛型变量中
                 var l = new List<CustNameLiItem>();
                 //先当作客户代码来查询
                 var tab = da.GetDataLikeCustId(custName);
                 if (tab.Rows.Count == 0)
                 {
                     //当作客户名称来查询
                     tab = da.GetDataLikeCustName(custName);
                 }
                 //获取单据数据
                 AddCustNameListItem(tab, ref l);
                 //如果在客户清单中查询到数据
                 if (l.Count > 0)
                 {
                     //将泛型变量各项目放入数组
                     var itms = new CustNameLiItem[l.Count];
                     //复制泛型变量的内容到数组
                     l.CopyTo(itms);
                     //循环重新设置单只数
                     foreach (var itm in itms)
                     {
                         //将实例加入li
                         strResult += itm.ToString();
                     }
                 }
             }
             break;
         //客户料号
         case ParameterField.CustNum:
             //数据适配器
             using (var da = new t_pmc_orderTableAdapter())
             {
                 //将查询到的结果保存到泛型变量中
                 var l = new List<OrderLiItem>();
                 //获取数据
                 var tab = da.GetDataLikeCustNum(custNum);
                 //写入泛型对象
                 AddOrderListItem(tab, ref l);
                 //如果在客户清单中查询到数据
                 if (l.Count > 0)
                 {
                     //将泛型变量各项目放入数组
                     var itms = new OrderLiItem[l.Count];
                     //复制泛型变量的内容到数组
                     l.CopyTo(itms);
                     //循环重新设置单只数
                     foreach (var itm in itms)
                     {
                         //将实例加入li
                         strResult += itm.ToString();
                     }
                 }
             }
             break;
         //备注
         case ParameterField.Remark:
             //数据适配器
             using (var da = new t_pmc_orderTableAdapter())
             {
                 //将查询到的结果保存到泛型变量中
                 var l = new List<RemarkLiItem>();
                 //获取数据
                 var tab = da.GetDataLikeRemark(remark);
                 //写入泛型对象
                 AddRemarkListItem(tab, ref l);
                 //如果在客户清单中查询到数据
                 if (l.Count > 0)
                 {
                     //将泛型变量各项目放入数组
                     var itms = new RemarkLiItem[l.Count];
                     //复制泛型变量的内容到数组
                     l.CopyTo(itms);
                     //循环重新设置单只数
                     foreach (var itm in itms)
                     {
                         //将实例加入li
                         strResult += itm.ToString();
                     }
                 }
             }
             break;
         //送货单中的客户名称
         case ParameterField.DeliveryCustName:
             //数据适配器
             using (var da = new t_pmc_custTableAdapter())
             {
                 //将查询到的结果保存到泛型变量中
                 var l = new List<DeliveryCustNameLiItem>();
                 //先当作客户代码来查询
                 var tab = da.GetDataLikeCustId(dCustName);
                 if (tab.Rows.Count == 0)
                 {
                     //当作客户名称来查询
                     tab = da.GetDataLikeCustName(dCustName);
                 }
                 //写入泛型对象
                 AddDeliveryCustNameListItem(tab, ref l);
                 //如果在客户清单中查询到数据
                 if (l.Count > 0)
                 {
                     //将泛型变量各项目放入数组
                     var itms = new DeliveryCustNameLiItem[l.Count];
                     //复制泛型变量的内容到数组
                     l.CopyTo(itms);
                     //循环重新设置单只数
                     foreach (var itm in itms)
                     {
                         //将实例加入li
                         strResult += itm.ToString();
                     }
                 }
             }
             break;
         //送货单中的订单序号
         case ParameterField.DeliveryOrderId:
             //数据适配器
             using (var da = new t_pmc_orderTableAdapter())
             {
                 //将查询到的结果保存到泛型变量中
                 var l = new List<DeliveryOrderLiItem>();
                 //获取数据
                 var tab = da.GetDataByOrderId(dOrderId);
                 //写入泛型对象
                 AddDeliveryOrderListItem(iBillType, tab, ref l);
                 //如果在客户清单中查询到数据
                 if (l.Count > 0)
                 {
                     //将泛型变量各项目放入数组
                     var itms = new DeliveryOrderLiItem[l.Count];
                     //复制泛型变量的内容到数组
                     l.CopyTo(itms);
                     //循环重新设置单只数
                     foreach (var itm in itms)
                     {
                         //将实例加入li
                         strResult += itm.ToString();
                     }
                 }
             }
             break;
         //送货单中的订单编号
         case ParameterField.DeliveryOrderNum:
             //数据适配器
             using (var da = new t_pmc_orderTableAdapter())
             {
                 //将查询到的结果保存到泛型变量中
                 var l = new List<DeliveryOrderLiItem>();
                 //获取数据
                 var tab = da.GetBalanceDataLikeOrderNum(dOrderNum);
                 //写入泛型对象
                 AddDeliveryOrderListItem(iBillType, tab, ref l);
                 //如果在客户清单中查询到数据
                 if (l.Count > 0)
                 {
                     //将泛型变量各项目放入数组
                     var itms = new DeliveryOrderLiItem[l.Count];
                     //复制泛型变量的内容到数组
                     l.CopyTo(itms);
                     //循环重新设置单只数
                     foreach (var itm in itms)
                     {
                         //将实例加入li
                         strResult += itm.ToString();
                     }
                 }
             }
             break;
         //送货单中的生产编号
         case ParameterField.DeliveryProductNum:
             //数据适配器
             using (var da = new t_pmc_orderTableAdapter())
             {
                 //将查询到的结果保存到泛型变量中
                 var l = new List<DeliveryOrderLiItem>();
                 //获取数据
                 var tab = da.GetBalanceDataLikeProductNum(dProductNum);
                 //写入泛型对象
                 AddDeliveryOrderListItem(iBillType, tab, ref l);
                 //如果在客户清单中查询到数据
                 if (l.Count > 0)
                 {
                     //将泛型变量各项目放入数组
                     var itms = new DeliveryOrderLiItem[l.Count];
                     //复制泛型变量的内容到数组
                     l.CopyTo(itms);
                     //循环重新设置单只数
                     foreach (var itm in itms)
                     {
                         //将实例加入li
                         strResult += itm.ToString();
                     }
                 }
             }
             break;
         //送货单中的客户料号
         case ParameterField.DeliveryCustNum:
             //数据适配器
             using (var da = new t_pmc_orderTableAdapter())
             {
                 //将查询到的结果保存到泛型变量中
                 var l = new List<DeliveryOrderLiItem>();
                 //获取数据
                 var tab = da.GetBalanceDataLikeCustNum(dCustNum);
                 //写入泛型对象
                 AddDeliveryOrderListItem(iBillType, tab, ref l);
                 //如果在客户清单中查询到数据
                 if (l.Count > 0)
                 {
                     //将泛型变量各项目放入数组
                     var itms = new DeliveryOrderLiItem[l.Count];
                     //复制泛型变量的内容到数组
                     l.CopyTo(itms);
                     //循环重新设置单只数
                     foreach (var itm in itms)
                     {
                         //将实例加入li
                         strResult += itm.ToString();
                     }
                 }
             }
             break;
         //送货单中的规格
         case ParameterField.DeliverySpecification:
             //数据适配器
             using (var da = new t_pmc_orderTableAdapter())
             {
                 //将查询到的结果保存到泛型变量中
                 var l = new List<DeliveryOrderLiItem>();
                 //获取数据
                 var tab = da.GetBalanceDataLikeSpecification(dSpecification);
                 //写入泛型对象
                 AddDeliveryOrderListItem(iBillType, tab, ref l);
                 //如果在客户清单中查询到数据
                 if (l.Count > 0)
                 {
                     //将泛型变量各项目放入数组
                     var itms = new DeliveryOrderLiItem[l.Count];
                     //复制泛型变量的内容到数组
                     l.CopyTo(itms);
                     //循环重新设置单只数
                     foreach (var itm in itms)
                     {
                         //将实例加入li
                         strResult += itm.ToString();
                     }
                 }
             }
             break;
         //送货单中的批号
         case ParameterField.DeliveryBatchNum:
             //数据适配器
             using (var da = new t_pmc_orderTableAdapter())
             {
                 //将查询到的结果保存到泛型变量中
                 var l = new List<DeliveryOrderLiItem>();
                 //获取数据
                 var tab = da.GetBalanceDataLikeBatchNum(dBatchNum);
                 //写入泛型对象
                 AddDeliveryOrderListItem(iBillType, tab, ref l);
                 //如果在客户清单中查询到数据
                 if (l.Count > 0)
                 {
                     //将泛型变量各项目放入数组
                     var itms = new DeliveryOrderLiItem[l.Count];
                     //复制泛型变量的内容到数组
                     l.CopyTo(itms);
                     //循环重新设置单只数
                     foreach (var itm in itms)
                     {
                         //将实例加入li
                         strResult += itm.ToString();
                     }
                 }
             }
             break;
     }
     //加入ul头尾
     strResult = "<ul>\n" + strResult + "</ul>\n";
     //写入数据
     context.Response.Write(strResult);
 }
示例#2
0
 /// <summary>
 /// 添加获取到的数据到泛型变量
 /// </summary>
 /// <param name="tab">包含指定格式的数据表</param>
 /// <param name="l">将数据填写到的泛型变量</param>
 private void AddOrderListItem(DataSetPmcOrderMgr.t_pmc_orderDataTable tab, ref List<OrderLiItem> l)
 {
     //li内容
     foreach (DataSetPmcOrderMgr.t_pmc_orderRow row in tab.Rows)
     {
         //实例化li项目类
         var itm = new OrderLiItem();
         //设置实例的值
         //订单序号
         itm.OrderId = row.order_id;
         //状态
         if (!row.IsstateNull())
         {
             itm.State = row.state;
         }
         //良率
         itm.OkPercent = row.ok_percent;
         //生产编号
         itm.ProductNum = row.product_num;
         //pcs面积
         itm.PcsArea = row.pcs_area;
         //客户名称
         itm.CustName = row.cust_name;
         //客户料号
         itm.CustNum = row.cust_num;
         //订单编号
         if (!row.Isorder_numNull())
         {
             itm.OrderNum = row.order_num;
         }
         //订单pcs总数
         itm.OrderPcsQty = row.order_pcs_qty;
         //订单pcs面积
         itm.OrderPcsArea = row.order_pcs_area;
         //下单日期
         itm.OrderDate = row.order_date;
         //需求日期
         itm.NeedDate = row.need_date;
         //生产日期
         if (!row.Isproduct_dateNull())
         {
             itm.ProductDate = row.product_date;
         }
         //备注
         if (!row.IsremarkNull())
         {
             itm.Remark = row.remark;
         }
         //将实例加入泛型变量
         l.Add(itm);
     }
 }
示例#3
0
 /// <summary>
 /// 添加获取到的数据到泛型变量
 /// </summary>
 /// <param name="tab">包含指定格式的数据表</param>
 /// <param name="l">将数据填写到的泛型变量</param>
 private void AddOrderListItem(DataSetPmcOrderMgr.t_pmc_orderDataTable tab, ref List<OrderLiItem> l)
 {
     //li内容
     foreach (DataSetPmcOrderMgr.t_pmc_orderRow row in tab.Rows)
     {
         //实例化li项目类
         var itm = new OrderLiItem();
         //设置实例的值
         //订单序号
         itm.OrderId = row.order_id;
         //状况
         if (!row.IsstateNull())
         {
             itm.State = row.state;
         }
         //良率
         if (!row.Isok_percentNull())
         {
             itm.OkPercent = row.ok_percent;
         }
         //生产编号
         if (!row.Isproduct_numNull())
         {
             itm.ProductNum = row.product_num;
         }
         //pnl长
         itm.PnlLength = row.pnl_length;
         //pnl宽
         itm.PnlWidth = row.pnl_width;
         //客户名称
         if (!row.Iscust_nameNull())
         {
             itm.CustName = row.cust_name;
         }
         //客户料号
         itm.CustNum = row.cust_num;
         //订单编号
         if (!row.Isorder_numNull())
         {
             itm.OrderNum = row.order_num;
         }
         //事业部
         itm.MarketDept = row.Ismarket_deptNull() ? string.Empty : row.market_dept;
         //销售单号
         itm.SaleNum = row.Issale_numNull() ? string.Empty : row.sale_num;
         //特殊流程
         itm.SpecialFlow = row.Isspecial_flowNull() ? string.Empty : row.special_flow;
         //SMT备注
         itm.SmtRemark = row.Issmt_remarkNull() ? string.Empty : row.smt_remark;
         //FPC单价
         itm.UnitPriceFpc = row.Isunit_price_fpcNull() ? 0m : row.unit_price_fpc;
         //SMT单价
         itm.UnitPriceSmt = row.Isunit_price_smtNull() ? 0m : row.unit_price_smt;
         //批次号
         itm.BatchNum = row.Isbatch_numNull() ? string.Empty : row.batch_num;
         //规格
         itm.Specification = row.IsspecificationNull() ? string.Empty : row.specification;
         //备品数量
         itm.FocPcsQty = row.Isfoc_pcs_qtyNull() ? 0 : row.foc_pcs_qty;
         //覆盖膜
         itm.CoverMembrane = row.Iscover_membraneNull() ? 0 : row.cover_membrane;
         //投料率
         itm.FeedingRate = row.Isfeeding_rateNull() ? 0m : row.feeding_rate;
         //订单pcs数
         itm.OrderPcsQty = row.order_pcs_qty;
         //开料pnl数
         itm.TotalPnlQty = row.total_pnl_qty;
         //pnl含pcs数
         itm.PnlCountPcs = row.pnl_count_pcs;
         //开料pcs数
         itm.TotalPcsQty = row.total_pcs_qty;
         //落单日期
         itm.OrderDate = row.order_date;
         //需求日期
         if (!row.Isneed_dateNull())
         {
             itm.NeedDate = row.need_date;
         }
         //生产日期
         if (!row.Isproduct_dateNull())
         {
             itm.ProductDate = row.product_date;
         }
         //备注
         if (!row.IsremarkNull())
         {
             itm.Remark = row.remark;
         }
         //将实例加入泛型变量
         l.Add(itm);
     }
 }
示例#4
0
 public void ProcessRequest(HttpContext context)
 {
     //清空之前数据
     context.Response.Clear();
     //检测是否含有session
     if (context.Session.Count < 5)
     {
         //跳转
         context.Response.Redirect("/Account/Login", true);
         //停止加载后续内容
         context.Response.End();
         //直接返回
         return;
     }
     //执行基类的方法
     if (!base.CheckIsLogin(context))
     {
         return;
     }
     //当前使用的查询参数类型
     var parField = ParameterField.None;
     //用户传入的生产编号
     string productNum = context.Request["pnum"];
     string custName = string.Empty;
     string custNum = string.Empty;
     string remark = string.Empty;
     string dCustName = string.Empty;
     string dOrderId = string.Empty;
     string dOrderNum = string.Empty;
     string dProductNum = string.Empty;
     string dCustNum = string.Empty;
     //检测生产编号
     if (productNum != null && productNum.Length > 0)
     {
         //查询字段类型为生产编号
         parField = ParameterField.ProductNum;
         //设置参数值
         productNum = "%" + productNum.Trim().Replace("*", "%") + "%";
     }
     else
     {
         //用户传入的客户名称
         custName = context.Request["cname"];
         if (custName != null && custName.Length > 0)
         {
             //查询字段类型为客户名称
             parField = ParameterField.CustName;
             //设置参数值
             custName = "%" + custName.Trim().Replace("*", "%") + "%";
         }
         else
         {
             //用户传入的客户料号
             custNum = context.Request["cnum"];
             if (custNum != null && custNum.Length > 0)
             {
                 //查询字段类型为客户料号
                 parField = ParameterField.CustNum;
                 //设置参数值
                 custNum = "%" + custNum.Trim().Replace("*", "%") + "%";
             }
             else
             {
                 //用户传入的备注
                 remark = context.Request["remark"];
                 if (remark != null && remark.Length > 0)
                 {
                     //查询字段类型为备注
                     parField = ParameterField.Remark;
                     //设置参数值
                     remark = "%" + remark.Trim().Replace("*", "%") + "%";
                 }
                 else
                 {
                     //用户传入的送货单中的客户名称
                     dCustName = context.Request["dcname"];
                     if (dCustName != null && dCustName.Length > 0)
                     {
                         //查询字段类型为送货单中的客户名称
                         parField = ParameterField.DeliveryCustName;
                         //设置参数值
                         dCustName = "%" + dCustName.Trim().Replace("*", "%") + "%";
                     }
                     else
                     {
                         //用户传入的送货单中的订单序号
                         dOrderId = context.Request["doid"];
                         if (dOrderId != null && dOrderId.Length > 0)
                         {
                             //查询字段类型为送货单中的订单序号
                             parField = ParameterField.DeliveryOrderId;
                             //设置参数值
                             dOrderId = dOrderId.Trim();
                         }
                         else
                         {
                             //用户传入的送货单中的订单编号
                             dOrderNum = context.Request["donum"];
                             if (dOrderNum != null && dOrderNum.Length > 0)
                             {
                                 //查询字段类型为送货单中的订单编号
                                 parField = ParameterField.DeliveryOrderNum;
                                 //设置参数值
                                 dOrderNum = "%" + dOrderNum.Trim().Replace("*", "%") + "%";
                             }
                             else
                             {
                                 //用户传入的送货单中的生产编号
                                 dProductNum = context.Request["dpnum"];
                                 if (dProductNum != null && dProductNum.Length > 0)
                                 {
                                     //查询字段类型为送货单中的生产编号
                                     parField = ParameterField.DeliveryProductNum;
                                     //设置参数值
                                     dProductNum = "%" + dProductNum.Trim().Replace("*", "%") + "%";
                                 }
                                 else
                                 {
                                     //用户传入的送货单中的客户料号
                                     dCustNum = context.Request["dcnum"];
                                     if (dCustNum != null && dCustNum.Length > 0)
                                     {
                                         //查询字段类型为送货单中的客户料号
                                         parField = ParameterField.DeliveryCustNum;
                                         //设置参数值
                                         dCustNum = "%" + dCustNum.Trim().Replace("*", "%") + "%";
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
         }
     }
     //当前未使用特定的三种字段类型之一进行查询则不输出值直接退出
     if (parField == ParameterField.None)
     {
         return;
     }
     //待输出到浏览器的数据
     string strResult = string.Empty;
     //检测查询类型
     switch (parField)
     {
         //使用生产编号进行查询
         case ParameterField.ProductNum:
             //数据适配器
             using (var da = new t_pmc_orderTableAdapter())
             {
                 //将查询到的结果保存到泛型变量中
                 var l = new List<OrderLiItem>();
                 //获取数据
                 var tab = da.GetDataLikeProductNum(productNum);
                 //获取单据数据
                 AddOrderListItem(tab, ref l);
                 //如果在客户清单中查询到数据
                 if (l.Count > 0)
                 {
                     //将泛型变量各项目放入数组
                     var itms = new OrderLiItem[l.Count];
                     //复制泛型变量的内容到数组
                     l.CopyTo(itms);
                     //循环重新设置单只数
                     foreach (var itm in itms)
                     {
                         //将实例加入li
                         strResult += itm.ToString();
                     }
                 }
             }
             break;
         //客户名称
         case ParameterField.CustName:
             //数据适配器
             using (var da = new t_pmc_custTableAdapter())
             {
                 //将查询到的结果保存到泛型变量中
                 var l = new List<CustNameLiItem>();
                 //先当作客户代码来查询
                 var tab = da.GetDataLikeCustId(custName);
                 if (tab.Rows.Count == 0)
                 {
                     //当作客户名称来查询
                     tab = da.GetDataLikeCustName(custName);
                 }
                 //获取单据数据
                 AddCustNameListItem(tab, ref l);
                 //如果在客户清单中查询到数据
                 if (l.Count > 0)
                 {
                     //将泛型变量各项目放入数组
                     var itms = new CustNameLiItem[l.Count];
                     //复制泛型变量的内容到数组
                     l.CopyTo(itms);
                     //循环重新设置单只数
                     foreach (var itm in itms)
                     {
                         //将实例加入li
                         strResult += itm.ToString();
                     }
                 }
             }
             break;
         //客户料号
         case ParameterField.CustNum:
             //数据适配器
             using (var da = new t_pmc_orderTableAdapter())
             {
                 //将查询到的结果保存到泛型变量中
                 var l = new List<OrderLiItem>();
                 //获取数据
                 var tab = da.GetDataLikeCustNum(custNum);
                 //写入泛型对象
                 AddOrderListItem(tab, ref l);
                 //如果在客户清单中查询到数据
                 if (l.Count > 0)
                 {
                     //将泛型变量各项目放入数组
                     var itms = new OrderLiItem[l.Count];
                     //复制泛型变量的内容到数组
                     l.CopyTo(itms);
                     //循环重新设置单只数
                     foreach (var itm in itms)
                     {
                         //将实例加入li
                         strResult += itm.ToString();
                     }
                 }
             }
             break;
         //备注
         case ParameterField.Remark:
             //数据适配器
             using (var da = new t_pmc_orderTableAdapter())
             {
                 //将查询到的结果保存到泛型变量中
                 var l = new List<RemarkLiItem>();
                 //获取数据
                 var tab = da.GetDataLikeRemark(remark);
                 //写入泛型对象
                 AddRemarkListItem(tab, ref l);
                 //如果在客户清单中查询到数据
                 if (l.Count > 0)
                 {
                     //将泛型变量各项目放入数组
                     var itms = new RemarkLiItem[l.Count];
                     //复制泛型变量的内容到数组
                     l.CopyTo(itms);
                     //循环重新设置单只数
                     foreach (var itm in itms)
                     {
                         //将实例加入li
                         strResult += itm.ToString();
                     }
                 }
             }
             break;
         //送货单中的客户名称
         case ParameterField.DeliveryCustName:
             //数据适配器
             using (var da = new t_pmc_custTableAdapter())
             {
                 //将查询到的结果保存到泛型变量中
                 var l = new List<DeliveryCustNameLiItem>();
                 //先当作客户代码来查询
                 var tab = da.GetDataLikeCustId(dCustName);
                 if (tab.Rows.Count == 0)
                 {
                     //当作客户名称来查询
                     tab = da.GetDataLikeCustName(dCustName);
                 }
                 //写入泛型对象
                 AddDeliveryCustNameListItem(tab, ref l);
                 //如果在客户清单中查询到数据
                 if (l.Count > 0)
                 {
                     //将泛型变量各项目放入数组
                     var itms = new DeliveryCustNameLiItem[l.Count];
                     //复制泛型变量的内容到数组
                     l.CopyTo(itms);
                     //循环重新设置单只数
                     foreach (var itm in itms)
                     {
                         //将实例加入li
                         strResult += itm.ToString();
                     }
                 }
             }
             break;
         //送货单中的订单序号
         case ParameterField.DeliveryOrderId:
             //数据适配器
             using (var da = new t_pmc_orderTableAdapter())
             {
                 //将查询到的结果保存到泛型变量中
                 var l = new List<DeliveryOrderLiItem>();
                 //获取数据
                 var tab = da.GetDataByOrderId(dOrderId);
                 //写入泛型对象
                 AddDeliveryOrderListItem(tab, ref l);
                 //如果在客户清单中查询到数据
                 if (l.Count > 0)
                 {
                     //将泛型变量各项目放入数组
                     var itms = new DeliveryOrderLiItem[l.Count];
                     //复制泛型变量的内容到数组
                     l.CopyTo(itms);
                     //循环重新设置单只数
                     foreach (var itm in itms)
                     {
                         //将实例加入li
                         strResult += itm.ToString();
                     }
                 }
             }
             break;
         //送货单中的订单编号
         case ParameterField.DeliveryOrderNum:
             //数据适配器
             using (var da = new t_pmc_orderTableAdapter())
             {
                 //将查询到的结果保存到泛型变量中
                 var l = new List<DeliveryOrderLiItem>();
                 //获取数据
                 var tab = da.GetBalanceDataLikeOrderNum(dOrderNum);
                 //写入泛型对象
                 AddDeliveryOrderListItem(tab, ref l);
                 //如果在客户清单中查询到数据
                 if (l.Count > 0)
                 {
                     //将泛型变量各项目放入数组
                     var itms = new DeliveryOrderLiItem[l.Count];
                     //复制泛型变量的内容到数组
                     l.CopyTo(itms);
                     //循环重新设置单只数
                     foreach (var itm in itms)
                     {
                         //将实例加入li
                         strResult += itm.ToString();
                     }
                 }
             }
             break;
         //送货单中的生产编号
         case ParameterField.DeliveryProductNum:
             //数据适配器
             using (var da = new t_pmc_orderTableAdapter())
             {
                 //将查询到的结果保存到泛型变量中
                 var l = new List<DeliveryOrderLiItem>();
                 //获取数据
                 var tab = da.GetBalanceDataLikeProductNum(dProductNum);
                 //写入泛型对象
                 AddDeliveryOrderListItem(tab, ref l);
                 //如果在客户清单中查询到数据
                 if (l.Count > 0)
                 {
                     //将泛型变量各项目放入数组
                     var itms = new DeliveryOrderLiItem[l.Count];
                     //复制泛型变量的内容到数组
                     l.CopyTo(itms);
                     //循环重新设置单只数
                     foreach (var itm in itms)
                     {
                         //将实例加入li
                         strResult += itm.ToString();
                     }
                 }
             }
             break;
         //送货单中的客户料号
         case ParameterField.DeliveryCustNum:
             //数据适配器
             using (var da = new t_pmc_orderTableAdapter())
             {
                 //将查询到的结果保存到泛型变量中
                 var l = new List<DeliveryOrderLiItem>();
                 //获取数据
                 var tab = da.GetBalanceDataLikeCustNum(dCustNum);
                 //写入泛型对象
                 AddDeliveryOrderListItem(tab, ref l);
                 //如果在客户清单中查询到数据
                 if (l.Count > 0)
                 {
                     //将泛型变量各项目放入数组
                     var itms = new DeliveryOrderLiItem[l.Count];
                     //复制泛型变量的内容到数组
                     l.CopyTo(itms);
                     //循环重新设置单只数
                     foreach (var itm in itms)
                     {
                         //将实例加入li
                         strResult += itm.ToString();
                     }
                 }
             }
             break;
     }
     //加入ul头尾
     strResult = "<ul>\n" + strResult + "</ul>\n";
     //写入数据
     context.Response.Write(strResult);
 }