/// <summary>
/// 删除事件
/// by xlb 2013-01-05
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void buttonDelRule_Click(object sender, EventArgs e)
{
try
{
if (_currentRule == null || _currentRule.RuleCode == null)
{
MessageBox.Show("请选择要删除的数据");
return;
}
DataTable dtQcRecord = QCRecord.GetAllQcRecord(_currentRule.RuleCode);
int count = int.Parse(dtQcRecord.Rows[0][0].ToString());
if (count > 0)
{
MessageBox.Show("该规则已被质控记录使用，无法删除");
return;
}
if (MyMessageBox.Show("您确定删除吗？", "提示", MyMessageBoxButtons.OkCancel) == DialogResult.Cancel)
{
return;
}
QCRule.DeleteQcRule(_currentRule);
MessageBox.Show("删除成功");
InitDataRule();
DS_Common.ClearControl(groupControlRule);
DS_Common.ClearControl(groupControlCondtion);
lookUpEditDoctorLevel.EditValue = null;
}
catch (Exception ex)
{
MyMessageBox.Show(1, ex);
}
}
/// <summary>
/// 处理循环触发的时限规则
/// 进行有限次循环时，如果有限次的循环未结束，则外部的触发将会不起作用
/// </summary>
/// <param name="noofinpat"></param>
/// <param name="rule"></param>
/// <param name="drConfigDataResult"></param>
/// <param name="listQCRecord"></param>
void Process1QCRuleCircle(QCRule rule, DataRow drConfigDataResult, List <QCRecord> listQCRecord)
{
try
{
string noofinpat = drConfigDataResult[rule.Condition.PatNoColumnName].ToString();
if (rule.MARK == QCEnum.OperationType.Circle && rule.CycleTimes > 0)//有限次循环
{
//获得离当前时间最接近的第一条循环记录
QCRecord record = (from QCRecord qcrecord in listQCRecord
where qcrecord.CycleTimes == 1
orderby qcrecord.RealConditionTime descending
select qcrecord).FirstOrDefault();
//由于循环记录的第一条记录对应的QCRecord.FirstCycleRecordID为空，所有下面计算的时候要减去1
int count = (from QCRecord qcrecord in listQCRecord
where qcrecord.FirstCycleRecordID == record.ID
select qcrecord).Count();
if (count < rule.CycleTimes - 1)//上一次的有限次的循环未结束，则外部的触发将会不起作用
{
return;
}
else if (count == rule.CycleTimes - 1)//上一次的有限次的循环已经结束，则外部的触发开始起作用
{
//插入初始化数据到QCRecord表中
QCRecord.InsertInitData(noofinpat, rule, drConfigDataResult);
}
}
}
catch (Exception ex)
{
throw ex;
}
}
public static LEDShowEntity GetLEDShow(int iClienID, int iTes_TestItems_ID)
{
LEDShowEntity lEDShowEntity = null;
try
{
using (DCQUALITYDataContext db = new DCQUALITYDataContext())
{
QCRecord qcrecord = (from c in db.QCRecord
where c.QCRecord_Client_ID == iClienID && c.QCRecord_ISLEDSHOW == false && c.TestItems.Tes_TestItems_ID == iTes_TestItems_ID && c.Dictionary.Dictionary_Name == "启动"
select c).First();
lEDShowEntity = new LEDShowEntity();
lEDShowEntity.CarNum = qcrecord.QCInfo.DRAW_EXAM_INTERFACE.CNTR_NO; //车牌号
lEDShowEntity.Grade = qcrecord.QCInfo.DRAW_EXAM_INTERFACE.PROD_ID; //等级货品
lEDShowEntity.AvgOne = qcrecord.QCInfo.QCInfo_MOIST_PER_SAMPLE.ToString(); //一检平均水分值
//qcrecord.QCInfo.QCInfo_UnpackBack_MOIST_PER_SAMPLE.ToString();//拆包后水分平均
lEDShowEntity.AvgTwo = qcrecord.QCInfo.QCInfo_UnpackBefore_MOIST_PER_SAMPLE.ToString(); //拆包前水分平均
lEDShowEntity.Count = qcrecord.QCRecord_QCCOUNT.ToString(); //检查序号；
lEDShowEntity.Result = qcrecord.QCRecord_RESULT.ToString(); //结果
// lEDShowEntity.OneValue = xh + ":" + wate + "%";
lEDShowEntity.ID = qcrecord.QCRecord_ID;
}
}
catch (Exception ex) {}
return(lEDShowEntity);
}
public static bool UpdateQCRecordISLEDSHOW(int iqcrecordId)
{
bool rbool = false;
using (DCQUALITYDataContext db = new DCQUALITYDataContext())
{
QCRecord qcrecord = db.QCRecord.First(c => c.QCRecord_ID == iqcrecordId);
qcrecord.QCRecord_ISLEDSHOW = true;
db.SubmitChanges();
rbool = true;
}
return(rbool);
}
/// <summary>
/// 修改质检记录信息
/// 注意：请在编写实体之前先获取实体再进行修改的字段编写
/// </summary>
/// <param name="record">质检记录实体（QCRecord）</param>
/// <returns></returns>
public static bool UpdateOneQcRecord(QCRecord record)
{
bool rbool = false;
using (DCQUALITYDataContext db = new DCQUALITYDataContext())
{
try
{
QCRecord qInfo = db.QCRecord.First(c => c.QCRecord_ID == record.QCRecord_ID);
qInfo.QCRecord_Client_ID = record.QCRecord_Client_ID;
qInfo.QCRecord_COUNT = record.QCRecord_COUNT;
qInfo.QCRecord_Dictionary_ID = record.QCRecord_Dictionary_ID;
qInfo.QCRecord_DRAW = record.QCRecord_DRAW;
// qInfo.QCRecord_ISLEDSHOW = record.QCRecord_ISLEDSHOW;
qInfo.QCRecord_ISRETEST = record.QCRecord_ISRETEST;
qInfo.QCRecord_NAME = record.QCRecord_NAME;
qInfo.QCRecord_NUMBER = record.QCRecord_NUMBER;
qInfo.QCRecord_OFF_TIME = record.QCRecord_OFF_TIME;
qInfo.QCRecord_QCCOUNT = record.QCRecord_QCCOUNT;
qInfo.QCRecord_QCInfo_ID = record.QCRecord_QCInfo_ID;
qInfo.QCRecord_QCRetest_ID = record.QCRecord_QCRetest_ID;
qInfo.QCRecord_REMARK = record.QCRecord_REMARK;
qInfo.QCRecord_RESULT = record.QCRecord_RESULT;
qInfo.QCRecord_TARE = record.QCRecord_TARE;
qInfo.QCRecord_TestItems_ID = record.QCRecord_TestItems_ID;
qInfo.QCRecord_TIME = record.QCRecord_TIME;
qInfo.QCRecord_TYPE = record.QCRecord_TYPE;
qInfo.QCRecord_UPDATE_REASON = record.QCRecord_UPDATE_REASON;
qInfo.QCRecord_UPDATE_TIME = record.QCRecord_UPDATE_TIME;
qInfo.QCRecord_UserId = record.QCRecord_UserId;
qInfo.QCRecord_UserId_UpdateID = record.QCRecord_UserId_UpdateID;
qInfo.QCRecord_UpdateCardUserName = record.QCRecord_UpdateCardUserName;
db.SubmitChanges();
rbool = true;
}
catch (Exception ex)
{
throw new Exception("修改质检信息（QCInfo）:" + ex.Message);
}
finally
{
db.Connection.Close();
}
}
return(rbool);
}
/// <summary>
/// 处理每一条时限规则
/// </summary>
/// <param name="rule"></param>
void Process1QCRule(QCRule rule)
{
try
{
QCCondition condition = rule.Condition;
//通过QCCondition表中的配置获得相应表中的结果集, 存在病人流水号时，需要将其转换为首页序号
DataTable dtConfigResult = QCCondition.GetConfigDataResult(condition);
foreach (DataRow dr in dtConfigResult.Rows)
{
//通过首页序号NOOFINPAT + RULECODE 在QCRecord表中获取对应的记录
string noofinpat = dr[condition.PatNoColumnName].ToString();
string rulecode = rule.RuleCode;
List <QCRecord> listQCRecord = (from QCRecord rec in m_ListQCRecord
where rec.NoOfInpat == noofinpat && rec.Rule.RuleCode == rulecode
select rec).ToList <QCRecord>();
//无记录则插入初始化的数据
if (listQCRecord.Count() == 0)
{
QCRecord.InsertInitData(noofinpat, rule, dr);
continue;
}
//通过时间比较是否存在相同的
DateTime timeValue = Convert.ToDateTime(dr[condition.TimeColumnName].ToString());
var qcRecords = from QCRecord record in listQCRecord
where record.ConditionTime.ToString("yyyy-MM-dd HH:mm:ss", CultureInfo.CurrentCulture)
== timeValue.ToString("yyyy-MM-dd HH:mm:ss", CultureInfo.CurrentCulture)
select record;
//表示已经处理过，所以不对其再次处理
if (qcRecords.Count() > 0)
{
continue;
}
//针对不同的操作方式进行不同的处理,确保 listQCRecord.count() > 0
Process1QCRuleMark(rule, dr, listQCRecord);
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 初始化数据
/// </summary>
private void InitData()
{
try
{
m_DictQCCondition = QCCondition.GetAllQCCondition();
m_DictQCCategory = RuleCategory.GetAllRuleCategory();
//获得所有QCRule，包括有效和无效
m_DictQCRuleAll = QCRule.GetAllQCRule(m_DictQCCondition, m_DictQCCategory);
m_ListQCRecord = QCRecord.GetAllQCRecord(m_DictQCRuleAll, m_DictQCCondition, m_DictQCCategory);
//获得所有有效的QCRule
m_DictQCRuleValid = QCRule.GetAllQCRuleValid(m_DictQCCondition, m_DictQCCategory);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 针对不同的操作方式进行不同的处理
/// </summary>
/// <param name="rule"></param>
/// <param name="drConfigDataResult"></param>
/// <param name="listQCRecord"></param>
void Process1QCRuleMark(QCRule rule, DataRow drConfigDataResult, List <QCRecord> listQCRecord)
{
try
{
string noofinpat = drConfigDataResult[rule.Condition.PatNoColumnName].ToString();
//判断A记录的操作方式
switch (rule.MARK)
{
//一次性，只能触发一次
case QCEnum.OperationType.OnlyOne:
#region Add By wwj 2013-02-27
//修改事件触发时间后，【1】删除原先就的时限提醒记录，【2】再插入初始化数据到QCRecord表中
//例如：修改入院入区时间，则需要先删除原先入院记录的提醒信息，然后插入新的入院记录提醒信息
foreach (QCRecord qcRecord in listQCRecord)
{
QCRecord.CancelQCRecordData(qcRecord.ID); //【1】
}
QCRecord.InsertInitData(noofinpat, rule, drConfigDataResult); //【2】
#endregion
break;
//触发一次执行一次
case QCEnum.OperationType.EveryOne:
//插入初始化数据到QCRecord表中
QCRecord.InsertInitData(noofinpat, rule, drConfigDataResult);
break;
//循环触发
case QCEnum.OperationType.Circle:
Process1QCRuleCircle(rule, drConfigDataResult, listQCRecord);
break;
default:
break;
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 根据质检记录编号获取质检记录实体
/// </summary>
/// <param name="iqcRecordID">质检记录编号</param>
/// <returns>QCRecord</returns>
public static QCRecord GetQCInfo(int iqcRecordID, string testItemName)
{
QCRecord qcInfo = null;
using (DCQUALITYDataContext db = new DCQUALITYDataContext())
{
try
{
qcInfo = db.QCRecord.First(c => c.QCRecord_ID == iqcRecordID);
}
catch (Exception ex)
{
throw new Exception("根据质检记录编号获取质检记录实体（QCRecord）:" + ex.Message);
}
finally
{
db.Connection.Close();
}
}
return(qcInfo);
}
/// <summary>
/// 新增一条质检记录
/// </summary>
/// <param name="qcRecord">QCRecord质检实体</param>
/// <param name="rint">新增后自动增长编号</param>
/// <returns></returns>
public static bool InsertOneQCRecord(QCRecord qcRecord, out int rint)
{
rint = 0;
bool rbool = true;
using (DCQUALITYDataContext db = new DCQUALITYDataContext())
{
try
{
db.QCRecord.InsertOnSubmit(qcRecord);
db.SubmitChanges();
rint = qcRecord.QCRecord_ID;
rbool = true;
}
catch
{
rbool = false;
}
finally { db.Connection.Close(); }
}
return(rbool);
}
/// <summary>
/// 判断时限的违规情况
/// 如果针对的是循环时限，需要动态的判断，并插入初始数据到QCRecord表中
/// </summary>
void Process2()
{
try
{
//更新时限记录的条件状态为完成
//QCRecord.REALCONDITIONTIME（实际条件时间）>= SYSDATE（当前时间）则 QCRecord.CONDITION=1，即条件已完成
QCRecord.UpdateConditionComplete();
//更新时限记录中的完成状态至未完成 当病历删除后导致对应的时限记录重新生效
QCRecord.UpdateResultToUnComplete();
//更新病历的违规状态，针对条件成立但是未完成的记录 即QCRecord.Condition == 1 AND QCRecord.Result == 0
//QCRecord.REALCONDITIONTIME（实际条件时间）+ QCRecord.TimeLimit < SYSDATE（当前时间）则 QCRecord.FoulState=1，即违规
QCRecord.UpdateFoulState();
//处理循环时限规则
Process2QCRuleCircle();
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 结束时限的内部逻辑
/// </summary>
/// <param name="recordDetailID"></param>
void CompleteQCTimeLimitInner(DataTable dtRecordDetail)
{
try
{
string noofinpat = dtRecordDetail.Rows[0]["noofinpat"].ToString(); //首页序号
string recordDetailID = dtRecordDetail.Rows[0]["id"].ToString(); //病历编号
string qcCode = dtRecordDetail.Rows[0]["qc_code"].ToString(); //病历监控代码
string createTime = dtRecordDetail.Rows[0]["createtime"].ToString(); //病历创建时间
//找到该份病历对应的所有病历时限
DataTable dtQCRecord = GetQCRecordByNoofinpatQCCode(noofinpat, qcCode);
//在QCRecord表中找到最合适的一条记录与病历编号RecordDetailID匹配
DataRow drQCRec = (from DataRow drQCRecord in dtQCRecord.Rows
where drQCRecord["result"].ToString() == "0"
orderby drQCRecord["realconditiontime"].ToString() descending
select drQCRecord).FirstOrDefault <DataRow>();
if (drQCRec != null)
{
//更新时限记录的已完成
string qcRecordID = drQCRec["id"].ToString();
DateTime recordDetailCreateTime = Convert.ToDateTime(createTime);
DateTime realConditionTime = Convert.ToDateTime(drQCRec["realconditiontime"]);
int timeLimit = Convert.ToInt32(drQCRec["timelimit"]);
string foulState = "0";//违规情况 默认不违规 0：不违规 1：违规
if ((recordDetailCreateTime - realConditionTime).Seconds >= timeLimit)
{
foulState = "1";
}
QCRecord.UpdateResultComplete(qcRecordID, recordDetailID, foulState);
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 修改LED显示的最后一条数据
/// 说明：在质检完成时将质检数据最后一条有效数据更改为LED未显示
/// </summary>
/// <param name="iqcinfoId">质检编号</param>
/// <param name="iTes_TestItems_ID">质检类型（水分检测、重量检测）</param>
/// <returns></returns>
public static bool UpdateQcRecordQCInfoID(int iqcinfoId, int iTes_TestItems_ID)
{
bool rbool = false;
int iqcRecordID = 0;
using (DCQUALITYDataContext db = new DCQUALITYDataContext())
{
try
{
iqcRecordID = db.QCRecord.Where(c => c.QCRecord_QCInfo_ID == iqcinfoId && c.Dictionary.Dictionary_Name == "启动" && c.TestItems.Tes_TestItems_ID == iTes_TestItems_ID).Max(p => p.QCRecord_ID);
QCRecord qcInfo = db.QCRecord.First(c => c.QCRecord_ID == iqcRecordID);
// qcInfo.QCRecord_ISLEDSHOW = false;
rbool = UpdateOneQcRecord(qcInfo);
//db.SubmitChanges();
// rbool = true;
}
catch (Exception ex)
{
throw new Exception("获取质检记录的最大的编号:" + ex.Message);
}
finally { db.Connection.Close(); }
}
return(rbool);
}
/// <summary>
/// 更新QCRecord表中的数据，结束满足条件的时限
/// </summary>
void Process3()
{
try
{
//获得所有未完成的病历时限记录，为了系统的性能考虑，只抓取在院且出院时间在30天之内的记录
List <QCRecord> listQCRecord = QCRecord.GetAllQCRecordUnComplete(m_DictQCRuleAll, m_DictQCCondition, m_DictQCCategory);
//按用户、质量规则、条件时间来排序
listQCRecord = (from QCRecord rec in listQCRecord
orderby rec.NoOfInpat, rec.Rule.QCCode, rec.RealConditionTime
select rec).ToList();
//为了性能上的考虑，使用字典保存已经捞取过的数据，避免重复捞取数据
Dictionary <string, DataTable> dictRecorddetailByPat = new Dictionary <string, DataTable>();
foreach (QCRecord record in listQCRecord)
{
string noofinpat = record.NoOfInpat;
string qccode = record.QCCode;
DataTable dtRecordDetailID = new DataTable();
#region 捞取符合条件的病人号RecordDetailID，用于结束对应的时限记录QCRecord
if (dictRecorddetailByPat.ContainsKey(noofinpat))
{
dtRecordDetailID = dictRecorddetailByPat[noofinpat];
}
else
{
dtRecordDetailID = GetRecordDetailIDByPatAndQCCode(noofinpat);
dictRecorddetailByPat.Add(noofinpat, dtRecordDetailID);
}
if (dtRecordDetailID.Rows.Count == 0)
{
continue;
}
List <DataRow> listDataRow = (from DataRow dr in dtRecordDetailID.Rows
where dr["qc_code"].ToString().Equals(qccode)
orderby dr["createtime"].ToString()
select dr).Distinct().ToList();
if (listDataRow.Count == 0)
{
continue;
}
#endregion
//更新时限记录的已完成
string recordDetailID = listDataRow[0]["id"].ToString();
//对于创建时间为空的时间处理 一般不会有空时间 xll 2013-05-21
DateTime recordDetailCreateTime = DateTime.Now;
if (!string.IsNullOrEmpty(listDataRow[0]["createtime"].ToString()))
{
recordDetailCreateTime = Convert.ToDateTime(listDataRow[0]["createtime"]);
}
DateTime realConditionTime = record.RealConditionTime;
string foulState = "0";//违规情况 默认不违规 0：不违规 1：违规
if ((recordDetailCreateTime - realConditionTime).Seconds >= record.TimeLimit)
{
foulState = "1";
}
QCRecord.UpdateResultComplete(record.ID, recordDetailID, foulState);
//删除已经在QCRecord表中匹配过的记录
dtRecordDetailID.Rows.Remove(listDataRow[0]);
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 处理循环时限规则，在适当的时机插入初始化数据至QCRecord表中
/// </summary>
void Process2QCRuleCircle()
{
try
{
//获取当前时间用于后面逻辑的比较
DateTime currentDateTime = GetCurrentDateTime();
//捞取QCRecord表中的循环规则时限的记录
List <QCRecord> listQCRecord = QCRecord.GetAllQCRecordCircle(m_DictQCRuleAll, m_DictQCCondition, m_DictQCCategory);
//获取拥有循环时限规则记录的所有病人列表
List <string> listNoOfInpat = (from QCRecord record in listQCRecord
where record.IsCycle == true
select record.NoOfInpat).Distinct().ToList();
//获取拥有循环时限规则记录的所有的RuleCode
List <string> ListRuleCode = (from QCRecord record in listQCRecord
where record.IsCycle == true
select record.Rule.RuleCode).Distinct().ToList();
foreach (string noofinpat in listNoOfInpat)
{
foreach (string ruleCode in ListRuleCode)
{
//根据 病人首页号 + RuleCode 获得时限记录QCRecord
List <QCRecord> listQCRecordByPat = (from QCRecord record in listQCRecord
where record.NoOfInpat.Equals(noofinpat) && record.Rule.RuleCode.Equals(ruleCode) && record.IsCycle == true
orderby record.CycleTimes descending
select record).ToList <QCRecord>();
if (listQCRecordByPat.Count() == 0)
{
continue;
}
//指定病人noofinpat、指定规则代码RuleCode 循环的最后一条记录QCRecord
QCRecord recLast = listQCRecordByPat.FirstOrDefault <QCRecord>();
listQCRecordByPat = (from QCRecord record in listQCRecord
where record.NoOfInpat.Equals(noofinpat) && record.Rule.RuleCode.Equals(ruleCode) && record.IsCycle == true
orderby record.CycleTimes ascending
select record).ToList <QCRecord>();
//指定病人noofinpat、指定规则代码RuleCode 循环的第一条记录QCRecord
QCRecord recFirst = listQCRecordByPat.FirstOrDefault <QCRecord>();
if (recLast.Rule.CycleTimes == 0)//无限次循环
{
//条件发生时间 + 循环时间间隔 < 当前时间 && 循环未停止
if (recLast.RealConditionTime.AddSeconds(recLast.TimeLimit) < currentDateTime && !recLast.IsStopCycle)
{
//插入初始化的数据到QCRecord表中
QCRecord.InsertInitDataForCircle(recLast, recFirst);
}
}
else//有限次循环
{
//条件发生时间 + 循环时间间隔 < 当前时间 && 当前循环的次数小于循环需要的总次数 && 循环未停止
if (recLast.RealConditionTime.AddSeconds(recLast.TimeLimit) < currentDateTime &&
recLast.CycleTimes < recLast.Rule.CycleTimes &&
!recLast.IsStopCycle)
{
//插入初始化的数据到QCRecord表中
QCRecord.InsertInitDataForCircle(recLast, recFirst);
}
else if (recLast.CycleTimes == recLast.Rule.CycleTimes && !recLast.IsStopCycle)
{
//循环次数到达上限，停止循环，设置最后一条记录的QCRecord.IsStopCycle = 1
QCRecord.UpdateStopCycle(recLast.ID, true);
}
}
}
}
}
catch (Exception ex)
{
throw ex;
}
}
