//-------------从指定的房间串中返回active的房间过滤----------------------------------------
private String get_active_RoomID_Cluster(String roomCluster)
{
if (CSTR.isEmpty(roomCluster))
{
return("");
}
String[] room_arr = CSTR.splitRooms(roomCluster);
if (null == room_arr || room_arr.Length <= 0)
{
return("");
}
String retCluster = "";
foreach (String roomID in room_arr)
{
bool is_active = DatabaseCache.RoomInfo_is_active(roomID);
if (is_active)
{
retCluster += roomID;
}
}
return(retCluster);
}
//获取指定行的字段值: JiaohaoTable_get_Field_String_by_IndexID("63","status")
public static String JiaohaoTable_Get_Field_Value_by_IndexID(String indexID, String fieldName)
{
indexID = CSTR.trim(indexID);
fieldName = CSTR.trim(fieldName);
if (CSTR.isEmpty(indexID))
{
return("");
}
if (CSTR.isEmpty(fieldName))
{
return("");
}
//获取JiaohaoTable表
DataTable cache_tbl = DB_Get_JiaohaoTable_table();
if (CSTR.IsTableEmpty(cache_tbl))
{
return(null);
}
//查询符合条件的行集合
DataRow[] row_result = cache_tbl.Select(String.Format("IndexID='{0}'", indexID));
if (CSTR.IsArrayEmpty(row_result))
{
return("");
}
//从第一行中返回指定的列数据
return(CSTR.ObjectTrim(row_result[0][fieldName]));
}
//获取系统中未完成的[超声科]房间的检查列表
private List <String> getUltrasoundExamList()
{
DataTable tbl = DatabaseCache.DB_Get_JiaohaoTable_table();
if (CSTR.IsTableEmpty(tbl))
{
return(null);
}
DataRow[] rows = tbl.Select("RoomID='[超声科]' and IsOver='0'");
if (CSTR.IsRowArrEmpty(rows))
{
return(null);
}
List <String> list = new List <string>();
foreach (DataRow row in rows)
{
String DJLSH = CSTR.ObjectTrim(row["DJLSH"]);
if (CSTR.isEmpty(DJLSH))
{
continue;
}
DJLSH = DJLSH.Replace("'", "");
list.Add(DJLSH);
}
return(list);
}
public static Dictionary <Status, bool> getStatus(DataRow row)
{
if (null == row)
{
return(null);
}
bool isNormal = false;
bool isActive = false;
bool isCalling = false;
bool isReadOnce = false;
bool isCheckOver = false;
bool isPass = false;
String statusCluster = getStatusCluser(row);
if (statusCluster.Equals("0000"))
{
isNormal = true;
}
else if (statusCluster.Equals("1000"))
{
isActive = true;
}
else if (statusCluster.Equals("1110"))
{
isCalling = true;
}
else if (statusCluster.Equals("0100"))
{
isPass = true;
}
else if (statusCluster.Equals("0101"))
{
//如果EndTime为空是读卡一次的检查
if (CSTR.isEmpty(CSTR.ObjectTrim(row["EndTime"])))
{
isReadOnce = true;
}
else
{
isCheckOver = true;
}
}
Dictionary <Status, bool> map = new Dictionary <Status, bool>();
map.Add(Status.Normal, isNormal);
map.Add(Status.Active, isActive);
map.Add(Status.Calling, isCalling);
map.Add(Status.Pass, isPass);
map.Add(Status.ReadOnce, isReadOnce);
map.Add(Status.CheckOver, isCheckOver);
return(map);
}
//调用者写入需要播报的语音文本
public void speak(String str)
{
str = CSTR.trim(str);
if (CSTR.isEmpty(str))
{
return;
}
text_speak = str;
need_speak = true;
}
//Token获取
public int Call_SP_Token(String strHandlerName)
{
if (CSTR.isEmpty(strHandlerName))
{
return(0);
}
try
{
MySqlConnection connection = getConn();
if (null == connection)
{
return(0);
}
//指定存储过程名称和连接
MySqlDataAdapter adapter = new MySqlDataAdapter();
adapter.SelectCommand = new MySqlCommand();
adapter.SelectCommand.Connection = connection;
adapter.SelectCommand.CommandText = "Tocken";//存储过程名称
adapter.SelectCommand.CommandType = CommandType.StoredProcedure;
//设置参数 //mysql的存储过程参数是以?打头的！！！！
//in - parameter_Handler_Name
MySqlParameter parameter_Handler_Name = new MySqlParameter("?Handler_Name", MySqlDbType.VarChar, 128);
parameter_Handler_Name.Direction = ParameterDirection.Input;
parameter_Handler_Name.Value = strHandlerName;
adapter.SelectCommand.Parameters.Add(parameter_Handler_Name);
//out - out_token_flag
MySqlParameter parameter_out_token_flag = new MySqlParameter("?out_token_flag", MySqlDbType.Int32, 11);
parameter_out_token_flag.Direction = ParameterDirection.Output;
adapter.SelectCommand.Parameters.Add(parameter_out_token_flag);
//把返回结果填入DataSet
DataSet ds = new DataSet();
adapter.Fill(ds);
//取得Out参数
int result_flag = CSTR.convertToInt(CSTR.ObjectTrim(parameter_out_token_flag.Value));
return(result_flag);
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
Log.log("[mysql.Call_SP_Token()] " + exp.Message);
conn = null;
}
return(0);
}
//获取RISServer的当前时间
private DateTime getRISServerTime()
{
DateTime dt = new DateTime();
try
{
//1.连接服务器,取得时间
ExamQueue queue = new ExamQueue();
String sql = "select date_format(now(),'%Y') as nYear," +
"date_format(now(),'%m') as nMonth," +
"date_format(now(),'%d') as nDay," +
"date_format(now(),'%H') as nHour," +
"date_format(now(),'%i') as nMinute," +
"date_format(now(),'%s') as nSecond";
DataTable tbl = queue.getDB().query(sql);
if (CSTR.IsTableEmpty(tbl))
{
return(dt);
}
//2.转换
String strYear = CSTR.ObjectTrim(tbl.Rows[0]["nYear"]);
String strMonth = CSTR.ObjectTrim(tbl.Rows[0]["nMonth"]);
String strDay = CSTR.ObjectTrim(tbl.Rows[0]["nDay"]);
String strHour = CSTR.ObjectTrim(tbl.Rows[0]["nHour"]);
String strMinute = CSTR.ObjectTrim(tbl.Rows[0]["nMinute"]);
String strSecond = CSTR.ObjectTrim(tbl.Rows[0]["nSecond"]);
if (CSTR.isEmpty(strYear) || CSTR.isEmpty(strMonth) || CSTR.isEmpty(strDay) ||
CSTR.isEmpty(strHour) || CSTR.isEmpty(strMinute) || CSTR.isEmpty(strSecond))
{
return(dt);
}
//3.生成DateTime格式时间
int nYear = Int16.Parse(strYear);
int nMonth = Int16.Parse(strMonth);
int nDay = Int16.Parse(strDay);
int nHour = Int16.Parse(strHour);
int nMinute = Int16.Parse(strMinute);
int nSecond = Int16.Parse(strSecond);
dt = new DateTime(nYear, nMonth, nDay, nHour, nMinute, nSecond);
}
catch (Exception exp)
{
Console.Out.WriteLine(exp.Message);
}
return(dt);
}
public DataTable TFD_Register_Query_Stusy_BAK()
{
//此查询没有考虑TJCS,会导致TJCS>1的检查项目变多
if (CSTR.isEmpty(tfd_DJLSH))
{
return(null);
}
String sql = String.Format(@"select
patient.TJBH,
patient.XM,
patient.XB,
patient.SFZH,
patient.PHONE as p_PHONE,
djb.PHONE as d_PHONE,
djb.DJLSH,
djb.DWBH,
(select top 1 MC from futian_user.HYDWDMB where BH=DWBH) as DWMC,
djb.TJRQ,
jlb.JCRQ as jlb_JCRQ,
djb.TJLB,
(select top 1 MC from futian_user.TJ_TJLB where BH=TJLB) as TJLBMC,
djb.RYLB,
(select top 1 MC from futian_user.TJ_TJRYLB where BH=RYLB) as RYLBMC,
jlb.XH,
jlb.LXBH as ExamType,
(select top 1 MC from futian_user.TJ_TJLXB where LXBH=jlb.LXBH) as ExamTypeMC,
jlb.TJXMBH,
(select top 1 MC from futian_user.TJ_ZHXM_HD where BH=TJXMBH) as TJXMMC,
(select top 1 TSXX from futian_user.TJ_ZHXM_HD where BH=TJXMBH) as TSXX,
(select top 1 CheckRoom from futian_user.TJ_ZHXM_HD where BH=TJXMBH) as CheckRoom,
jlb.ISOVER
from futian_user.RYXX patient,futian_user.TJ_TJDJB djb,futian_user.TJ_TJJLB jlb
where
djb.TJBH=patient.TJBH
and djb.TJBH=jlb.TJBH
and djb.DJLSH='{0}'
order by jlb.XH", tfd_DJLSH);
return(new ExamQueue().getTijianDB().query(sql));
}
public static byte[] regainByteBuffer(String base64Cluster)
{
byte[] buffer = null;
if (CSTR.isEmpty(base64Cluster))
{
return(null);
}
try
{
buffer = Convert.FromBase64String(base64Cluster);
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
buffer = null;
}
return(buffer);
}
//读取Blob数据
public Object ReadBlob(String photoName)
{
if (CSTR.isEmpty(photoName))
{
return(null);
}
String sql = String.Format("Select * from JiaohaoPhoto where PhotoName='{0}'", photoName);
MySqlCommand command = new MySqlCommand(sql, getConn());
MySqlDataReader reader = command.ExecuteReader();
if (reader.Read())
{
MemoryStream buf = new MemoryStream((byte[])reader["PhotoData"]);
return(buf);
}
return(null);
}
//构建查询sql
private String generateQueryString(List <String> lstDJLSH)
{
if (CSTR.IsListEmpty(lstDJLSH))
{
return("");
}
//把list中的DJLSH拼接成'11','22'格式
String DJLSH_cluster = "";
foreach (String item in lstDJLSH)
{
if (CSTR.isEmpty(item))
{
continue;
}
if (DJLSH_cluster.Length > 0)
{
DJLSH_cluster += ",";
}
DJLSH_cluster += String.Format("'{0}'", item);
}
if (CSTR.isEmpty(DJLSH_cluster))
{
return("");
}
//生成查询语句
String sql = String.Format("select [patient].patient_his_id,[patient].name," +
"[study].study_state,[study].study_begin_time,[study].study_end_time " +
"from [patient],[order],[study] " +
"where [order].patient_id=[patient].id " +
"and [order].id=[study].order_id " +
"and [order].register_time>getdate()-1 " +
"and [patient].patient_his_id in ({0}) ", DJLSH_cluster);
return(sql);
}
public DataTable SpecialExam_Register_Query_Stusy(String id_cluster)
{
//只能用于天方达登记的附加项目查询
if (CSTR.isEmpty(id_cluster))
{
return(null);
}
String sql = String.Format(@"select
CONCAT('{0}',DATE_FORMAT(NOW(),'%H%i')) as TJBH,
'{3}' as XM,
'{4}' as XB,
'' as SFZH,
'' as p_PHONE,
'' as d_PHONE,
CONCAT('{0}',DATE_FORMAT(NOW(),'%H%i')) as DJLSH,
'0000' as DWBH,
'非天方达' as DWMC,
now() as TJRQ,
now() as jlb_JCRQ,
TJLB,
TJLBMC,
'01' as RYLB,
'SA' as RYLBMC,
CONCAT(DATE_FORMAT(NOW(),'%H%i'),ProcedureStepID) XH,
ExamType,
OrderProcedureName as ExamTypeMC,
CONCAT(TJLB,ProcedureStepID) as TJXMBH,
ProcedureStepName as TJXMMC,
ExamTip as TSXX,
RoomID as CheckRoom,
'0' as ISOVER
from JiaohaoSpecialExam
where -- TJLBMC='{1}' and
id in ({2})", this.rfid_no, "附加项目", id_cluster, "p_name", "男");
return(new ExamQueue().getDB().query(sql));
}
public bool register()
{
if (CSTR.isEmpty(m_djlsh))
{
return(false);
}
if (CSTR.isEmpty(m_exam_type))
{
m_exam_type = "体检中心";
}
String webAPI_link = String.Format("http://192.168.3.206/api/webapi/tjRegister?tjh={0}&local={1}", m_djlsh, m_exam_type);
HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(webAPI_link);
request.Method = "GET";
using (WebResponse response = request.GetResponse())
{
String txt = response.GetResponseStream().ToString();
}
return(false);
}
private void Non_ActiveExam_Check()
{
//如果没有主动设置Handler_Name,则不用执行
if (CSTR.isEmpty(DatabaseCache.Tocken_Handler_Name_for_StoreProcedure))
{
return;
}
//1.获取Tocken
int tocken = queue.getDB().Call_SP_Token(DatabaseCache.Tocken_Handler_Name_for_StoreProcedure);
if (1 != tocken)
{
//System.Windows.Forms.MessageBox.Show("Tocken is not available.");
return;
}
//2.检测
Non_ActiveExam_opt.Check();
//执行数据库例行程序
//System.Windows.Forms.MessageBox.Show("Tocken Fetched.");
}
/// <summary>
/// 同类型房间重复出现时,只选择唯一的一个,避免重复
/// </summary>
/// <param name="listRound_3"></param>
/// <returns></returns>
private List <String> parse_5_Round_RoomType_Uniqueness_Handle(List <String> listRound_3)
{
//[RoomID]:register_table.CheckRoom
//注: 不生成新的返回List,而是对listRound_3进行修改后返回
//保证listRound_3中的每一项都不为空,而且只有一个房间
for (int i = 0; i < listRound_3.Count; i++)
{
String roomID = listRound_3[i];
String[] room_arr = CSTR.splitRooms(roomID);
//确保不为空
if (CSTR.isEmpty(roomID) || CSTR.splitRoomsCount(room_arr) <= 0)
{
listRound_3[i] = VALID_ROOM_ID;
continue;
}
//确保只有一个房间
if (room_arr.Length > 1)
{
//超过一个房间,则取第一个
listRound_3[i] = room_arr[0];
}
}
//同类房间如果有重复,需要从中选择唯一的一个房间
List <String> listSameType_RoomCluster = new List <string>();
listSameType_RoomCluster.Add("[302][303][304][305][405]");
listSameType_RoomCluster.Add("[306][307][401][402][403][404]");
listSameType_RoomCluster.Add("[309][311]");
listSameType_RoomCluster.Add("[308][312][313]");
listSameType_RoomCluster.Add("[324][325][326]");
listSameType_RoomCluster.Add("[322][406]");
//保存listRound_3中的同类房间
List <String> listExistRooms = new List <string>();
for (int i = 0; i < listSameType_RoomCluster.Count; i++)
{
listExistRooms.Add("");
}
//获取listRound_3中的同类房间串
foreach (String roomID in listRound_3)
{
for (int i = 0; i < listSameType_RoomCluster.Count; i++)
{
String room_cluster_full = listSameType_RoomCluster[i];
if (room_cluster_full.IndexOf(roomID) >= 0)
{
//读取目前保存的同类房间串
String room_exist = listExistRooms[i];
//先清除,再添加,不会重复出现同一个RoomID
room_exist = room_exist.Replace(roomID, "");
room_exist += roomID;
//重新保存
listExistRooms[i] = room_exist;
}
} //end for
} //end foreach
//判断是否重复
for (int i = 0; i < listExistRooms.Count; i++)
{
String rooms_id = listExistRooms[i];
String[] room_arr = CSTR.splitRooms(rooms_id);
if (CSTR.splitRoomsCount(room_arr) <= 1)
{
continue;
}
//两个或以上同类房间,出现重复
String strSel = "";
//获取未关闭的房间
String strActive = get_active_RoomID_Cluster(rooms_id);
String[] arr_active = CSTR.splitRooms(strActive);
if (CSTR.isEmpty(strActive) || CSTR.splitRoomsCount(arr_active) <= 0)
{
//如果重复房间都关闭,则直接选择第一个
strSel = room_arr[0];
}
else
{
//选择已开启房间的第一个
strSel = arr_active[0];
}
//更新到listRound_3
for (int i_round_3 = 0; i_round_3 < listRound_3.Count; i_round_3++)
{
String room_round_3 = listRound_3[i_round_3];
if (rooms_id.IndexOf(room_round_3) >= 0)
{
if (false == CSTR.isEmpty(strSel))
{
//更新,去除多个重复同类房间,修改为唯一的一个
listRound_3[i_round_3] = strSel;
}
}
}
}//end for
return(listRound_3);
}
/// <summary>
/// 对同一个EXAM的多个房间,选择返回一个(活动房间)(未完成检查数最少的房间)
/// </summary>
/// <param name="listRound_2"></param>
/// <returns></returns>
private List <String> parse_4_Round_Recommanded_Room_Handle(List <String> listRound_2)
{
//[RoomID]:register_table.CheckRoom
//逐一处理每个检查的房间串,并处理返回结果
List <String> roomList = new List <string>();
int nCount = register_table.Rows.Count;
for (int i = 0; i < nCount; i++)
{
//注: 由于Round_1_2保证了数据的完整性,在Round3无需进行CSTR.isEmpty的处理了
String rooms_id_origin = "";
String rooms_id_round_2 = "";
try
{
rooms_id_origin = CSTR.ObjectTrim(register_table.Rows[i]["CheckRoom"]);
rooms_id_round_2 = listRound_2[i];
//如果只有一个房间,直接写回原串
String[] rooms_arr_round_2 = CSTR.splitRooms(rooms_id_round_2);
if (rooms_arr_round_2.Length <= 1)
{
roomList.Add(rooms_id_round_2);
continue;
}
//[规则] 同一EXAM的多个房间,需要根据排队的未完成检查数来选择其中一个数目较少的
int min_count = 9999;
String min_room_id = rooms_arr_round_2[0];
foreach (String roomID in rooms_arr_round_2)
{
if (CSTR.isEmpty(roomID))
{
continue;
}
int queue_count = DatabaseCache.Queue_Length_Count_Specified_Room_Ignore_QueueActive(roomID);
if (queue_count < min_count)
{
//更新min_count到本房间
min_count = queue_count;
min_room_id = roomID;
}
}
//如果选择失败,则不予登记
if (CSTR.isEmpty(min_room_id))
{
min_room_id = VALID_ROOM_ID;
}
roomList.Add(min_room_id);
}
catch
{
//如果还出错,直接写回Round1的串
String strSel = rooms_id_round_2;
if (CSTR.isEmpty(rooms_id_round_2))
{
strSel = rooms_id_origin;
}
//如果多个房间,简单选择第一个
String[] room_arr = CSTR.splitRooms(strSel);
if (null == room_arr || room_arr.Length <= 0)
{
strSel = VALID_ROOM_ID;
}
else
{
strSel = room_arr[0];
}
roomList.Add(strSel);
}
}//end for
return(roomList);
}
/// <summary>
/// 处理[306][307]职检->[307](取消职检到[307])) : [309][311]女->[311]
/// 此轮的返回结果可以作为多个房间的备选(保存到JiaohaoTable.OptionRooms字段)
/// </summary>
/// <param name="listRound_1">第一轮的处理结果</param>
/// <returns></returns>
private List <String> parse_2_Round_Other_Room_Handle(List <String> listRound_1)
{
//[RoomID]:register_table.CheckRoom
//逐一处理每个检查的房间串,并处理返回结果
List <String> roomList = new List <string>();
int nCount = register_table.Rows.Count;
for (int i = 0; i < nCount; i++)
{
//注: 由于Round_1保证了数据的完整性,在Round2无需进行CSTR.isEmpty的处理了
String rooms_id_origin = "";
String rooms_id_round_1 = "";
try
{
rooms_id_origin = CSTR.ObjectTrim(register_table.Rows[i]["CheckRoom"]);
rooms_id_round_1 = listRound_1[i];
//0:女 1:男 %:未知
String PatientGender = CSTR.ObjectTrim(register_table.Rows[i]["XB"]);
if (PatientGender.Equals("0"))
{
PatientGender = "女";
}
else
{
PatientGender = "男";
}
//获取round_1的房间类型
String[] rooms_arr_round_1 = CSTR.splitRooms(rooms_id_round_1);
bool has_UltraSound = false;
bool has_309 = false;
bool has_311 = false;
foreach (String roomID in rooms_arr_round_1)
{
if ("[306][307][401][402][403][404]".IndexOf(roomID) >= 0)
{
has_UltraSound = true;
}
if (roomID.Equals("[309]"))
{
has_309 = true;
}
if (roomID.Equals("[311]"))
{
has_311 = true;
}
}
//[规则] 对于[309][311]的房间,男的选[309],女的选[311]
if (has_309 && has_311)
{
String strSel = rooms_id_round_1;
if (PatientGender.Equals("女"))
{
strSel = "[311]";
}
else
{
strSel = strSel.Replace("[311]", "");//去掉[311]房间
//如果为空则恢复原有串
if (CSTR.isEmpty(strSel))
{
strSel = rooms_id_round_1;
}
}
roomList.Add(strSel);
continue;
}
else if (has_UltraSound)
{
//[规则] (取消)职检的B超检查默认选[307],,经阴道检查[403]
String strSel = rooms_id_round_1;
//解决心电错误分配到[307]的问题
//if (STUDY_is_vacation_exam)
//{
// strSel = "[307]";
//}
roomList.Add(strSel);
continue;
}
else
{
//其他不无需处理的RoomID,直接写回原有的房间串
roomList.Add(rooms_id_round_1);
}
}
catch
{
//如果还出错,直接写回Round1的串
String strSel = rooms_id_round_1;
if (CSTR.isEmpty(rooms_id_round_1))
{
strSel = rooms_id_origin;
}
roomList.Add(strSel);
}
}//end for
return(roomList);
}
/// <summary>
/// parse_1_Round_Ending_Room_Handle
/// 处理[308]~[313]的房间
/// 根据职检与否来更改房间指向
/// 保证检查有效性和房间号不为空
/// </summary>
/// <returns>返回修改了相关总检房间的列表,如[309][311]保存为list[2]='[308][312][313]'</returns>
private List <String> parse_1_Round_Ending_Room_Handle()
{
//[RoomID]:register_table.CheckRoom
//获取各类总检房间的开启情况
String active_endingRoomCluster_full = get_active_RoomID_Cluster(endingRoomCluster_full);
String active_endingRoomCluster_normal = get_active_RoomID_Cluster(endingRoomCluster_normal);
String active_endingRoomCluster_vocation = get_active_RoomID_Cluster(endingRoomCluster_vocation);
bool is_all_room_closed = CSTR.isEmpty(active_endingRoomCluster_full);
bool is_all_normal_room_closed = CSTR.isEmpty(active_endingRoomCluster_normal);
bool is_all_vocation_room_closed = CSTR.isEmpty(active_endingRoomCluster_vocation);
//逐一处理每个检查的房间串,并处理返回结果
List <String> roomList = new List <string>();
foreach (DataRow row in register_table.Rows)
{
//[规则]检查类型和项目编号等四个关键字段为空则不予登记
String OrderProcedureName = CSTR.ObjectTrim(row["ExamTypeMC"]);
String ProcedureStepID = CSTR.ObjectTrim(row["TJXMBH"]);
String ProcedureStepName = CSTR.ObjectTrim(row["TJXMMC"]);
String ExamType = CSTR.ObjectTrim(row["ExamType"]);
if (CSTR.isEmpty(ExamType) || CSTR.isEmpty(OrderProcedureName) ||
CSTR.isEmpty(ProcedureStepID) || CSTR.isEmpty(ProcedureStepName))
{
roomList.Add(VALID_ROOM_ID);
continue;
}
//[规则]对于没有CheckRoom的记录,属于体检系统新增记录,房间并入[other]系列
String rooms_id = CSTR.ObjectTrim(row["CheckRoom"]);
String[] room_arr = CSTR.splitRooms(rooms_id);
if (null == room_arr || room_arr.Length <= 0)
{
roomList.Add("[other]");
continue;
}
//判断此exam的房间串是否属于endingRoom中的一个
bool is_belong_endingRoom = false; //总检房(总)
bool is_belong_normal_endingRoom = false; //个检总检
bool is_belong_vocation_endingRoom = false; //职检总检
foreach (String roomID in room_arr)
{
if (endingRoomCluster_full.IndexOf(roomID) >= 0)
{
is_belong_endingRoom = true;
}
if (endingRoomCluster_normal.IndexOf(roomID) >= 0)
{
is_belong_normal_endingRoom = true;
}
if (endingRoomCluster_vocation.IndexOf(roomID) >= 0)
{
is_belong_vocation_endingRoom = true;
}
}
//如果不属于总检房间类型,写回原房间串,直接处理下一个exam
if (false == is_belong_endingRoom)
{
roomList.Add(rooms_id);
continue;
}
//----------------------------总检房间类型的处理---------------------
//[规则]全部总检房间都关闭时,个检选择[311],职检选择[313]
if (is_all_room_closed)
{
String strSel = "[311]";
if (STUDY_is_vacation_exam)
{
strSel = "[313]";
}
roomList.Add(strSel);
continue;
}
//[规则]如果有独立的[311]或[310]房间的总检房间,直接映射为[311](包括职检)
if (STUDY_has_311_or_310_alone)
{
//注意:本循环中的rooms_id并非一定为[310]或[311],甚至可能为[312][313]
if (DatabaseCache.RoomInfo_is_active("[311]"))
{
//如果311房间active,直接选择
roomList.Add("[311]");
continue;
}
}
//[规则]如果Study中有职检EndingRoom,或者存在职检的项目,直接映射到[308][312][313],否则映射到[309][311]
if (STUDY_has_312_313_room || STUDY_is_vacation_exam)
{
//如果当前exam的rooms_id属于[312][313]则直接写回原串,否则强制写入[312][313]
if (is_belong_vocation_endingRoom)
{
roomList.Add(rooms_id);
continue;
}
else
{
roomList.Add("[308][312][313]");
continue;
}
}
//其他的个检总检房间,写入原串中的active房间
//(当前条件:1.非职检 2.职检与个检必有一个是有未关闭房间
String strActive = get_active_RoomID_Cluster(rooms_id);
String strSelect = strActive;
if (CSTR.isEmpty(strActive))
{
if (false == is_all_normal_room_closed)
{
strSelect = active_endingRoomCluster_normal;
}
else
{
strSelect = active_endingRoomCluster_vocation;
}
}
roomList.Add(strSelect);
}//end foreach
return(roomList);
}
/// <summary>
/// check_us_exam_status()
/// 用于查找超声系统中,指定的DJLSH的体检检查的完成状态
/// </summary>
/// <param name="lstDJLSH">需要查询的DJLSH列表</param>
/// <returns>map('DJLSH',true/false) true表示已经完成,false表示不存在或未完成</returns>
private Dictionary <String, bool> check_us_exam_status()
{
try
{
//获取[超声科]房间的未完成检查列表
List <String> lstDJLSH = getUltrasoundExamList();
if (CSTR.IsListEmpty(lstDJLSH))
{
return(null);
}
//生成检查状态sql语句
String sql = generateQueryString(lstDJLSH);
if (CSTR.isEmpty(sql))
{
return(null);
}
//执行查询
SqlServerOperator us_db = new SqlServerOperator(true);
DataTable tbl = us_db.query(sql);
if (CSTR.IsTableEmpty(tbl))
{
return(null);
}
//构建返回map
Dictionary <String, bool> map = new Dictionary <string, bool>();
foreach (DataRow row in tbl.Rows)
{
//获取DJLSH
String DJLSH = CSTR.ObjectTrim(row["patient_his_id"]);
bool is_over = CSTR.ObjectTrim(row["study_state"]).Equals("已登记") ? false : true;
if (CSTR.isEmpty(DJLSH))
{
continue;
}
//在map.key中查找是否存在,如果没有则添加
bool is_key_exist = false;
foreach (String key in map.Keys)
{
if (DJLSH.Equals(key))
{
is_key_exist = true;
}
}
if (is_key_exist)
{
//多个相同DJLSH只要有一个已完成就OK
bool is_over_exist = map[DJLSH];
if (false == is_over_exist && true == is_over)
{
map[DJLSH] = true;
}
}
else
{
//new,加入到map
map[DJLSH] = is_over;
}
}
return(map);
}
catch (Exception exp)
{
System.Console.WriteLine(exp.Message);
}
//出错返回null值
return(null);
}
//影响行数 -1:表示执行错误(事务支持)
public int update_use_Transaction(List <String> sql_list)
{
int nCount = -1;
if (null == sql_list)
{
return(-1);
}
if (sql_list.Count <= 0)
{
return(-1);
}
try
{
//获取Connection
MySqlConnection connection = getConn();
if (null == connection)
{
return(-1);
}
//生成事务
MySqlTransaction trans = connection.BeginTransaction();
//建立命令
MySqlCommand cmd = connection.CreateCommand();
//指定命令事务
cmd.Transaction = trans;
try
{
foreach (String sql in sql_list)
{
if (CSTR.isEmpty(sql))
{
continue;
}
cmd.CommandText = sql;
//执行update,并返回"影响行数"
int n = cmd.ExecuteNonQuery();
}
//Commit(事务提交)
trans.Commit();
nCount = sql_list.Count;
}
catch (Exception exp_cmd)
{
try
{
//Rollback(事务回滚)
trans.Rollback();
}
catch
{
}
Console.WriteLine(exp_cmd.Message);
conn = null;
nCount = -1;
}
}
catch (Exception exp)
{
//Log出现的错误
Console.WriteLine(exp.Message);
Log.log("[mysql.update()] " + exp.Message);
conn = null;
nCount = -1;
}
return(nCount);
}
//登记成功,返回NEW_DJLSH,登记失败,返回null;
public String register()
{
String str_ret_DJLSH = null;
if (CSTR.IsTableEmpty(register_table))
{
return(null);
}
if (CSTR.isEmpty(rfid_no))
{
return(null);
}
if (CSTR.isEmpty(ring_no))
{
return(null);
}
ExamQueue queue = new ExamQueue();
try
{
//生成每个检查的检查房间-------------------------------------------------------------------------
List <String> reg_list_RoomID = parse_and_allot_RoomID_for_STUDY();
if (null == reg_list_RoomID)
{
return(null);
}
if (reg_list_RoomID.Count <= 0)
{
return(null);
}
//生成每个检查的检查房间-------------------------------------------------------------------------
//通用数据以第一条记录为准------------------------------------------------------------------------
DataRow rowFirst = register_table.Rows[0];
//PatientInfo级别的信息(同一使用第一行的数据)
String PatientNameChinese = CSTR.ObjectTrim(rowFirst["XM"]);
String PatientGender = CSTR.ObjectTrim(rowFirst["XB"]);
if (PatientGender.Equals("0"))
{
PatientGender = "女";
}
else
{
PatientGender = "男"; //0:女 1:男 %:未知
}
String SFZH = CSTR.ObjectTrim(rowFirst["SFZH"]); //身份证号
String Phone = (CSTR.ObjectTrim(rowFirst["p_Phone"]).Length > //两个电话取长度长的那个
CSTR.ObjectTrim(rowFirst["d_Phone"]).Length) ?
CSTR.ObjectTrim(rowFirst["p_Phone"]) : CSTR.ObjectTrim(rowFirst["d_Phone"]);
String PatientIntraID = CSTR.ObjectTrim(rowFirst["TJBH"]);
String DJLSH = CSTR.ObjectTrim(rowFirst["DJLSH"]);
String TJLB = CSTR.ObjectTrim(rowFirst["TJLB"]);
String TJLBMC = CSTR.ObjectTrim(rowFirst["TJLBMC"]);
String DWBH = CSTR.ObjectTrim(rowFirst["DWBH"]);
String DWMC = CSTR.ObjectTrim(rowFirst["DWMC"]);
String ExamAccessionID = this.ring_no;//用于显示序号
//获取激活时间
DateTime arrivalTime = DateTime.Now;
String strArrivalTime = arrivalTime.ToString("HH:mm:ss"); //只取得时间部分,用以生成QueueID
String strArrivalDateTime = arrivalTime.ToString("yyyyMMdd HH:mm:ss"); //取得日期及时间(格式化时间)
//生成QueueID
String QueueID = String.Format("time_to_sec('{0}')", strArrivalTime);
String ExamArrivalDateTime = "NOW()";
//生成检查来源(类别)
String PreExamFrom = "个检";//体检来源(类别)
if (STUDY_is_vacation_exam)
{
PreExamFrom = "职检";
}
//PatientInfo级别的信息同一使用第一行的数据为准----------------------------------------------------
//生成每一个Exam的JiaohaoTable和JiaohaoExamInfo的Insert的Sql语句
List <String> reg_list_sql_JiaohaoTable = new List <string>();
List <String> reg_list_sql_JiaohaoExamInfo = new List <string>();
String reg_str_RoomID_registed_cluster = "";//记录已经登记了的RoomID列表
for (int i = 0; i < register_table.Rows.Count; i++)
{
//取得行数据
DataRow row = register_table.Rows[i];
//ExamInfo级别的数据,每个Row会有不同---------------------------------
String ModalityID = CSTR.ObjectTrim(row["CheckRoom"]);
String OrderProcedureName = CSTR.ObjectTrim(row["ExamTypeMC"]);
String ProcedureStepID = CSTR.ObjectTrim(row["TJXMBH"]);
String ProcedureStepName = CSTR.ObjectTrim(row["TJXMMC"]);
String ExamType = CSTR.ObjectTrim(row["ExamType"]);
String ReorderReason = "";// CSTR.ObjectTrim(row["TSXX"]);//提示信息
//ExamInfo级别的数据,每个Row会有不同---------------------------------
//获取RoomID
String RoomID = reg_list_RoomID[i];
if (CSTR.isEmpty(RoomID) || RoomID.Equals(VALID_ROOM_ID))
{
//如果是无效房间,则生成空的SQL语句
reg_list_sql_JiaohaoExamInfo.Add("");
reg_list_sql_JiaohaoTable.Add("");
//处理下一个
continue;
}
//有了唯一的RoomID后,定义OrderID,用于同一房间检查的详细信息查询
String OrderID = CSTR.trim(DJLSH + RoomID);
//ExamID也要写入到JiaohaoExamInfo,用于和IndexID的对应,需要保证每个Exam不同
String ExamID = String.Format("{0}.{1}.{2}", OrderID, ProcedureStepID, i.ToString());
//合并相同房间的RoomID字段和检查方法字段,保存到JiaohaoTable.ArrayRoomID和JiaohaoTable.ArrayProcedureStepName
String ArrayRoomID = "";
String ArrayProcedureStepName = "";
for (int reg_point = 0; reg_point < reg_list_RoomID.Count; reg_point++)
{
String reg_room_id = reg_list_RoomID[reg_point];
if (RoomID.Equals(reg_room_id))
{
String roomid_for_arr = CSTR.ObjectTrim(register_table.Rows[reg_point]["CheckRoom"]);
String procedureName_for_arr = CSTR.ObjectTrim(register_table.Rows[reg_point]["TJXMMC"]);
//去掉敏感字符';'
roomid_for_arr = roomid_for_arr.Replace(";", "");
procedureName_for_arr = procedureName_for_arr.Replace(";", "");
//加入到Array字段
if (ArrayRoomID.Length > 0)
{
ArrayRoomID += ";";
}
ArrayRoomID += roomid_for_arr;
if (ArrayProcedureStepName.Length > 0)
{
ArrayProcedureStepName += ";";
}
ArrayProcedureStepName += procedureName_for_arr;
}
}
//检查状态的确定
String ExamSatus = "2"; //默认为未检
String status = "0"; //默认为未检
String IsOver = "0"; //默认为未检
String IsNeedQueue = "1"; //默认需要排队
String IsNeedVoice = "1"; //默认需要TTS语音
//对roomID,查询房间的三个状态 active/needQueue/needVoice
bool bActive = DatabaseCache.RoomInfo_is_active(RoomID);
bool bNeedQueue = DatabaseCache.RoomInfo_is_need_queue(RoomID);
bool bNeedVoice = DatabaseCache.RoomInfo_is_need_voice(RoomID);
//只有NeedQueue为false才无需排队,不论房间是否active或disactive
if (bNeedQueue == false)
{
ExamSatus = "3";
status = "1";
IsOver = "1";
IsNeedQueue = "0";
IsNeedVoice = "0";
}
else
{
ExamSatus = "2";
status = "0";
IsOver = "0";
IsNeedQueue = "1";
if (bNeedVoice)
{
IsNeedVoice = "1";
}
else
{
IsNeedVoice = "0";
}
}
//生成插入到JiaohaoTable的语句
String sql_JiaohaoTable = String.Format("insert into JiaohaoTable " +
" (QueueID,PatientNameChinese,PatientGender," +//1
"SFZH,Phone,PatientIntraID," +
"DJLSH,Rfid,RfidName," +//2
"TJLB,TJLBMC,DWBH," +
"DWMC,ExamID,OrderID," +//3
"ExamAccessionID,ExamArrivalDateTime,ModalityID," +
"OrderProcedureName,ProcedureStepID,ProcedureStepName," +//4
"ExamType,RoomID,ReorderReason," +
"PreExamFrom,ExamSatus,status," +//5
"IsOver,IsNeedQueue,IsNeedVoice," +
"ArrayRoomID,ArrayProcedureStepName) VALUES " +
" ({0},'{1}','{2}'," +//1
" '{3}','{4}','{5}'," +
" '{6}','{7}','{8}'," +//2
" '{9}','{10}','{11}'," +
" '{12}','{13}','{14}'," +//3
" '{15}',{16},'{17}'," +
" '{18}','{19}','{20}'," +//4
" '{21}','{22}','{23}'," +
"'{24}',{25},{26}," +//5
"{27},{28},{29}," +
"'{30}','{31}')",
QueueID, PatientNameChinese, PatientGender,//1
SFZH, Phone, PatientIntraID,
DJLSH, this.rfid_no, this.ring_no,//2
TJLB, TJLBMC, DWBH,
DWMC, ExamID, OrderID,//3
ExamAccessionID, ExamArrivalDateTime, ModalityID,
OrderProcedureName, ProcedureStepID, ProcedureStepName,//4
ExamType, RoomID, ReorderReason,
PreExamFrom, ExamSatus, status,//5
IsOver, IsNeedQueue, IsNeedVoice,
ArrayRoomID, ArrayProcedureStepName
);
//生成插入到JiaohaoExamInfo的语句
String sql_JiaohaoExamInfo = String.Format("insert into JiaohaoExamInfo " +
" (ExamID,OrderID,RoomID,CheckRoom," +
"ProcedureStepID,ProcedureStepName,ExamType,RfidName) VALUES " +
" ('{0}','{1}','{2}','{3}'," +
"'{4}','{5}','{6}','{7}')",
ExamID, OrderID, RoomID, ModalityID,
ProcedureStepID, ProcedureStepName, ExamType, this.ring_no);
//对于相同的RoomID,在JiaohaoTable中只能写入一次
if (reg_str_RoomID_registed_cluster.IndexOf(RoomID) >= 0)
{
//如果此Exam的RoomID已经登记了,则不再写入相同的JiaohaoTable记录
sql_JiaohaoTable = "";
}
else
{
//记录本次的RoomID到已完成房间串
reg_str_RoomID_registed_cluster += RoomID;
}
//保存SQL语句
reg_list_sql_JiaohaoTable.Add(sql_JiaohaoTable);
reg_list_sql_JiaohaoExamInfo.Add(sql_JiaohaoExamInfo);
}//end for (int i = 0; i < register_table.Rows.Count; i++)
//重置返回值
str_ret_DJLSH = null;
//逐条写入数据库
int nCount = queue.getDB().update_use_Transaction(reg_list_sql_JiaohaoTable);
if (nCount > 0)
{
//不再插入检查到JiaohaoExamInfo
//int nCount2 = queue.getDB().update_use_Transaction(reg_list_sql_JiaohaoExamInfo);
str_ret_DJLSH = DJLSH;//设置返回值
}
}
catch (Exception exp)
{
str_ret_DJLSH = null;
}
return(str_ret_DJLSH);
}
/**
* 获取所有的检查项目(ExamInfo关联)
* 使用:
* FinalCheckWnd.cs在显示检查列表时调用
*
* **/
public static DataTable ExamInfo_get_All_Items_by_RingNo(String ringNo)
{
DataTable tblRet = null;
ringNo = CSTR.trim(ringNo);
if (ringNo.Length <= 0)
{
return(null);
}
//获取JiaohaoTable表
DataTable cache_tbl = DB_Get_JiaohaoTable_table();
if (CSTR.IsTableEmpty(cache_tbl))
{
return(null);
}
//查询符合条件的行集合(排序优先级别"QueueActive DESC,IsOver"
DataRow[] JiaohaoTable_row_result =
cache_tbl.Select(String.Format("RfidName='{0}'", ringNo), "IsOver,QueueActive DESC,IsNeedQueue");
if (CSTR.IsArrayEmpty(JiaohaoTable_row_result))
{
return(null);
}
//构建返回表
tblRet = new DataTable();
tblRet = cache_tbl.Clone();//克隆表结构,但无数据
foreach (DataRow row_JiaohaoTable in JiaohaoTable_row_result)
{
//Split本检查的ArrayProcedureStepName,并逐条添加到返回表
String ArrayProcedureStepName = CSTR.ObjectTrim(row_JiaohaoTable["ArrayProcedureStepName"]);
if (CSTR.isEmpty(ArrayProcedureStepName))
{
//如果ArrayProcedureStepName无内容,直接Copy本条记录到返回表
DataRow newRow = Row_Copy(row_JiaohaoTable, tblRet);
tblRet.Rows.Add(newRow);
continue;
}
String[] procedureName_arr = ArrayProcedureStepName.Split(';');
if (null == procedureName_arr || procedureName_arr.Length <= 1)
{
//如果检查Item数量少于2个,直接Copy本条记录到返回表
DataRow newRow = Row_Copy(row_JiaohaoTable, tblRet);
tblRet.Rows.Add(newRow);
continue;
}
foreach (String procedureName in procedureName_arr)
{
//把每个ProcedureStepName的数据Copy到新的行newRow
DataRow newRow = Row_Copy(row_JiaohaoTable, tblRet);
if (null != newRow)
{
newRow["ProcedureStepName"] = procedureName;
tblRet.Rows.Add(newRow);
}
}
}//end foreach (DataRow row in JiaohaoTable_row_result)
return(tblRet);
}
