public override object GetParam(DFDictionary entity)
{
return(new { InstanceId = entity["InstanceId"] });
}
public override void CheckInput(FormM form, DFDictionary entity)
{
base.CheckInput(form, entity);
var AQ1 = ParseHelper.ParseDecimal(entity["AQ1"]);
if (!AQ1.HasValue)
{
throw new WFException("AQ1必须是数字");
}
var AQ2 = ParseHelper.ParseDecimal(entity["AQ2"]);
if (!AQ2.HasValue)
{
throw new WFException("AQ2必须是数字");
}
var AQ3 = ParseHelper.ParseDecimal(entity["AQ3"]);
if (!AQ3.HasValue)
{
throw new WFException("AQ3必须是数字");
}
var AQ4 = ParseHelper.ParseDecimal(entity["AQ4"]);
if (!AQ4.HasValue)
{
throw new WFException("AQ4必须是数字");
}
var AQ5 = ParseHelper.ParseDecimal(entity["AQ5"]);
if (!AQ5.HasValue)
{
throw new WFException("AQ5必须是数字");
}
var AQ6 = ParseHelper.ParseDecimal(entity["AQ6"]);
if (!AQ6.HasValue)
{
throw new WFException("AQ6必须是数字");
}
var AQ7 = ParseHelper.ParseDecimal(entity["AQ7"]);
if (!AQ7.HasValue)
{
throw new WFException("AQ7必须是数字");
}
var AQ8 = ParseHelper.ParseDecimal(entity["AQ8"]);
if (!AQ8.HasValue)
{
throw new WFException("AQ8必须是数字");
}
var AKK = ParseHelper.ParseDecimal(entity["AKK"]);
if (!AKK.HasValue)
{
throw new WFException("空开距离A必须是数字");
}
var BKK = ParseHelper.ParseDecimal(entity["BKK"]);
if (!BKK.HasValue)
{
throw new WFException("空开距离B必须是数字");
}
//var BWT2 = ParseHelper.ParseDecimal(entity["BWT2"]);
//if (!BWT2.HasValue)
//{
// throw new WFException("WT2B必须是数字");
//}
//var AWT2 = ParseHelper.ParseDecimal(entity["AWT2"]);
//if (!AWT2.HasValue)
//{
// throw new WFException("WT2A必须是数字");
//}
}
public override void CheckInput(FormM form, DFDictionary entity)
{
base.CheckInput(form, entity);
if (string.IsNullOrWhiteSpace(entity["ZDB"]))
{
throw new WFException("请输入振动泵信息");
}
//碱洗电流最大值控制数字
//var jxdlmax = ParseHelper.ParseDecimal(entity["JXDLMax"]);
//if (!jxdlmax.HasValue)
//{
// throw new WFException("碱洗电流最大值必须是数字");
//}
////碱洗电流最小值控制数字
//var jxdlmin = ParseHelper.ParseDecimal(entity["JXDLMin"]);
//if (!jxdlmin.HasValue)
//{
// throw new WFException("碱洗电流最小值必须是数字");
//}
//总炉压标准值控制数字
var TotalLYStandard = ParseHelper.ParseDecimal(entity["TotalLYStandard"]);
if (!TotalLYStandard.HasValue)
{
throw new WFException("总炉压标准值必须是数字");
}
////总炉压最大值控制数字
//var TotalLYMax = ParseHelper.ParseDecimal(entity["TotalLYMax"]);
//if (!TotalLYMax.HasValue)
//{
// throw new WFException("总炉压最大值必须是数字");
//}
////总炉压最小值控制数字
//var TotalLYMin = ParseHelper.ParseDecimal(entity["TotalLYMin"]);
//if (!TotalLYMin.HasValue)
//{
// throw new WFException("总炉压最小值必须是数字");
//}
//排线速度标准控制数字
var PXSpeedStandard = ParseHelper.ParseDecimal(entity["PXSpeedStandard"]);
if (!PXSpeedStandard.HasValue)
{
throw new WFException("排线速度标准值必须是数字");
}
////排线速度最大控制数字
//var PXSpeedMax = ParseHelper.ParseDecimal(entity["PXSpeedMax"]);
//if (!PXSpeedMax.HasValue)
//{
// throw new WFException("排线速度最大值必须是数字");
//}
////排线速度最小控制数字
//var PXSpeedMin = ParseHelper.ParseDecimal(entity["PXSpeedMin"]);
//if (!PXSpeedMin.HasValue)
//{
// throw new WFException("排线速度最小值必须是数字");
//}
//收线张力标准控制数字
var SXZLStandard = ParseHelper.ParseDecimal(entity["SXZLStandard"]);
if (!SXZLStandard.HasValue)
{
throw new WFException("收线张力标准值必须是数字");
}
//收线张力最大控制数字
//var SXZLMax = ParseHelper.ParseDecimal(entity["SXZLMax"]);
//if (!SXZLMax.HasValue)
//{
// throw new WFException("收线张力最大值必须是数字");
//}
//收线张力最小控制数字
//var SXZLMin = ParseHelper.ParseDecimal(entity["SXZLMin"]);
//if (!SXZLMin.HasValue)
//{
// throw new WFException("收线张力最小值必须是数字");
//}
using (var db = Pub.DB)
{
//检查收线的生产信息
var s1 = "select count(1) from sm_t_process_product where InstanceId=@InstanceId";
var c1 = db.Query <int>(s1, new { InstanceId = entity["InstanceId"] }).FirstOrDefault();
if (c1 == 0 || c1 != 8)
{
throw new WFException("收线的生产信息AQ1-AQ8必须填写");
}
//检查收线的槽液工艺
var s2 = "select count(1) from sm_t_process_cy where InstanceId=@InstanceId";
var c2 = db.Query <int>(s2, new { InstanceId = entity["InstanceId"] }).FirstOrDefault();
if (c2 == 0)
{
throw new WFException("收线的槽液工艺设定必须填写");
}
//检查收线的浴槽信息
var s3 = "select count(1) from sm_t_process_yc where InstanceId=@InstanceId";
var c3 = db.Query <int>(s3, new { InstanceId = entity["InstanceId"] }).FirstOrDefault();
if (c3 == 0)
{
throw new WFException("收线的浴槽信息必须填写");
}
//检查收线的产品质量标准
var s4 = "select count(1) from sm_t_process_quality where InstanceId=@InstanceId";
var c4 = db.Query <int>(s4, new { InstanceId = entity["InstanceId"] }).FirstOrDefault();
if (c4 == 0)
{
throw new WFException("收线的产品质量标准信息必须填写");
}
//检查放线的炉压信息
var s5 = "select count(1) from sm_t_process_ly where InstanceId=@InstanceId";
var c5 = db.Query <int>(s5, new { InstanceId = entity["InstanceId"] }).FirstOrDefault();
if (c5 == 0)
{
throw new WFException("放线的炉压信息必须填写");
}
//检查放线的AQ信息
var s6 = "select count(1) from sm_t_process_aq where InstanceId=@InstanceId";
var c6 = db.Query <int>(s6, new { InstanceId = entity["InstanceId"] }).FirstOrDefault();
if (c6 == 0)
{
throw new WFException("放线的AQ准信息必须填写");
}
}
}
public override DFDictionary Get(FormM form, DFDictionary entity, ref string message)
{
ArgumentCheck.CheckMustInput(entity, "ModelId");
var engine = NinjectHelper.Get <IEngine>();
if (engine == null)
{
throw new Exception("找不到 IEngine".GetRes());
}
var user = Util.GetCurrentUser();
var instanceId = string.Empty;
// 信达生物 SAP 只能传递 10 位流水号
var model = WFDA.Instance.GetModelById(entity["ModelId"]);
if (model.DFFormName == "Form_XDSW_T_PR")
{
instanceId = Pub.GetNextIdFromDB("P", DateTime.Now.ToString("yyMMdd"), string.Empty, 3);
}
else if (model.DFFormName == "Form_AD_T_PO")
{
instanceId = Pub.GetNextIdFromDB("P", DateTime.Now.ToString("yyyyMMdd"), string.Empty, 4);
}
else if (model.DFFormName == "Form_AD_T_BANK_PAYMENT")
{
instanceId = Pub.GetNextIdFromDB("F", DateTime.Now.ToString("yyyyMMdd"), string.Empty, 4);
}
else if (model.DFFormName == "Form_AD_T_FA")
{
instanceId = Pub.GetNextIdFromDB("G", DateTime.Now.ToString("yyyyMMdd"), string.Empty, 4);
}
else
{
instanceId = Pub.GetNextIdFromDB("A", DateTime.Now.ToString("yyyyMMdd"), string.Empty, 4);
}
var Requestor = user.UserId;
var RequestorName = user.UserName;
var RequestorProxy = string.Empty;
var RequestorProxyName = string.Empty;
// 如果是代理申请，客户端会传上来申请人编号
if (!string.IsNullOrWhiteSpace(entity["Requestor"]))
{
Requestor = entity["Requestor"];
var requestor = WF_M_USERLoader.Get(Requestor);
if (requestor == null)
{
throw new Exception(string.Format("根据用户编号 {0} 找不到用户", Requestor));
}
RequestorName = requestor.UserName;
RequestorProxy = user.UserId;
RequestorProxyName = user.UserName;
}
// 开始工作流
engine.StartDBWF(entity["ModelId"], instanceId, Requestor, RequestorProxy, RequestorName,
RequestorProxyName, DateTime.Now, true, user.UserId, user.UserName);
if (!string.IsNullOrWhiteSpace(entity["SourceInstanceId"]))
{
// 复制单据
CloneInstance(entity, instanceId);
}
var dict = new DFDictionary();
if (!string.IsNullOrWhiteSpace(entity["ModelId"]))
{
using (var db = Pub.DB)
{
var sql = "select * from WF_T_INSTANCE where 1=1";
sql += " and InstanceId=@InstanceId";
var parameters = new
{
InstanceId = instanceId
};
var item = db.Query <WF_T_INSTANCE>(sql, parameters).FirstOrDefault();
if (item != null)
{
dict = DFDictionary.Create <WF_T_INSTANCE>(item);
}
}
}
return(dict);
}
public override void SetAccess(FormM form, DFDictionary entity)
{
base.SetAccess(form, entity);
}
public override object GetParam(DFDictionary entity)
{
return(new { LogId = entity["LogId"] });
}
//[Obsolete("该方法已经过期，请使用 DynamicForm.Core.BaseDA.SaveClientData 方法代替")]
private object SaveParameter(HttpContext context, DFDictionary dict)
{
context.Session[DFPub.DF_DATA_EXCHANGE] = dict[DFPub.DF_DATA_EXCHANGE];
return(null);
}
public override void SetAccess(FormM form, DFDictionary entity)
{
base.SetAccess(form, entity);
this.Model.Add("Line", "L01,L02,L03,L04");
}
public override int Update(FormM form, DFDictionary entity, ref string message)
{
try
{
var currentUser = Util.GetCurrentUser();
var listStatus1 = JsonSerializeHelper.DeserializeObject <List <WFTreeNode> >(Base64StringHelper.ConvertFromBase64String(entity["DF_TREE_VIEWSTATE1"]));
if (listStatus1 == null)
{
throw new Exception("Invalid DF_TREE_VIEWSTATE1");
}
var listStatus2 = JsonSerializeHelper.DeserializeObject <List <WFTreeNode> >(Base64StringHelper.ConvertFromBase64String(entity["DF_TREE_VIEWSTATE2"]));
if (listStatus2 == null)
{
throw new Exception("Invalid DF_TREE_VIEWSTATE2");
}
if (string.IsNullOrWhiteSpace(entity["RoleId"]))
{
throw new ArgumentNullException("RoleId");
}
using (var db = Pub.DB)
{
var sql = string.Empty;
sql = "DELETE FROM WF_M_AUTH_MODULE WHERE RoleId=@RoleId";
db.Execute(sql, new { RoleId = entity["RoleId"] });
sql = "DELETE FROM WF_M_AUTH_DATA WHERE RoleId=@RoleId";
db.Execute(sql, new { RoleId = entity["RoleId"] });
var checkedList = listStatus1.Where(a => a._checked).ToList();
db.Insert(checkedList.Select(a => new WF_M_AUTH_MODULE()
{
AuthId = Guid.NewGuid().ToString(),
ModuleId = a.id,
RoleId = entity["RoleId"],
CreateUser = currentUser.UserName,
CreateTime = DateTime.Now,
LastModifyUser = currentUser.UserName,
LastModifyTime = DateTime.Now
}));
checkedList = listStatus2.Where(a => a._checked).ToList();
db.Insert(checkedList.Select(a => new WF_M_AUTH_DATA()
{
AuthId = Guid.NewGuid().ToString(),
DeptId = a.id,
RoleId = entity["RoleId"],
CreateUser = currentUser.UserName,
CreateTime = DateTime.Now,
LastModifyUser = currentUser.UserName,
LastModifyTime = DateTime.Now
}));
}
message = "保存成功".GetRes();
return(DFPub.EXECUTE_SUCCESS);
}
catch (Exception ex)
{
message = ex.Message;
return(DFPub.EXECUTE_ERROR);
}
}
public override object GetParam(DFDictionary entity)
{
return(new { ID = entity["ID"] });
}
public override int Query(FormM form, DFDictionary entity, DataGridVM vm, int start, int limit, ref string message)
{
return(QueryByDay(form, entity, vm, start, limit, ref message));
}
public override int Query(FormM form, DFDictionary entity, DataGridVM vm, int start, int limit, ref string message)
{
using (var db = Pub.DB)
{
var sql = @"select ins.*,u.chinesename,u.EmployeeId from WF_T_INSTANCE ins
left join wf_m_user u on ins.Requestor=u.userid
left join wf_m_userdept ud on u.deptid=ud.deptid
where 1=1 and ud.UserId=@UserId";
if (!string.IsNullOrWhiteSpace(entity["DeptId"]))
{
sql += " and ud.DeptId in (SELECT DeptId FROM dbo.WF_M_DEPT WHERE DeptLabel LIKE (SELECT DeptLabel+'%' FROM dbo.WF_M_DEPT WHERE DeptId=@DeptId))";
}
if (!string.IsNullOrWhiteSpace(entity["InstanceStatus"]))
{
sql += " and InstanceStatus in @InstanceStatus";
}
if (!string.IsNullOrWhiteSpace(entity["InstanceId"]))
{
sql += " and InstanceId like @InstanceId";
}
if (!string.IsNullOrWhiteSpace(entity["ModelName"]))
{
sql += " and ModelName like @ModelName";
}
if (!string.IsNullOrWhiteSpace(entity["RequestTimeFrom"]))
{
sql += " and RequestTime>=@RequestTimeFrom";
}
if (!string.IsNullOrWhiteSpace(entity["RequestTimeTo"]))
{
sql += " and RequestTime<=@RequestTimeTo";
}
if (!string.IsNullOrWhiteSpace(entity["RequestorName"]))
{
sql += " and (RequestorName like @RequestorName or u.EmployeeId like @RequestorName or u.ChineseName like @RequestorName)";
}
if (!string.IsNullOrWhiteSpace(entity["EndDateFrom"]))
{
sql += " and (ins.instancestatus='Finished' and ins.lastmodifytime>=@EndDateFrom)";
}
if (!string.IsNullOrWhiteSpace(entity["EndDateTo"]))
{
sql += " and (ins.instancestatus='Finished' and ins.lastmodifytime<=@EndDateTo)";
}
sql += " order by ins.LastModifyTime desc";
var parameters = new
{
UserId = Util.GetCurrentUser().UserId,
DeptId = entity["DeptId"],
InstanceStatus = entity["InstanceStatus"].Split(',').ToList(),
InstanceId = string.Format("%{0}%", entity["InstanceId"]),
ModelName = string.Format("%{0}%", entity["ModelName"]),
RequestTimeFrom = ParseHelper.ParseDate(entity["RequestTimeFrom"]).GetValueOrDefault().ToString("yyyy-MM-dd"),
RequestTimeTo = ParseHelper.ParseDate(entity["RequestTimeTo"]).GetValueOrDefault().ToString("yyyy-MM-dd 23:59:59.999"),
RequestorName = "%" + entity["RequestorName"] + "%",
EndDateFrom = ParseHelper.ParseDate(entity["EndDateFrom"]).GetValueOrDefault().ToString("yyyy-MM-dd"),
EndDateTo = ParseHelper.ParseDate(entity["EndDateTo"]).GetValueOrDefault().ToString("yyyy-MM-dd 23:59:59.999")
};
vm.results = db.Query <int>(DFPub.GetCountSql(sql), parameters).FirstOrDefault();
var list = db.Query <VM_WF_T_INSTANCE>(DFPub.GetPageSql(sql, start + 1, start + limit), parameters).ToList();
foreach (var l in list)
{
l.CurrentExecutorName = StepExecutorLoader.GetCurrentExecutorName(l.InstanceId);
}
vm.rows = list;
return(DFPub.EXECUTE_SUCCESS);
}
}
public override int Query(FormM form, DFDictionary entity, DataGridVM vm, int start, int limit, ref string message)
{
GetList(entity, vm, start, limit);
return(DFPub.EXECUTE_SUCCESS);
}
public override object GetParam(DFDictionary entity)
{
return(new { SlaveDeviceId = entity["SlaveDeviceId"] });
}
private object QueryList(DFDictionary dict)
{
var vm = QueryForm(dict);
return(vm);
}
public virtual void ProcessData(DataTable dt, List <VM_TableMetadata> tables, DFDictionary entity)
{
var user = Util.GetCurrentUser().UserName;
foreach (DataRow dr in dt.Rows)
{
try
{
var drDict = entity.Merge(dr.ToDFDictionary());
foreach (var table in tables)
{
var dict = ConvertDFDictionary(table.Columns, drDict);
CheckData(table.Columns, dict, user, null);
SaveData(table, dict);
}
}
catch (WFException ex)
{
dr.SetField <string>("Result", ex.Message);
}
}
}
internal static DataGridVM QueryForm(DFDictionary queryParameters)
{
FormM form = null;
DFDictionary entity = null;
DFPub.SetDBEntity(queryParameters, ref form, ref entity);
if (null == form)
{
throw new ArgumentException("DF_FORMNAME");
}
var start = ParseHelper.ParseInt(queryParameters["start"]).GetValueOrDefault();
var limit = ParseHelper.ParseInt(queryParameters["limit"]).GetValueOrDefault();
// 如果客户端是导出，那么就设置记录数为最大值
if (queryParameters.Data.ContainsKey(DFPub.DF_DATAGRID_EXPORT))
{
start = 0;
limit = int.MaxValue;
}
var vm = new DataGridVM();
var message = string.Empty;
if (!string.IsNullOrWhiteSpace(form.DAImp))
{
var da = NinjectHelper.Get <IDA>(form.DAImp);
try
{
if (null == da)
{
throw new Exception("Invalid DAImp");
}
da.Query(form, entity, vm, start, limit, ref message);
if (vm.rows == null)
{
vm.rows = new List <string>();
}
if (vm.rows.GetType() == typeof(DataTable))
{
if (entity.Data.ContainsKey(DFPub.DF_DATAGRID_EXPORT))
{
vm.data = ExportHelper.Export(((DataTable)vm.rows), form, vm.data as List <GridColumnM>);
}
}
else
{
ConvertToDisplayText((IList)vm.rows);
if (entity.Data.ContainsKey(DFPub.DF_DATAGRID_EXPORT))
{
vm.data = ExportHelper.Export(((IList)vm.rows), form);
}
}
}
catch (Exception ex)
{
m_log.Error(ex.Message, ex);
vm.hasError = true;
vm.error = ex.Message;
message = ex.Message;
}
}
if (vm.rows == null)
{
vm.rows = new List <string>();
}
return(vm);
}
public abstract object GetParam(DFDictionary entity);
public override DFDictionary Get(FormM form, DFDictionary entity, ref string message)
{
return(base.Get(form, entity, ref message));
}
public override int Update(FormM form, DFDictionary entity, ref string message)
{
WFRes.Instance.Load();
message = "刷新界面语言成功".GetRes();
return(base.Update(form, entity, ref message));
}
public override void CheckInput(FormM form, DFDictionary entity)
{
base.CheckInput(form, entity);
//A面镀槽
var ADCStandard = ParseHelper.ParseDecimal(entity["ADCStandard"]);
if (!ADCStandard.HasValue)
{
throw new WFException("A面镀槽标准值必须是数字");
}
var ADCMax = ParseHelper.ParseDecimal(entity["ADCMax"]);
if (!ADCMax.HasValue)
{
throw new WFException("A面镀槽最大值必须是数字");
}
var ADCMin = ParseHelper.ParseDecimal(entity["ADCMin"]);
if (!ADCMin.HasValue)
{
throw new WFException("A面镀槽最小值必须是数字");
}
//A面调节槽
var ATJCStandard = ParseHelper.ParseDecimal(entity["ATJCStandard"]);
if (!ATJCStandard.HasValue)
{
throw new WFException("A面调节槽标准值必须是数字");
}
var ATJCMax = ParseHelper.ParseDecimal(entity["ATJCMax"]);
if (!ATJCMax.HasValue)
{
throw new WFException("A面调节槽最大值必须是数字");
}
var ATJCMin = ParseHelper.ParseDecimal(entity["ATJCMin"]);
if (!ATJCMin.HasValue)
{
throw new WFException("A面调节槽最小值必须是数字");
}
//A面Izn
var AIznStandard = ParseHelper.ParseDecimal(entity["AIznStandard"]);
if (!AIznStandard.HasValue)
{
throw new WFException("A面Izn标准值必须是数字");
}
var AIznMax = ParseHelper.ParseDecimal(entity["AIznMax"]);
if (!AIznMax.HasValue)
{
throw new WFException("A面Iz最大值必须是数字");
}
var AIznMin = ParseHelper.ParseDecimal(entity["AIznMin"]);
if (!AIznMin.HasValue)
{
throw new WFException("A面Izn最小值必须是数字");
}
//A面MF1
var AMF1Standard = ParseHelper.ParseDecimal(entity["AMF1Standard"]);
if (!AMF1Standard.HasValue)
{
throw new WFException("A面MF1标准值必须是数字");
}
var AMF1Max = ParseHelper.ParseDecimal(entity["AMF1Max"]);
if (!AMF1Max.HasValue)
{
throw new WFException("A面MF1最大值必须是数字");
}
var AMF1Min = ParseHelper.ParseDecimal(entity["AMF1Min"]);
if (!AMF1Min.HasValue)
{
throw new WFException("A面MF1最小值必须是数字");
}
//A面MF2
var AMF2Standard = ParseHelper.ParseDecimal(entity["AMF2Standard"]);
if (!AMF2Standard.HasValue)
{
throw new WFException("A面MF2标准值必须是数字");
}
var AMF2Max = ParseHelper.ParseDecimal(entity["AMF2Max"]);
if (!AMF2Max.HasValue)
{
throw new WFException("A面MF2最大值必须是数字");
}
var AMF2Min = ParseHelper.ParseDecimal(entity["AMF2Min"]);
if (!AMF2Min.HasValue)
{
throw new WFException("A面MF2最小值必须是数字");
}
//B面镀槽
var BDCStandard = ParseHelper.ParseDecimal(entity["BDCStandard"]);
if (!BDCStandard.HasValue)
{
throw new WFException("B面镀槽标准值必须是数字");
}
var BDCMax = ParseHelper.ParseDecimal(entity["BDCMax"]);
if (!BDCMax.HasValue)
{
throw new WFException("B面镀槽最大值必须是数字");
}
var BDCMin = ParseHelper.ParseDecimal(entity["BDCMin"]);
if (!BDCMin.HasValue)
{
throw new WFException("B面镀槽最小值必须是数字");
}
//B面调节槽
var BTJCStandard = ParseHelper.ParseDecimal(entity["BTJCStandard"]);
if (!BTJCStandard.HasValue)
{
throw new WFException("B面调节槽标准值必须是数字");
}
var BTJCMax = ParseHelper.ParseDecimal(entity["BTJCMax"]);
if (!BTJCMax.HasValue)
{
throw new WFException("B面调节槽最大值必须是数字");
}
var BTJCMin = ParseHelper.ParseDecimal(entity["BTJCMin"]);
if (!BTJCMin.HasValue)
{
throw new WFException("B面调节槽最小值必须是数字");
}
//B面Izn
var BIznStandard = ParseHelper.ParseDecimal(entity["BIznStandard"]);
if (!BIznStandard.HasValue)
{
throw new WFException("B面Izn标准值必须是数字");
}
var BIznMax = ParseHelper.ParseDecimal(entity["BIznMax"]);
if (!BIznMax.HasValue)
{
throw new WFException("B面Iz最大值必须是数字");
}
var BIznMin = ParseHelper.ParseDecimal(entity["BIznMin"]);
if (!BIznMin.HasValue)
{
throw new WFException("B面Izn最小值必须是数字");
}
//B面MF1
var BMF1Standard = ParseHelper.ParseDecimal(entity["BMF1Standard"]);
if (!BMF1Standard.HasValue)
{
throw new WFException("B面MF1标准值必须是数字");
}
var BMF1Max = ParseHelper.ParseDecimal(entity["BMF1Max"]);
if (!BMF1Max.HasValue)
{
throw new WFException("B面MF1最大值必须是数字");
}
var BMF1Min = ParseHelper.ParseDecimal(entity["BMF1Min"]);
if (!BMF1Min.HasValue)
{
throw new WFException("B面MF1最小值必须是数字");
}
//B面MF2
var BMF2Standard = ParseHelper.ParseDecimal(entity["BMF2Standard"]);
if (!BMF2Standard.HasValue)
{
throw new WFException("B面MF2标准值必须是数字");
}
var BMF2Max = ParseHelper.ParseDecimal(entity["BMF2Max"]);
if (!BMF2Max.HasValue)
{
throw new WFException("B面MF2最大值必须是数字");
}
var BMF2Min = ParseHelper.ParseDecimal(entity["BMF2Min"]);
if (!BMF2Min.HasValue)
{
throw new WFException("B面MF2最小值必须是数字");
}
}
public override void CheckInput(FormM form, DFDictionary entity)
{
base.CheckInput(form, entity);
if (entity["Line"] == "L01")
{
if (string.IsNullOrWhiteSpace(entity["Z6Standard"]) || string.IsNullOrWhiteSpace(entity["Z6Max"]) || string.IsNullOrWhiteSpace(entity["Z6Min"]))
{
throw new WFException("Z6温度信息必须填写");
}
}
//炉压设定检查
var Z1Standard = ParseHelper.ParseDecimal(entity["Z1Standard"]);
if (!Z1Standard.HasValue)
{
throw new WFException("Z1标准值必须是数字");
}
var Z1Max = ParseHelper.ParseDecimal(entity["Z1Max"]);
if (!Z1Max.HasValue)
{
throw new WFException("Z1最大值必须是数字");
}
var Z1Min = ParseHelper.ParseDecimal(entity["Z1Min"]);
if (!Z1Min.HasValue)
{
throw new WFException("Z1最小值必须是数字");
}
var Z2Standard = ParseHelper.ParseDecimal(entity["Z2Standard"]);
if (!Z2Standard.HasValue)
{
throw new WFException("Z2标准值必须是数字");
}
var Z2Max = ParseHelper.ParseDecimal(entity["Z2Max"]);
if (!Z2Max.HasValue)
{
throw new WFException("Z2最大值必须是数字");
}
var Z2Min = ParseHelper.ParseDecimal(entity["Z2Min"]);
if (!Z2Min.HasValue)
{
throw new WFException("Z2最小值必须是数字");
}
var Z3Standard = ParseHelper.ParseDecimal(entity["Z3Standard"]);
if (!Z3Standard.HasValue)
{
throw new WFException("Z3标准值必须是数字");
}
var Z3Max = ParseHelper.ParseDecimal(entity["Z3Max"]);
if (!Z3Max.HasValue)
{
throw new WFException("Z3最大值必须是数字");
}
var Z3Min = ParseHelper.ParseDecimal(entity["Z3Min"]);
if (!Z3Min.HasValue)
{
throw new WFException("Z3最小值必须是数字");
}
var Z4Standard = ParseHelper.ParseDecimal(entity["Z4Standard"]);
if (!Z4Standard.HasValue)
{
throw new WFException("Z4标准值必须是数字");
}
var Z4Max = ParseHelper.ParseDecimal(entity["Z4Max"]);
if (!Z4Max.HasValue)
{
throw new WFException("Z4最大值必须是数字");
}
var Z4Min = ParseHelper.ParseDecimal(entity["Z4Min"]);
if (!Z4Min.HasValue)
{
throw new WFException("Z4最小值必须是数字");
}
var Z5Standard = ParseHelper.ParseDecimal(entity["Z5Standard"]);
if (!Z5Standard.HasValue)
{
throw new WFException("Z5标准值必须是数字");
}
var Z5Max = ParseHelper.ParseDecimal(entity["Z5Max"]);
if (!Z5Max.HasValue)
{
throw new WFException("Z5最大值必须是数字");
}
var Z5Min = ParseHelper.ParseDecimal(entity["Z5Min"]);
if (!Z5Min.HasValue)
{
throw new WFException("Z5最小值必须是数字");
}
var Z6Standard = ParseHelper.ParseDecimal(entity["Z6Standard"]);
if (!Z6Standard.HasValue)
{
throw new WFException("Z6标准值必须是数字");
}
var Z6Max = ParseHelper.ParseDecimal(entity["Z6Max"]);
if (!Z6Max.HasValue)
{
throw new WFException("Z6最大值必须是数字");
}
var Z6Min = ParseHelper.ParseDecimal(entity["Z6Min"]);
if (!Z6Min.HasValue)
{
throw new WFException("Z6最小值必须是数字");
}
}
private int btnGenerate(FormM form, DFDictionary entity, ref string message)
{
var list = GetGridClientData <VM_ColumnMetadata>(entity).Where(a => a.selected).ToList();
if (list.Count == 0)
{
throw new WFException("请选择列");
}
var tableName = entity["TableName"];
var GenerateOption = entity["GenerateOption"];
var sql = string.Empty;
if (GenerateOption.Contains("CreateTable"))
{
sql = string.Format("CREATE TABLE {0}({1});", tableName,
string.Join("," + Environment.NewLine, list.Select(a => string.Format("{0} {1}{2}", a.ColumnName, a.DataType, a.IsNullable == "Y" ? "" : " NOT NULL"))));
sql += Environment.NewLine + Environment.NewLine
+ string.Format("ALTER TABLE {0} ADD PRIMARY KEY({1});", tableName, string.Join(",", list.Where(a => a.IsPrimaryKey == "Y").Select(a => a.ColumnName)));
}
if (GenerateOption.Contains("Alter"))
{
sql += Environment.NewLine + Environment.NewLine
+ string.Join(Environment.NewLine, list.Select(a => string.Format("ALTER TABLE {0} ADD {1} {2}{3}{4}{5};",
tableName,
a.ColumnName,
a.DataType,
a.IsNullable == "Y" ? string.Empty : " NOT NULL",
a.IsPrimaryKey == "Y" ? " PRIMARY KEY" : string.Empty,
a.IsIdentity == "Y" ? " IDENTITY(1,1)" : string.Empty)));
}
if (GenerateOption.Contains("Insert"))
{
var listCopy = list;
var insertSql = string.Format("INSERT INTO {0}({1}) VALUES({2})", tableName, string.Join(",", listCopy.Select(a => a.ColumnName)),
string.Join(",", listCopy.Select(a => string.Format("@{0}", a.ColumnName))));
if (entity["SyncText"] == "1")
{
this.Model.Add("Insert", insertSql);
}
sql += Environment.NewLine + Environment.NewLine + insertSql;
}
if (GenerateOption.Contains("Update"))
{
var listCopy = list;
if (entity["SpecialOptions"] == "1")
{
listCopy = list.Where(a => a.ColumnName.ToLower() != "createuser" && a.ColumnName.ToLower() != "createtime").ToList();
}
var updateSql = string.Format("UPDATE {0} SET {1} WHERE {2}", tableName, string.Join(",", listCopy.Where(a => a.IsPrimaryKey != "Y").Select(a => string.Format("{0}=@{0}", a.ColumnName))),
string.Join(" and ", listCopy.Where(a => a.IsPrimaryKey == "Y").Select(a => string.Format("{0}=@{0}", a.ColumnName))));
if (entity["SyncText"] == "1")
{
this.Model.Add("Update", updateSql);
}
sql += Environment.NewLine + Environment.NewLine + updateSql;
}
if (GenerateOption.Contains("Exist"))
{
var existSql = string.Format("SELECT * FROM {0} WHERE {1}", tableName, string.Join(" and ", list.Where(a => a.IsPrimaryKey == "Y").Select(a => string.Format("{0}=@{0}", a.ColumnName))));
if (entity["SyncText"] == "1")
{
this.Model.Add("CheckExist", existSql);
}
sql += Environment.NewLine + Environment.NewLine + existSql;
}
this.Model.Add("SQL", sql);
return(DFPub.EXECUTE_SUCCESS);
}
