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;
}
//用户传入的lot卡号、订单序号
string lotId = context.Request["lid"];
string orderId = context.Request["oid"];
//检测传入的lot卡号
if (!string.IsNullOrWhiteSpace(lotId))
{
//数据适配器获取订单信息
using (var da = new t_ppc_lot_cardTableAdapter())
using (var tab = da.GetDataByLotId(lotId))
{
//检测是否含有数据
if (tab.Rows.Count > 0)
{
//首行
orderId = tab.Rows[0]["order_id"].ToString();
//待返回的订单信息表内容
string strOrderInfo = CreateLotCardInfoTable(tab);
//写入数据到浏览器
context.Response.Write(strOrderInfo);
}
}
}
//检测订单序号
if (string.IsNullOrWhiteSpace(orderId))
{
return;
}
//数据适配器获取订单信息
using (var da = new t_pmc_orderTableAdapter())
using (var tab = da.GetDataByOrderId(orderId))
{
//待返回的订单信息表内容
string strOrderInfo = CreateOrderInfoTable(tab);
//写入数据到浏览器
context.Response.Write(strOrderInfo);
}
}
protected void cvOrderId_ServerValidate(object source, ServerValidateEventArgs args)
{
//默认不存在该部门
args.IsValid = false;
//检测输入的订单序号是否存在
using (var da = new t_pmc_orderTableAdapter())
using (var tab = da.GetDataByOrderId(args.Value))
{
args.IsValid = tab.Rows.Count > 0;
}
}
protected void fvLotCardMgrSupplementAdd_ItemInserting(object sender, FormViewInsertEventArgs e)
{
//取消原本的添加请求
e.Cancel = true;
//检测是否含有session
if (Session.Count < 5)
{
//跳转
Response.Redirect("/Account/Login", true);
//停止加载后续内容
Response.End();
//直接返回
return;
}
//当前用户所在部门
string procName = Session["proc_name"].ToString();
//当前角色id
Int16 roleId = Convert.ToInt16(Session["role_id"]);
//检测是否有权限
if (procName != mustProcName || roleId < 0 || roleId > 4)
{
throw new Exception("您没有添加记录权限！");
}
//获取用户提供的订单序号的订单开料数量
int orderPnlQty;
using (var da = new t_pmc_orderTableAdapter())
using (var tab = da.GetDataByOrderId(e.Values["order_id"].ToString()))
{
//第一行数据
var row = (DataSetPmcOrderMgr.t_pmc_orderRow)tab.Rows[0];
//检测pnl含pcs数
if (row.pnl_count_pcs <= 0)
{
throw new Exception(string.Format("您提供的订单序号 {0} 没有输入正确的pnl含pcs数,禁止开卡！", e.Values["order_id"]));
}
//获取开料数量
orderPnlQty = row.total_pnl_qty;
}
//pnl数量文本框
var tb = (TextBox)fvLotCardMgrSupplementAdd.FindControl("txtPnlQty");
//每lot数量
int lotPnlQty = int.Parse(tb.Text);
//每lot数量不能大于订单数量
if (lotPnlQty > orderPnlQty)
{
//重新设置每lot数量
lotPnlQty = orderPnlQty;
tb.Text = lotPnlQty.ToString();
}
//设置录入员姓名和时间
e.Values["add_person"] = Session["user_name"].ToString();
e.Values["add_time"] = DateTime.Now;
e.Values["last_change_time"] = DateTime.Now;
//根据输入的批量卡id执行添加数据
if (ydOperateLotCard.InsertLotCardRecord(e, orderPnlQty, lotPnlQty))
{
//调用过程执行跳转
fvLotCardMgrSupplementAdd_ItemInserted(null, null);
}
}
protected void fvOrderMgrAdd_ItemCreated(object sender, EventArgs e)
{
//新增状态
if (fvOrderMgrAdd.CurrentMode == FormViewMode.Insert)
{
//当前订单id号
var tb = (TextBox)fvOrderMgrAdd.FindControl("txtOrderId");
if (tb != null)
{
//获取最大id号
using (var da = new t_pmc_orderTableAdapter())
{
//获取
object obj = da.GetLastOrderId(); ;
string strMaxId;
if (obj == null || string.IsNullOrWhiteSpace(obj.ToString()))
{
strMaxId = "A0";
}
else
{
strMaxId = obj.ToString();
}
//设置为最大id号+1
tb.Text = strMaxId.Substring(0, 1) + (int.Parse(strMaxId.Substring(1)) + 1).ToString();
}
}
//当前订单下单日期文本框
tb = (TextBox)fvOrderMgrAdd.FindControl("txtOrderDate");
if (tb != null)
{
//检查用户提供的日期参数标识
string strOrderDate = Request["pdate"];
DateTime dtOrderDate;
if (strOrderDate != null && strOrderDate.Length > 0 &&
DateTime.TryParse(strOrderDate, out dtOrderDate))
{
//设置默认日期
tb.Text = dtOrderDate.ToString("yyyy-MM-dd");
}
else
{
//设置日期为当前日期
tb.Text = DateTime.Now.ToString("yyyy-MM-dd");
}
}
//当前订单状态文本框
tb = (TextBox)fvOrderMgrAdd.FindControl("txtState");
if (tb != null)
{
//默认为新单
tb.Text = "新单";
}
//设置良率默认为98
tb = (TextBox)fvOrderMgrAdd.FindControl("txtOkPercent");
if (tb != null)
{
tb.Text = "99";
}
//当前仓存数文本框
tb = (TextBox)fvOrderMgrAdd.FindControl("txtStockPcsQty");
if (tb != null)
{
//设置默认值为空
tb.Text = string.Empty;
}
//当前已交货pcs数文本框
tb = (TextBox)fvOrderMgrAdd.FindControl("txtOutPcsQty");
if (tb != null)
{
//设置默认值为0
tb.Text = "0";
}
//生产日期文本框
tb = (TextBox)fvOrderMgrAdd.FindControl("txtProductDate");
if (tb != null)
{
tb.Text = DateTime.Now.ToString("yyyy-MM-dd");
}
//需求日期文本框
tb = (TextBox)fvOrderMgrAdd.FindControl("txtNeedDate");
if (tb != null)
{
tb.Text = DateTime.Now.ToString("yyyy-MM-dd");
}
}
//当前生产编号文本框获取焦点
var txtProductNum = (TextBox)fvOrderMgrAdd.FindControl("txtProductNum");
if (txtProductNum != null)
{
//设置焦点
txtProductNum.Focus();
}
}
protected void fvOrderMgrAdd_ItemInserting(object sender, FormViewInsertEventArgs e)
{
//默认取消请求
e.Cancel = true;
//检测是否含有session
if (Session.Count < 5)
{
//跳转
Response.Redirect("/Account/Login", true);
//停止加载后续内容
Response.End();
//直接返回
return;
}
//当前用户所在部门
string deptName = Session["dept_name"].ToString();
//当前角色id
Int16 roleId = Convert.ToInt16(Session["role_id"]);
//检测是否有权限
if (deptName != mustDeptName || (roleId != 0 && roleId != 1 && roleId != 6))
{
throw new Exception("您没有添加记录权限！");
}
//当前订单id文本框
var tb = (TextBox)fvOrderMgrAdd.FindControl("txtOrderId");
if (tb != null)
{
//检测id号是否存在
using (var da = new t_pmc_orderTableAdapter())
using (var tab = da.GetDataByOrderId(tb.Text))
{
//订单序号存在提示错误
if (tab.Rows.Count > 0)
{
throw new Exception("订单序号已经存在！");
}
}
}
//pcs面积
decimal pcsArea;
var obj = e.Values["pcs_area"];
if (obj == null || !decimal.TryParse(obj.ToString(), out pcsArea))
{
e.Values["pcs_area"] = 0m;
}
//设置录入员姓名和时间
e.Values["add_person"] = Session["user_name"].ToString();
e.Values["add_time"] = DateTime.Now;
e.Values["last_change_time"] = DateTime.Now;
//做单条添加
e.Cancel = false;
}
//导出数据到Excel
protected void lBtnToExcel_Click(object sender, EventArgs e)
{
//获取数据并填充到数据表
using (var da = new t_pmc_orderTableAdapter())
{
//检测session中保存的查询条件
object obj = Session["order_mgr_unfinished_where_content"];
string str = string.Empty;
if (obj != null && obj.ToString().Length > 0)
{
str = obj.ToString();
}
//获取前1万行数据
var tab = da.GetPagedData(0, 10000, str, "order by [id] desc", true, false);
//设置列标题
string[] titleCol =
("序号,订单序号,首卡卡号,尾卡卡号,状况,良率,生产编号,pnl长,pnl宽,pnl面积,客户名称,客户料号," +
"订单编号,订单pcs数,订单pcs面积,事业部,销售单号,特殊流程,SMT备注,FPC单价,SMT单价,FPC+SMT总价,工具费," +
"批次号,规格,备品数量,覆盖膜,投料率,开料pnl数,开料pnl面积,pnl含pcs数," +
"开料pcs数,仓存pcs数,落单日期,需求日期,生产日期,已交货pcs数,已交货pcs面积," +
"欠交货pcs数,欠交货面积,备注,录入员,录入时间,修改时间").Split(',');
//设置表名称
string titleTab = "未完成订单清单";
//临时文件名称
string fileName = titleTab + DateTime.Now.ToString("yyMMddHHmmss") + ".xls";
//执行导出数据到excel
bool isSuccess = ydPublicMethod.DataTable2Excel(tab, titleCol, ref fileName, titleTab);
//如果成功则跳转到指定页面
if (isSuccess)
{
Response.Redirect(fileName);
//停止加载后续内容
Response.End();
}
}
}
//导出数据到Excel
protected void lBtnToExcel_Click(object sender, EventArgs e)
{
//获取数据并填充到数据表
using (var da = new t_pmc_orderTableAdapter())
{
//检测session中保存的查询条件
object obj = Session["order_mgr_where_content"];
string str = string.Empty;
if (obj != null && obj.ToString().Length > 0)
{
str = obj.ToString();
}
//获取前1万行数据
var tab = da.GetPagedData(0, 10000, str, "order by [id] desc", false, false);
//设置列标题
string[] titleCol =
("序号,订单序号,首卡卡号,尾卡卡号,状态,良率,生产编号,pcs面积," +
"客户名称,客户代码,订单编号,订单pcs总数,订单pcs总面积,仓存pcs数," +
"下单日期,需求日期,生产日期,已出pcs数量,已出pcs面积,未出pcs数量,未出pcs面积," +
"备注,录入员,录入时间,修改时间").Split(',');
//设置表名称
string titleTab = "量产订单清单";
//临时文件名称
string fileName = titleTab + DateTime.Now.ToString("yyMMddHHmmss") + ".xls";
//执行导出数据到excel
bool isSuccess = ydPublicMethod.DataTable2Excel(tab, titleCol, ref fileName, titleTab);
//如果成功则跳转到指定页面
if (isSuccess)
{
Response.Redirect(fileName);
//停止加载后续内容
Response.End();
}
}
}
protected void cvOrderId_ServerValidate(object source, ServerValidateEventArgs args)
{
//默认检测不能通过
args.IsValid = false;
//当前对象
var cv = ((CustomValidator)source);
//取得索引号
var i = cv.ID.Substring(cv.ID.Length - 1, 1);
//找到当前行的交货数量和备品数量
var txtPcsQty = (TextBox)tabDataListSon.FindControl("txtPcsQty" + i);
var txtFocPcsQty = (TextBox)tabDataListSon.FindControl("txtFocPcsQty" + i);
//取得数量
int iPcsQty;
if (!int.TryParse(txtPcsQty.Text, out iPcsQty))
{
iPcsQty = 0;
}
int iFocPcsQty;
if (!int.TryParse(txtFocPcsQty.Text, out iFocPcsQty))
{
iFocPcsQty = 0;
}
//取得的输入的生产编号订单序号
string userOrderId = args.Value.ToUpper();
//如果出数为0则直接通过
if (iPcsQty + iFocPcsQty <= 0)
{
args.IsValid = true;
return;
}
else if (userOrderId.Trim().Length <= 0)
{
cv.ToolTip = "有交货数量则订单序号必填";
return;
}
//检测输入是否正确
if (!Regex.IsMatch(userOrderId, @"^[A-Z][1-9]\d{0,4}$"))
{
cv.ToolTip = "必须单个字母加上最多5位整数";
return;
}
//通过订单序号获取订单中生产编号
using (var da = new t_pmc_orderTableAdapter())
{
//当前订单序号的数据
var tab = da.GetDataByOrderId(userOrderId);
if (tab.Rows.Count <= 0)
{
cv.ToolTip = "订单不存在";
return;
}
}
//允许通过
args.IsValid = true;
}
protected void cvProductNum_ServerValidate(object source, ServerValidateEventArgs args)
{
//默认检测不能通过
args.IsValid = false;
//当前对象
var cv = ((CustomValidator)source);
//取得索引号
var i = cv.ID.Substring(cv.ID.Length - 1, 1);
//找到当前行的交货数量和备品数量
var txtPcsQty = (TextBox)tabDataListSon.FindControl("txtPcsQty" + i);
var txtFocPcsQty = (TextBox)tabDataListSon.FindControl("txtFocPcsQty" + i);
//取得数量
int iPcsQty;
if (!int.TryParse(txtPcsQty.Text, out iPcsQty))
{
iPcsQty = 0;
}
int iFocPcsQty;
if (!int.TryParse(txtFocPcsQty.Text, out iFocPcsQty))
{
iFocPcsQty = 0;
}
//取得的输入的生产编号
string userProductNum = args.Value.ToUpper();
//如果出数为0则直接通过
if (iPcsQty + iFocPcsQty <= 0)
{
args.IsValid = true;
return;
}
else if (userProductNum.Trim().Length <= 0)
{
cv.ToolTip = "有交货数量生产编号必填";
return;
}
//订单序号文本框
var txtOrderId = (TextBox)tabDataListSon.FindControl("txtOrderId" + i);
//是否找到订单序号文本框
if (txtOrderId == null)
{
cv.ToolTip = "未找到订单序号文本框";
return;
}
//通过订单序号获取订单中生产编号
using (var da = new t_pmc_orderTableAdapter())
{
//当前订单序号的数据
var tab = da.GetDataByOrderId(txtOrderId.Text);
if (tab.Rows.Count <= 0)
{
cv.ToolTip = "未找到指定的订单";
return;
}
//首行数据
var row = (DataSetPmcOrderMgr.t_pmc_orderRow)tab.Rows[0];
//检测有无找到生产编号
if (row.Isproduct_numNull() || row.product_num.Length <= 0)
{
cv.ToolTip = "当前订单无生产编号";
return;
}
//取得的订单生产编号
string orderProductNum = row.product_num.ToUpper();
//修改错误文本内容
cv.ToolTip = string.Format("与订单生产编号\"{0}\"只能版本不同", orderProductNum);
//小于两个字符不检测
if (orderProductNum.Length < 2)
{
args.IsValid = true;
}
else if (userProductNum.Length >= 2)
{
//检测是否能通过
args.IsValid = orderProductNum.Remove(orderProductNum.Length - 2) == userProductNum.Remove(userProductNum.Length - 2);
}
}
}
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);
}
protected void fvOrderMgrUnfinishedAdd_ItemInserting(object sender, FormViewInsertEventArgs e)
{
//默认取消请求
e.Cancel = true;
//检测是否含有session
if (Session.Count < 5)
{
//跳转
Response.Redirect("/Account/Login", true);
//停止加载后续内容
Response.End();
//直接返回
return;
}
//当前用户所在部门
string procName = Session["proc_name"].ToString();
//当前角色id
Int16 roleId = Convert.ToInt16(Session["role_id"]);
//检测是否有权限
if (procName != mustProcName || roleId < 0 || roleId > 4)
{
throw new Exception("您没有添加记录权限！");
}
//当前订单id文本框
var tb = (TextBox)fvOrderMgrUnfinishedAdd.FindControl("txtOrderId");
if (tb != null)
{
//检测id号是否存在
using (var da = new t_pmc_orderTableAdapter())
using (var tab = da.GetDataByOrderId(tb.Text))
{
//id号存在提示错误
if (tab.Rows.Count > 0)
{
throw new Exception("订单序号已经存在！");
}
}
}
//生产编号
object obj = e.Values["product_num"];
if (obj == null)
{
e.Values["product_num"] = string.Empty;
}
//pnl面积
decimal pnlArea = 0m;
obj = e.Values["pnl_length"];
object obj2 = e.Values["pnl_width"];
decimal dPnlLength;
decimal dPnlWidth;
if (obj != null && obj2 != null
&& decimal.TryParse(obj.ToString(), out dPnlLength)
&& decimal.TryParse(obj2.ToString(), out dPnlWidth)
)
{
pnlArea = Math.Round(dPnlLength * dPnlWidth / 1000000, 5);
}
//订单pcs数
int orderPcsQty = Convert.ToInt32(e.Values["order_pcs_qty"]);
//订单开料pnl数
int totalPnlQty = 0;
obj = e.Values["total_pnl_qty"];
int iTotalPnlQty;
if (obj != null && int.TryParse(obj.ToString(), out iTotalPnlQty))
{
totalPnlQty = iTotalPnlQty;
}
//pnl含pcs数
int pnlCountPcs = 0;
obj = e.Values["pnl_count_pcs"];
int iPnlCountPcs;
if (obj != null && int.TryParse(obj.ToString(), out iPnlCountPcs) && iPnlCountPcs > 0)
{
pnlCountPcs = iPnlCountPcs;
}
//pcs面积
decimal pcsArea = pnlCountPcs == 0 ? 0m : Math.Round(pnlArea / pnlCountPcs, 5);
//已交货数
int outPcsQty = Convert.ToInt32(e.Values["out_pcs_qty"]);
//仓存数
int stockPcsQty = 0;
obj = e.Values["total_pnl_qty"];
int iStockPcsQty;
if (obj != null && int.TryParse(obj.ToString(), out iStockPcsQty) && iStockPcsQty > 0)
{
stockPcsQty = iStockPcsQty;
}
//FPC单价
decimal unitPriceFpc = 0m;
obj = e.Values["unit_price_fpc"];
decimal dUnitPriceFpc;
if (obj != null && decimal.TryParse(obj.ToString(), out dUnitPriceFpc) && dUnitPriceFpc > 0)
{
unitPriceFpc = dUnitPriceFpc;
}
//SMT单价
decimal unitPriceSmt = 0m;
obj = e.Values["unit_price_smt"];
decimal dUnitPriceSmt;
if (obj != null && decimal.TryParse(obj.ToString(), out dUnitPriceSmt) && dUnitPriceSmt > 0)
{
unitPriceSmt = dUnitPriceSmt;
}
//总开料pcs数
int totalPcsQty = totalPnlQty * pnlCountPcs;
//设置各需要计算的列的值
e.Values["pnl_area"] = pnlArea;
e.Values["pnl_count_pcs"] = pnlCountPcs;
e.Values["order_pcs_area"] = pcsArea * orderPcsQty;
e.Values["total_pnl_area"] = pnlArea * totalPnlQty;
e.Values["total_pcs_qty"] = totalPnlQty * pnlCountPcs;
e.Values["out_pcs_area"] = pcsArea * outPcsQty;
e.Values["balance_pcs_qty"] = orderPcsQty - outPcsQty;
e.Values["balance_pcs_area"] = pcsArea * (orderPcsQty - outPcsQty);
e.Values["fpc_smt_total_amount"] = (unitPriceFpc + unitPriceSmt) * orderPcsQty;
e.Values["cover_membrane"] = Math.Ceiling(1.02 * totalPnlQty);
e.Values["feeding_rate"] = totalPcsQty == 0 ? 0m : Math.Round(1.0m * (orderPcsQty - stockPcsQty) / totalPcsQty, 5);
//设置录入员姓名和时间
e.Values["add_person"] = Session["user_name"].ToString();
e.Values["add_time"] = DateTime.Now;
e.Values["last_change_time"] = DateTime.Now;
//做单条添加
e.Cancel = false;
}
/// <summary>
/// 根据输入的LOT格式来保存多条数据到数据库
/// </summary>
/// <param name="e">传入的带有数据的事件参数</param>
/// <param name="orderPnlQty">订单开料数量</param>
/// <param name="lotPnlQty">lot卡每lot数量</param>
/// <returns></returns>
internal static bool InsertLotCardRecord(FormViewInsertEventArgs e, int orderPnlQty, int lotPnlQty)
{
//当前用户输入的lot卡号
string strInput = e.Values["lot_id"].ToString().Trim().Replace("－", "-").Replace("—", "-");
//检测是否只输入了一个lot卡号
string[] strLotIds = strInput.Split(new string[] { "--" }, StringSplitOptions.None);
//检测是否正确lot卡号并转换
if (!ydOperateLotCard.IsLotCardId(ref strLotIds[0]))
{
//返回失败
throw new Exception("您输入了一个不合格的lot卡号 " + strLotIds[0] + " ！");
}
//生产编号
string productNum = string.Empty;
//获取订单中的生产编号
using (var da = new t_pmc_orderTableAdapter())
using (var tab = da.GetDataByOrderId(e.Values["order_id"].ToString()))
{
//检测有数据
if (tab.Rows.Count > 0)
{
//首行
var row = (DataSetPmcOrderMgr.t_pmc_orderRow)tab.Rows[0];
//获取生产编号
productNum = row.product_num;
}
}
//检测是否获取到生产编号
if (string.IsNullOrWhiteSpace(productNum))
{
throw new Exception("未从订单中获取到生产编号！");
}
//保存数据到部门lot卡记录中的sql添加语句
string sqlstr =
"INSERT INTO [t_dept_lot_card_balance](" +
"[prev_dept_name],[dept_name],[lot_id],[product_num],[pnl_qty],[pcs_qty]," +
"[remark],[add_person],[add_time],[last_change_time]" +
") VALUES (" +
"@prevDeptName,@deptName,@lotId,@productNum,@pnlQty,@pcsQty," +
"@remark,@addPerson,@addTime,@lastChangeTime" +
")";
//数据适配器
//当前数据库连接
//当前更新语句对象
using (var da = new t_ppc_lot_cardTableAdapter())
using (var conn = da.Connection)
using (var cmd = da.Adapter.InsertCommand)
using (var cmdDept = new SqlCommand(sqlstr, conn))
{
//打开数据库连接
conn.Open();
//开启事务
using (var tran = conn.BeginTransaction())
{
//设置事务
da.Transaction = tran;
cmdDept.Transaction = tran;
//试运行
try
{
//按照单条添加
if (strLotIds.Length == 1)
{
//当前输入的lot卡号
string lotId = e.Values["lot_id"].ToString().Trim();
//保存一条记录到数据库
if (!InsertOneRecord(cmd, cmdDept, productNum, lotId, lotPnlQty, e))
{
//失败就直接返回
return false;
}
}
else
{
//写入lot卡后剩余待写入数量
int balancePnlQty = orderPnlQty;
//检测结束lot卡号
if (strLotIds[1].Length == 0)
{
//使用最大编号作为结束lot卡号
strLotIds[1] = int.MaxValue.ToString();
}
else
{
//正则检测
string strReg = @"^[1-9]\d{0,4}$";
//检测是否正确lot卡号
if (!Regex.IsMatch(strLotIds[1], strReg))
{
//非数字返回失败
throw new Exception("您输入了一个不合格的lot卡号 " + strLotIds[1] + " ！");
}
}
//lot卡中的年份月份和数字索引号
string strYear = strLotIds[0].Substring(0, 5);
int iLotIdStart = int.Parse(strLotIds[0].Substring(5));
int iLotIdEnd = int.Parse(strLotIds[1]);
//检测起始和结束lot卡号,让起始lot卡号最小
if (iLotIdStart > iLotIdEnd)
{
int i = iLotIdStart;
iLotIdStart = iLotIdEnd;
iLotIdEnd = i;
}
//循环设置lot卡号执行保存
for (int i = iLotIdStart; i <= iLotIdEnd; i++)
{
//只剩下lot卡1.5倍数量就一次性开一张卡
if (balancePnlQty <= lotPnlQty * 1.5)
{
lotPnlQty = balancePnlQty;
}
////检测当前应该写入的pnl数量
//if (balancePnlQty < lotPnlQty)
//{
// lotPnlQty = balancePnlQty;
//}
//当前要添加的lot卡号
string lotId = strYear + i.ToString();
//保存一条记录到数据库
if (!InsertOneRecord(cmd, cmdDept, productNum, lotId, lotPnlQty, e))
{
//失败就直接返回
return false;
}
else
{
//当前剩余数量
balancePnlQty -= lotPnlQty;
//检测剩余数量小于或等于0则退出循环
if (balancePnlQty <= 0)
{
break;
}
}
}
}
//提交事务
tran.Commit();
//返回成功
return true;
}
catch (Exception ex)
{
//回滚事务
tran.Rollback();
//非数字返回失败
throw new Exception(ex.Message);
}
}
}
}
/// <summary>
/// 保存多条lot卡开卡记录数据到数据库
/// </summary>
/// <param name="e">传入的带有数据的事件参数</param>
/// <returns></returns>
private bool InsertData(FormViewInsertEventArgs e)
{
//当前用户输入的lot卡号
string strLotIdBegin = e.Values["lot_id"].ToString();
//正则表达式
string strReg = @"^[1-9]\d(0[1-9]|1[012])-[1-9]\d{0,4}";
//检测是否正确lot卡号
if (!Regex.IsMatch(strLotIdBegin, strReg))
{
//非数字返回失败
throw new Exception("您输入了一个不合格的结束lot卡号 " + strLotIdBegin + " ！");
}
//数据适配器
//当前添加语句对象
//当前数据库连接
using (var da = new t_ppc_lot_cardTableAdapter())
using (var daOrder = new t_pmc_orderTableAdapter())
using (var daBalance = new t_dept_lot_card_balanceTableAdapter())
using (var conn = da.Connection)
{
//打开数据库连接
conn.Open();
//设置数据库连接
daOrder.Connection = daBalance.Connection = conn;
//开启事务
using (var tran = conn.BeginTransaction())
{
//设置事务
daOrder.Transaction = da.Transaction = daBalance.Transaction = tran;
//试运行
try
{
//订单序号
string orderId = ((TextBox)fvLotCardMgrAdd.FindControl("txtOrderId")).Text;
//取得生产编号
string productNum = daOrder.GetProductNumByOrderId(orderId).ToString();
//lot卡中的年份月份和数字索引号
string strYearMonth = strLotIdBegin.Substring(0, 5);
int iLotId = int.Parse(strLotIdBegin.Substring(5));
//每卡开多少pnl
Int16 iEveryCardPnlQty = Int16.Parse(((TextBox)fvLotCardMgrAdd.FindControl("txtEveryCardPnlQty")).Text);
//是否补料单
bool isSupplement = Convert.ToBoolean(e.Values["is_supplement"]);
//首部门
string firstDeptName = ((TextBox)fvLotCardMgrAdd.FindControl("txtFirstDeptName")).Text;
//备注
string remark = e.Values["remark"].ToString();
//录入员
string addPerson = e.Values["add_person"].ToString();
//录入时间
DateTime addTime = Convert.ToDateTime(e.Values["add_time"]);
//录入时间
DateTime lastChangeTime = Convert.ToDateTime(e.Values["last_change_time"]);
//遍历pnl数
foreach (var item in new string[] { "A", "B", "C", "D" })
{
//pnl开料数
string pnlQty = ((TextBox)fvLotCardMgrAdd.FindControl("txtPnlQty" + item)).Text;
if (pnlQty.Length <= 0)
{
continue;
}
int iPnlQty = int.Parse(pnlQty);
//pnl长
Int16 iPnlLength = Int16.Parse(((TextBox)fvLotCardMgrAdd.FindControl("txtPnlLength" + item)).Text);
//pnl宽
Int16 iPnlWidth = Int16.Parse(((TextBox)fvLotCardMgrAdd.FindControl("txtPnlWidth" + item)).Text);
//pnl含pcs数
Int16 iPnlCountPcs = Int16.Parse(((TextBox)fvLotCardMgrAdd.FindControl("txtPnlCountPcs" + item)).Text);
//开卡数
int iCountCard = iPnlQty / iEveryCardPnlQty;
//尾卡数量太多,卡数+1
if (iPnlQty - iCountCard * iEveryCardPnlQty >= iEveryCardPnlQty * 0.5)
{
iCountCard++;
}
//开卡数至少一张
if (iCountCard <= 0)
{
iCountCard = 1;
}
//lot卡逐个往数据库填写
for (int i = iLotId; i < iLotId + iCountCard; i++)
{
//当前lot卡号
string lotId = strYearMonth + i;
//当前卡开pnl数
Int16 iPnlQtyThis = i == iLotId + iCountCard - 1 ?
(Int16)(iPnlQty - (iCountCard - 1) * iEveryCardPnlQty) :
iEveryCardPnlQty;
//写入当前lot卡
if (da.Insert(
orderId,
lotId,
isSupplement,
iPnlLength,
iPnlWidth,
iPnlCountPcs,
iPnlQtyThis,
firstDeptName,
remark,
addPerson,
addTime,
lastChangeTime
) <= 0)
{
//返回失败
throw new Exception(string.Format("插入lot卡 {0} 到数据库失败！", lotId));
}
//写入部门结存
if (daBalance.Insert(
"计划",
firstDeptName,
lotId,
productNum,
iPnlQtyThis,
0,
null,
true,
addPerson,
addTime,
lastChangeTime
) <= 0)
{
//返回失败
throw new Exception(string.Format("插入lot卡 {0} 到部门结存失败！", lotId));
}
}
//当前iLotId
iLotId = iLotId + iCountCard;
}
//提交事务
tran.Commit();
//返回成功
return true;
}
catch (Exception ex)
{
//回滚事务
tran.Rollback();
//非数字返回失败
throw new Exception(ex.Message);
}
}
}
}
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);
}
