/// <summary>
/// 获取座位使用状态
/// </summary>
/// <param name="seatNo"></param>
/// <returns></returns>
public static EnterOutLogType GetSeatUsedState(string seatNo)
{
IWCFService.ISeatManageService seatService = new WcfServiceForSeatManage.SeatManageDateService();
bool error = false;
try
{
EnterOutLogInfo model = seatService.GetEnterOutLogInfoWithBookWaitBySeatNum(seatNo);
if (model != null)
{
SeatManage.EnumType.EnterOutLogType type = model.EnterOutState;
return(type);
}
else
{
List <BespeakLogInfo> bespeakLogs = seatService.GetBespeakLogInfoBySeatNo(seatNo, DateTime.Now);
if (bespeakLogs.Count > 0 && bespeakLogs[0].BsepeakState == SeatManage.EnumType.BookingStatus.Waiting)
{
return(EnterOutLogType.BespeakWaiting);
}
return(EnterOutLogType.None);
}
}
catch (Exception ex)
{
error = true;
SeatManageComm.WriteLog.Write("获取座位状态失败：" + ex.Message);
return(EnterOutLogType.None);
}
}
/// <summary>
/// 返回最后一条计时记录
/// </summary>
/// <param name="eol">进出记录</param>
private static EnterOutLogInfo GetLastNoSeatTimeLog(EnterOutLogInfo eol)
{
try
{
List <EnterOutLogType> eoltypeList = new List <EnterOutLogType>();
eoltypeList.Add(EnterOutLogType.BookingConfirmation);
eoltypeList.Add(EnterOutLogType.SelectSeat);
eoltypeList.Add(EnterOutLogType.ReselectSeat);
eoltypeList.Add(EnterOutLogType.WaitingSuccess);
eoltypeList.Add(EnterOutLogType.ContinuedTime);
List <EnterOutLogInfo> lasteol = T_SM_EnterOutLog.GetEnterOutLogByNo(eol.EnterOutLogNo, eoltypeList, 1);
if (lasteol.Count > 0)
{
return(lasteol[0]);
}
else
{
return(null);
}
}
catch (Exception ex)
{
WriteLog.Write(string.Format("监控服务：获取读者最后的续时记录发生错误：" + ex.Message));
return(null);
}
}
/// <summary>
/// 添加违规记录
/// </summary>
/// <param name="eol">进出记录</param>
/// <param name="type">违规类型</param>
/// <param name="note">提示信息</param>
private void AddViolationRecordByEnterOutLog(EnterOutLogInfo eol, ViolationRecordsType type, string note, ReadingRoomSetting roomSetting, DateTime nowDateTime)
{
try
{
if (roomSetting.BlackListSetting.Used && !roomSetting.BlackListSetting.ViolateRoule[type])
{
return;
}
if (!regulationRulesSetting.BlacklistSet.Used || !regulationRulesSetting.BlacklistSet.ViolateRoule[type])
{
return;
}
ViolationRecordsLogInfo vrli = new ViolationRecordsLogInfo();
vrli.CardNo = eol.CardNo;
vrli.SeatID = eol.SeatNo;
if (vrli.SeatID.Length > roomSetting.SeatNumAmount)
{
vrli.SeatID = vrli.SeatID.Substring(vrli.SeatID.Length - roomSetting.SeatNumAmount);
}
vrli.ReadingRoomID = eol.ReadingRoomNo;
vrli.EnterOutTime = nowDateTime.ToString();
vrli.EnterFlag = type;
vrli.Remark = note;
seatManageService.AddViolationRecordsLog(vrli);
WriteLog.Write(string.Format("监控服务：读者{0}，{1}，记录违规", vrli.CardNo, vrli.Remark));
}
catch (Exception ex)
{
WriteLog.Write(string.Format("监控服务：添加违规记录发生错误：" + ex.Message));
}
}
/// <summary>
/// 增加一条数据
/// </summary>
public int Add(EnterOutLogInfo model, ref int newLogId)
{
//TODO:不跟据阅览室状态添加进出记录
SqlParameter[] parameters = new SqlParameter[11];
parameters[0] = new SqlParameter("@ExcResult", SqlDbType.Int);
parameters[0].Direction = ParameterDirection.Output;
parameters[1] = new SqlParameter("@CardNo", model.CardNo);
parameters[2] = new SqlParameter("@EnterOutLogNo", model.EnterOutLogNo);
parameters[3] = new SqlParameter("@EnterOutState", (int)model.EnterOutState);
parameters[4] = new SqlParameter("@EnterOutTime", model.EnterOutTime);
parameters[5] = new SqlParameter("@EnterFlag", (int)model.Flag);
parameters[6] = new SqlParameter("@ReadingRoomNo", model.ReadingRoomNo);
parameters[7] = new SqlParameter("@Remark", model.Remark);
parameters[8] = new SqlParameter("@SeatNo", model.SeatNo);
parameters[9] = new SqlParameter("@TerminalNum", model.TerminalNum);
parameters[10] = new SqlParameter("RETURN_VALUE", SqlDbType.Int);
parameters[10].Direction = ParameterDirection.ReturnValue;
DbHelperSQL.Execute_Proc("Proc_AddNewEnterOutLog", parameters);
string id = parameters[10].Value.ToString();
if (!string.IsNullOrEmpty(id))
{
newLogId = int.Parse(id);
}
return((int)parameters[0].Value);
}
/// <summary>
/// 进出记录数据集行转换为实体对象
/// </summary>
/// <param name="dr"></param>
/// <returns></returns>
private EnterOutLogInfo DataRowToEnterOutLogBakInfo(DataRow dr)
{
EnterOutLogInfo model = new EnterOutLogInfo();
model.CardNo = dr["CardNo"].ToString();
model.EnterOutLogNo = dr["EnterOutLogNo"].ToString();
model.EnterOutTime = Convert.ToDateTime(dr["EnterOutTime"]);
model.Flag = (Operation)int.Parse(dr["EnterFlag"].ToString());
model.EnterOutType = (LogStatus)int.Parse(dr["EnterOutType"].ToString());
model.SeatNo = dr["SeatNo"].ToString();
model.EnterOutState = (EnterOutLogType)int.Parse(dr["EnterOutState"].ToString());
model.Remark = dr["Remark"].ToString();
string strtemp = dr["MarkTime"].ToString();
if (!string.IsNullOrEmpty(strtemp))
{
model.MarkTime = DateTime.Parse(strtemp);
}
else
{
model.MarkTime = DateTime.Parse("1900-1-1");
}
model.ReadingRoomNo = dr["ReadingRoomNo"].ToString();
model.EnterOutLogID = dr["EnterOutLogID"].ToString();
model.TerminalNum = dr["TerminalNum"].ToString();
model.TypeName = dr["ReaderTypeName"].ToString();
model.DeptName = dr["ReaderDeptName"].ToString();
model.Sex = dr["Sex"].ToString();
return(model);
}
/// <summary>
/// 等待座位
/// </summary>
/// <returns></returns>
public bool WaitSeat(SeatUC_ViewModel seatVM)
{
WaitSeatLogInfo lastWaitInfo = T_SM_SeatWaiting.GetListWaitLogByCardNo(ClientObject.EnterOutLogData.EnterOutlog.CardNo, ClientObject.EnterOutLogData.EnterOutlog.ReadingRoomNo);
ReadingRoomInfo roomInfo = ClientObject.EnterOutLogData.Student.AtReadingRoom;
if (!string.IsNullOrEmpty(ClientObject.EnterOutLogData.EnterOutlog.SeatNo))
{
PopupWindowsObject.GetInstance().Window.ShowMessage(TipType.WaitSeatWithSeat);
return(false);
}
if (lastWaitInfo != null && lastWaitInfo.SeatWaitTime.AddMinutes(roomInfo.Setting.NoManagement.OperatingInterval).CompareTo(ServiceDateTime.Now) >= 0)
{
PopupWindowsObject.GetInstance().Window.ShowMessage(TipType.WaitSeatFrequent);
return(false);
}
SeatLockState lockseat = T_SM_Seat.LockSeat(seatVM.LongSeatNo);
if (lockseat != SeatLockState.Locked) //座位成功加锁
{
PopupWindowsObject.GetInstance().Window.ShowMessage(TipType.SeatLocking);
return(false);
}
ClientObject.EnterOutLogData.WaitSeatLogModel = new WaitSeatLogInfo()
{
SeatNo = seatVM.ShortSeatNo
};
PopupWindowsObject.GetInstance().Window.ShowMessage(TipType.SetShortWarning);
ClientObject.EnterOutLogData.WaitSeatLogModel = null;
if (PopupWindowsObject.GetInstance().Window.ViewModel.OperateResule == HandleResult.Successed)
{
//初始化等待记录 记录ID需要待执行之后添加。
WaitSeatLogInfo waitInfo = new WaitSeatLogInfo();
waitInfo.CardNo = ClientObject.EnterOutLogData.EnterOutlog.CardNo;
waitInfo.NowState = LogStatus.Valid;
waitInfo.OperateType = Operation.Reader;
waitInfo.WaitingState = EnterOutLogType.Waiting;
EnterOutLogInfo seatUsingEnterOutInfo = T_SM_EnterOutLog.GetUsingEnterOutLogBySeatNo(seatVM.LongSeatNo);
seatUsingEnterOutInfo.EnterOutState = EnterOutLogType.ShortLeave;
seatUsingEnterOutInfo.EnterOutType = LogStatus.Valid;
seatUsingEnterOutInfo.Flag = Operation.OtherReader;
seatUsingEnterOutInfo.TerminalNum = ClientObject.ClientSetting.ClientNo;
seatUsingEnterOutInfo.Remark = string.Format("在{0} {1}号座位，被读者{2}在终端{3}设置为暂离并等待该座位", seatUsingEnterOutInfo.ReadingRoomName, seatUsingEnterOutInfo.ShortSeatNo, waitInfo.CardNo, ClientObject.ClientSetting.ClientNo);
ClientObject.EnterOutLogData.EnterOutlog = seatUsingEnterOutInfo; //要等待读者的暂离记录
ClientObject.EnterOutLogData.WaitSeatLogModel = waitInfo; //等待记录
ClientObject.EnterOutLogData.FlowControl = ClientOperation.WaitSeat;
return(true);
}
else
{
T_SM_Seat.UnLockSeat(seatVM.LongSeatNo);//确认窗口点击取消或者自动关闭，则解锁。
return(false);
}
}
/// <summary>
/// 暂离超时操作
/// </summary>
/// <param name="enterOutlog">进出记录</param>
/// <param name="roomset">阅览室设置</param>
private void ShortLeaveOverTimeOperator(EnterOutLogInfo enterOutlog, ReadingRoomSetting readingRoomSetting, DateTime nowDateTime)
{
try
{
string vrremark = "";
ViolationRecordsType vrtypt = ViolationRecordsType.ShortLeaveOutTime;
enterOutlog.EnterOutTime = nowDateTime;
enterOutlog.EnterOutState = EnterOutLogType.Leave;
switch (enterOutlog.Flag)
{//TODO:记录管理员信息
case Operation.Admin:
enterOutlog.Remark = string.Format("在{0}，{1}号座位，被管理员设置暂离，暂离超时，被监控服务释放座位", enterOutlog.ReadingRoomName, enterOutlog.SeatNo.Substring(enterOutlog.SeatNo.Length - readingRoomSetting.SeatNumAmount));
vrremark = string.Format("读者在{0}，{1}号座位，被管理员设置暂离，暂离超时", enterOutlog.ReadingRoomName, enterOutlog.SeatNo.Substring(enterOutlog.SeatNo.Length - readingRoomSetting.SeatNumAmount));
vrtypt = ViolationRecordsType.ShortLeaveByAdminOutTime;
break;
case Operation.OtherReader:
enterOutlog.Remark = string.Format("在{0}，{1}号座位，被其他读者设置暂离，暂离超时，被监控服务释放座位", enterOutlog.ReadingRoomName, enterOutlog.SeatNo.Substring(enterOutlog.SeatNo.Length - readingRoomSetting.SeatNumAmount));
vrremark = string.Format("读者在{0}，{1}号座位，被其他读者设置暂离，暂离超时", enterOutlog.ReadingRoomName, enterOutlog.SeatNo.Substring(enterOutlog.SeatNo.Length - readingRoomSetting.SeatNumAmount));
vrtypt = ViolationRecordsType.ShortLeaveByReaderOutTime;
break;
case Operation.Reader:
enterOutlog.Remark = string.Format("在{0}，{1}号座位，暂离超时，被监控服务释放座位", enterOutlog.ReadingRoomName, enterOutlog.SeatNo.Substring(enterOutlog.SeatNo.Length - readingRoomSetting.SeatNumAmount));
vrremark = string.Format("读者在{0}，{1}号座位，暂离超时", enterOutlog.ReadingRoomName, enterOutlog.SeatNo.Substring(enterOutlog.SeatNo.Length - readingRoomSetting.SeatNumAmount));
vrtypt = ViolationRecordsType.ShortLeaveOutTime;
break;
case Operation.Service:
enterOutlog.Remark = string.Format("在{0}，{1}号座位，在座超时，监控服务设置暂离，暂离超时，被监控服务释放座位", enterOutlog.ReadingRoomName, enterOutlog.SeatNo.Substring(enterOutlog.SeatNo.Length - readingRoomSetting.SeatNumAmount));
vrremark = string.Format("读者在{0}，{1}号座位，在座超时，监控服务设置暂离，暂离超时", enterOutlog.ReadingRoomName, enterOutlog.SeatNo.Substring(enterOutlog.SeatNo.Length - readingRoomSetting.SeatNumAmount));
vrtypt = ViolationRecordsType.SeatOutTime;
break;
default:
enterOutlog.Remark = string.Format("在{0}，{1}号座位，暂离超时，被监控服务释放座位", enterOutlog.ReadingRoomName, enterOutlog.SeatNo.Substring(enterOutlog.SeatNo.Length - readingRoomSetting.SeatNumAmount));
vrremark = string.Format("读者在{0}，{1}号座位，暂离超时", enterOutlog.ReadingRoomName, enterOutlog.SeatNo.Substring(enterOutlog.SeatNo.Length - readingRoomSetting.SeatNumAmount));
vrtypt = ViolationRecordsType.ShortLeaveOutTime;
break;
}
enterOutlog.Flag = Operation.Service;
int logid = 0;
seatManageService.AddEnterOutLogInfo(enterOutlog, ref logid);
WriteLog.Write(string.Format("读者{0}，{1}", enterOutlog.CardNo, enterOutlog.Remark));
if (readingRoomSetting.IsRecordViolate)
{
AddViolationRecordByEnterOutLog(enterOutlog, vrtypt, vrremark, readingRoomSetting, nowDateTime);
}
}
catch (Exception ex)
{
WriteLog.Write(string.Format("监控服务：处理读者暂离超时发生错误：" + ex.Message));
}
}
public string CancelWait(WaitSeatLogInfo waitInfo)
{
try
{
ReadingRoomInfo roomInfo;
List <ReadingRoomInfo> roomInfos = seatManage.GetReadingRooms(new List <string>()
{
waitInfo.ReadingRoomNo
}, null, null);
if (roomInfos.Count > 0)
{
roomInfo = roomInfos[0];
}
else
{
throw new Exception("获取信息失败!");
}
//处理等待记录的Id
waitInfo.OperateType = Operation.Reader;
waitInfo.WaitingState = EnterOutLogType.WaitingCancel;
waitInfo.NowState = LogStatus.Valid;
if (seatManage.UpdateWaitLog(waitInfo))
{ //恢复读者的在座状态
EnterOutLogInfo enterOutlog = seatManage.GetEnterOutLogInfoById(waitInfo.EnterOutLogID);
System.TimeSpan shortleavetimelong = DateTime.Now - enterOutlog.EnterOutTime;
enterOutlog.EnterOutState = EnterOutLogType.ComeBack;
enterOutlog.EnterOutType = LogStatus.Valid;
enterOutlog.Flag = Operation.OtherReader;
enterOutlog.Remark = string.Format("读者{0}在手机预约网站取消等待{1} {2}号座位，您暂离{3}分钟后恢复为在座状态",
waitInfo.CardNo,
enterOutlog.ReadingRoomName,
enterOutlog.ShortSeatNo,
shortleavetimelong.Minutes);
int newId = -1;
if (seatManage.AddEnterOutLogInfo(enterOutlog, ref newId) == HandleResult.Successed)
{
return("取消等待成功！");
}
else
{
return("操作失败！");
}
}
else
{
return("操作失败！");
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 获取座位使用状态
/// </summary>
/// <param name="seatNo"></param>
/// <returns></returns>
public static EnterOutLogType GetSeatUsedState(string seatNo)
{
IWCFService.ISeatManageService seatService = WcfAccessProxy.ServiceProxy.CreateChannelSeatManageService();
bool error = false;
try
{
EnterOutLogInfo model = seatService.GetEnterOutLogInfoWithBookWaitBySeatNum(seatNo);
if (model != null)
{
SeatManage.EnumType.EnterOutLogType type = model.EnterOutState;
return(type);
}
else
{
List <BespeakLogInfo> bespeakLogs = seatService.GetBespeakLogInfoBySeatNo(seatNo, DateTime.Now);
if (bespeakLogs.Count > 0 && bespeakLogs[0].BsepeakState == SeatManage.EnumType.BookingStatus.Waiting)
{
return(EnterOutLogType.BespeakWaiting);
}
return(EnterOutLogType.None);
}
}
catch (Exception ex)
{
error = true;
SeatManageComm.WriteLog.Write("获取座位状态失败：" + ex.Message);
return(EnterOutLogType.None);
}
finally
{
ICommunicationObject ICommObjectService = seatService as ICommunicationObject;
try
{
if (ICommObjectService.State == CommunicationState.Faulted)
{
ICommObjectService.Abort();
}
else
{
ICommObjectService.Close();
}
}
catch
{
ICommObjectService.Abort();
}
}
}
public List <Seat> GetOftenUsedSeatByCardNo(string cardNo, int days, List <string> roomNums)
{
List <ReadingRoomInfo> rooms = GetReadingRoomInfo(roomNums);
List <string> noList = rooms.FindAll(room => room.Setting.ReadingRoomOpenState(DateTime.Now) == ReadingRoomStatus.Open).Select(room => room.No).ToList();
DataSet ds = t_sm_seat.ReaderUsedSeat(cardNo, days, noList, GetServerDateTime());
List <Seat> seats = new List <Seat>();
for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
{
Seat s = new Seat();
s.SeatNo = ds.Tables[0].Rows[i]["SeatNo"].ToString();
s.ReadingRoomNum = ds.Tables[0].Rows[i]["ReadingRoomNo"].ToString();
//bool isstopUse = false;
ReadingRoomInfo r = rooms.Find(u => u.No == s.ReadingRoomNum && u.SeatList.Seats.ContainsKey(s.SeatNo) && !u.SeatList.Seats[s.SeatNo].IsSuspended && u.Setting.ReadingRoomOpenState(DateTime.Now) == ReadingRoomStatus.Open);
if (r == null)
{
continue;
}
else
{
s.ReadingRoom = r;
}
//foreach (ReadingRoomInfo r in rooms)
//{
// if (r.No == s.ReadingRoomNum && r.SeatList.Seats.ContainsKey(s.SeatNo) && r.SeatList.Seats[s.SeatNo].IsSuspended)
// {
// s.ReadingRoom = r;
// isstopUse = true;
// break;
// }
//}
//if (isstopUse)
//{
// continue;
//}
EnterOutLogInfo enterOutLog = GetEnterOutLogInfoBySeatNum(s.SeatNo);
if (enterOutLog == null || enterOutLog.EnterOutState == SeatManage.EnumType.EnterOutLogType.Leave)
{
seats.Add(s);
}
if (seats.Count >= 12)
{
break;
}
}
return(seats);
}
/// <summary>
/// 添加新的进出记录
/// </summary>
/// <param name="model"></param>
public static HandleResult AddEnterOutLog(EnterOutLogInfo model, ref int newLogId)
{
IWCFService.ISeatManageService seatService = new WcfServiceForSeatManage.SeatManageDateService();
bool error = false;
try
{
HandleResult result = seatService.AddEnterOutLogInfo(model, ref newLogId);
return(result);
}
catch (Exception ex)
{
error = true;
WriteLog.Write("添加进出记录遇到错误：" + ex.Message);
return(HandleResult.Failed);
}
}
/// <summary>
/// 座位等待处理
/// </summary>
/// <param name="readingRoom">阅览室</param>
/// <param name="enterOutLog">进出记录</param>
/// <param name="waitSeatLoglist">等待记录列表</param>
private void WaitSeatOperate(ReadingRoomInfo readingRoom, EnterOutLogInfo enterOutLog, List <WaitSeatLogInfo> waitSeatLoglist, DateTime nowDateTime)
{
try
{
waitSeatLoglist[0].WaitingState = EnterOutLogType.WaitingSuccess;
waitSeatLoglist[0].StatsChangeTime = nowDateTime;
seatManageService.UpdateWaitLog(waitSeatLoglist[0]);
ReaderNoticeInfo notice = new ReaderNoticeInfo();
//释放原读者座位
int logid = 0;
enterOutLog.Flag = Operation.Service;
enterOutLog.EnterOutState = EnterOutLogType.Leave;
enterOutLog.EnterOutTime = nowDateTime;
enterOutLog.Remark = string.Format("在{0}，{1}号座位，被其他读者设置暂离，暂离超时，被监控服务释放座位", enterOutLog.ReadingRoomName, enterOutLog.SeatNo.Substring(enterOutLog.SeatNo.Length - readingRoom.Setting.SeatNumAmount));
seatManageService.AddEnterOutLogInfo(enterOutLog, ref logid);
WriteLog.Write(string.Format("监控服务：读者{0}，{1}", enterOutLog.CardNo, enterOutLog.Remark));
//等待读者入座
EnterOutLogInfo new_eol = new EnterOutLogInfo();
new_eol.CardNo = waitSeatLoglist[0].CardNo;
new_eol.EnterOutLogNo = SeatComm.RndNum();
new_eol.EnterOutState = EnterOutLogType.WaitingSuccess;
new_eol.EnterOutType = LogStatus.Valid;
new_eol.ReadingRoomNo = waitSeatLoglist[0].ReadingRoomNo;
new_eol.Flag = Operation.Service;
new_eol.SeatNo = enterOutLog.SeatNo;
new_eol.Remark = string.Format("在{0}，{1}号座位，等待成功，自动入座", enterOutLog.ReadingRoomName, enterOutLog.SeatNo.Substring(enterOutLog.SeatNo.Length - readingRoom.Setting.SeatNumAmount));
seatManageService.AddEnterOutLogInfo(new_eol, ref logid);
WriteLog.Write(string.Format("监控服务：读者{0}，{1}", new_eol.CardNo, new_eol.Remark));
if (readingRoom.Setting.IsRecordViolate)
{
AddViolationRecordByEnterOutLog(enterOutLog, ViolationRecordsType.ShortLeaveByReaderOutTime, string.Format("读者在{0}，{1}号座位，被其他读者设置暂离，暂离超时", enterOutLog.ReadingRoomName, enterOutLog.SeatNo.Substring(enterOutLog.SeatNo.Length - readingRoom.Setting.SeatNumAmount)), readingRoom.Setting, nowDateTime);
}
}
catch (Exception ex)
{
WriteLog.Write(string.Format("监控服务：处理等待读者发生错误：" + ex.Message));
}
}
public List <EnterOutLogInfo> GetEnterOutBakLogsByLastID(int ID)
{
StringBuilder strWhere = new StringBuilder();
strWhere.AppendFormat(" EnterOutLogID>{0} order by EnterOutLogNo,EnterOutLogID", ID);
List <EnterOutLogInfo> list = new List <EnterOutLogInfo>();
try
{
DataSet ds = enteroutlog_bak_dal.GetList(strWhere.ToString(), null);
for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
{
EnterOutLogInfo enterOutLog = DataRowToEnterOutLogBakInfo(ds.Tables[0].Rows[i]);;
list.Add(enterOutLog);
}
return(list);
}
catch
{
throw;
}
}
public List <EnterOutLogInfo> GetEnterOutBakLogsByDate(DateTime date)
{
StringBuilder strWhere = new StringBuilder();
//strWhere.AppendFormat(" DATEDIFF(DAY,EnterOutTime,'{0}')=0 ", date);
strWhere.AppendFormat(" EnterOutTime>'{0} 0:00:00' and EnterOutTime<'{0} 23:59:59'", date.ToShortDateString());
List <EnterOutLogInfo> list = new List <EnterOutLogInfo>();
try
{
DataSet ds = enteroutlog_bak_dal.GetList(strWhere.ToString(), null);
for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
{
EnterOutLogInfo enterOutLog = DataRowToEnterOutLogBakInfo(ds.Tables[0].Rows[i]);;
list.Add(enterOutLog);
}
return(list);
}
catch
{
throw;
}
}
/// <summary>
/// 在座超时处理
/// </summary>
/// <param name="leavetype">处理类型</param>
/// <param name="eol">进出记录</param>
private static void SeatOverTimeOperator(ReadingRoomSetting roomSetting, EnterOutLogInfo eol, DateTime nowDateTime)
{
try
{
int logdi = 0;
//在座超时处理
switch (roomSetting.SeatUsedTimeLimit.OverTimeHandle)
{
case EnterOutLogType.Leave:
eol.EnterOutState = EnterOutLogType.Leave;
eol.EnterOutTime = nowDateTime;
eol.Flag = Operation.Service;
eol.Remark = string.Format("在{0}，{1}号座位，在座超时，监控服务释放座位", eol.ReadingRoomName, eol.SeatNo.Substring(eol.SeatNo.Length - roomSetting.SeatNumAmount));
EnterOutOperate.AddEnterOutLog(eol, ref logdi);
WriteLog.Write(string.Format("监控服务：读者{0}，{1}", eol.CardNo, eol.Remark));
//违规处理
if (roomSetting.IsRecordViolate)
{
AddViolationRecordByEnterOutLog(eol, ViolationRecordsType.SeatOutTime, string.Format("读者在{0}，{1}号座位，在座超时", eol.ReadingRoomName, eol.SeatNo.Substring(eol.SeatNo.Length - roomSetting.SeatNumAmount)), roomSetting, nowDateTime);
}
break;
case EnterOutLogType.ShortLeave:
eol.EnterOutState = EnterOutLogType.ShortLeave;
eol.EnterOutTime = nowDateTime;
eol.Flag = Operation.Service;
eol.Remark = string.Format("在{0}，{1}号座位，在座超时，监控服务设置暂离", eol.ReadingRoomName, eol.SeatNo.Substring(eol.SeatNo.Length - roomSetting.SeatNumAmount));
EnterOutOperate.AddEnterOutLog(eol, ref logdi);
WriteLog.Write(string.Format("监控服务：读者{0}，{1}", eol.CardNo, eol.Remark));
break;
}
}
catch (Exception ex)
{
WriteLog.Write(string.Format("监控服务：处理读者在座超时发生错误：" + ex.Message));
}
}
/// <summary>
/// 添加新的进出记录
/// </summary>
/// <param name="model"></param>
public static HandleResult AddEnterOutLog(EnterOutLogInfo model, ref int newLogId)
{
IWCFService.ISeatManageService seatService = WcfAccessProxy.ServiceProxy.CreateChannelSeatManageService();
bool error = false;
try
{
HandleResult result = seatService.AddEnterOutLogInfo(model, ref newLogId);
return(result);
}
catch (Exception ex)
{
error = true;
WriteLog.Write("添加进出记录遇到错误：" + ex.Message);
return(HandleResult.Failed);
}
finally
{
ICommunicationObject ICommObjectService = seatService as ICommunicationObject;
try
{
if (ICommObjectService.State == CommunicationState.Faulted)
{
ICommObjectService.Abort();
}
else
{
ICommObjectService.Close();
}
}
catch
{
ICommObjectService.Abort();
}
}
}
/// <summary>
/// 进出记录的消息
/// </summary>
/// <param name="log"></param>
/// <returns></returns>
private string EnterOutLogMessage(EnterOutLogInfo log)
{
ReadingRoomInfo room = null;
try
{
room = clientObject.ReadingRoomList[log.ReadingRoomNo];
}
catch
{
room = T_SM_ReadingRoom.GetSingleRoomInfo(log.ReadingRoomNo);
}
string strMessage = "";
if (room != null)
{
strMessage = string.Format("{0} {1}", log.EnterOutTime.ToLongTimeString(), log.Remark);
}
else
{
strMessage = string.Format("{0} {1}", log.EnterOutTime.ToLongTimeString(), log.Remark);
}
return(strMessage);
}
/// <summary>
/// 获取实时记录
/// 预约记录
///选座记录
///等待记录
///黑名单记录
/// </summary>
/// <param name="cardNum"></param>
/// <param name="getItemsParameter"></param>
/// <returns></returns>
public string GetReaderActualTimeRecord(string cardNum, string getItemsParameter)
{
try
{
if (string.IsNullOrEmpty(cardNum) || string.IsNullOrEmpty(getItemsParameter))
{
JM_HandleResult result = new JM_HandleResult();
result.Result = false;
result.Msg = "输入的数据数据不能为空!";
return(SeatManage.SeatManageComm.JSONSerializer.Serialize(result));
}
JsonModel.JM_ActualTimeRecordParam param = SeatManageComm.JSONSerializer.Deserialize <JsonModel.JM_ActualTimeRecordParam>(getItemsParameter);
JsonModel.JM_ActualTimeRecords records = new JsonModel.JM_ActualTimeRecords();
if (param.GetEnterOutLog)//获取进出记录
{
SeatManage.ClassModel.EnterOutLogInfo enterOutLog = seatDataService.GetEnterOutLogInfoByCardNo(cardNum);
JsonModel.JM_EnterOutLog jm_enterOutLog = null;
if (enterOutLog != null)
{
jm_enterOutLog = new JsonModel.JM_EnterOutLog();
jm_enterOutLog.EnterOutTime = enterOutLog.EnterOutTime.ToString("yyyy-MM-dd HH:mm:ss");
jm_enterOutLog.EnterOutState = enterOutLog.EnterOutState.ToString();
jm_enterOutLog.Id = enterOutLog.EnterOutLogID;
jm_enterOutLog.SeatId = enterOutLog.SeatNo;
jm_enterOutLog.SeatNum = enterOutLog.ShortSeatNo;
jm_enterOutLog.RoomName = enterOutLog.ReadingRoomName;
jm_enterOutLog.RoomNum = enterOutLog.ReadingRoomNo;
SeatManage.ClassModel.ReadingRoomInfo room = seatDataService.GetReadingRoomInfo(new List <string>()
{
enterOutLog.ReadingRoomNo
})[0];
if (enterOutLog.EnterOutState == EnterOutLogType.ShortLeave)
{
String seatInfo = enterOutLog.Remark;
double saveTimeLength = 0;
if (enterOutLog.Flag == Operation.Admin)
{
if (room.Setting.AdminShortLeave.IsUsed)
{
saveTimeLength = room.Setting.AdminShortLeave.HoldTimeLength;
}
else
{
saveTimeLength = SeatManage.ClassModel.ReadingRoomSetting.GetSeatHoldTime(room.Setting.SeatHoldTime, enterOutLog.EnterOutTime);
}
}
else
{
saveTimeLength = SeatManage.ClassModel.ReadingRoomSetting.GetSeatHoldTime(room.Setting.SeatHoldTime, enterOutLog.EnterOutTime);
}
string saveTime = enterOutLog.EnterOutTime.AddMinutes(saveTimeLength).ToShortTimeString();
jm_enterOutLog.Remark = string.Format("座位将为您保留至{2}。", enterOutLog.ReadingRoomName, enterOutLog.ShortSeatNo, saveTime);
}
else
{
switch (enterOutLog.EnterOutState)
{
case EnterOutLogType.BookingConfirmation:
case EnterOutLogType.SelectSeat:
case EnterOutLogType.ContinuedTime:
case EnterOutLogType.ComeBack:
case EnterOutLogType.ReselectSeat:
case EnterOutLogType.WaitingSuccess:
List <SeatManage.ClassModel.BespeakLogInfo> bespeaklist = seatDataService.GetBespeakLogInfoBySeatNo(enterOutLog.SeatNo, DateTime.Now);
DateTime dt = new DateTime();
if (bespeaklist.Count > 0)
{
dt = bespeaklist[0].BsepeakTime.AddMinutes(-double.Parse(room.Setting.SeatBespeak.ConfirmTime.BeginTime));
}
else if (room.Setting.SeatUsedTimeLimit.Used)
{
if (room.Setting.SeatUsedTimeLimit.Mode == "Free")
{
dt = enterOutLog.EnterOutTime.AddMinutes(room.Setting.SeatUsedTimeLimit.UsedTimeLength);
if (dt > room.Setting.RoomOpenSet.NowCloseTime(enterOutLog.EnterOutTime))
{
dt = room.Setting.RoomOpenSet.NowCloseTime(enterOutLog.EnterOutTime);
}
}
else
{
for (int i = 0; i < room.Setting.SeatUsedTimeLimit.FixedTimes.Count; i++)
{
if (enterOutLog.EnterOutTime < room.Setting.SeatUsedTimeLimit.FixedTimes[i])
{
if (room.Setting.SeatUsedTimeLimit.IsCanContinuedTime && enterOutLog.EnterOutTime > room.Setting.SeatUsedTimeLimit.FixedTimes[i].AddMinutes(-room.Setting.SeatUsedTimeLimit.CanDelayTime))
{
if (i + 1 < room.Setting.SeatUsedTimeLimit.FixedTimes.Count)
{
dt = room.Setting.SeatUsedTimeLimit.FixedTimes[i + 1];
}
else
{
dt = room.Setting.RoomOpenSet.NowCloseTime(enterOutLog.EnterOutTime);
}
}
else
{
dt = room.Setting.SeatUsedTimeLimit.FixedTimes[i];
}
break;
}
}
}
}
//TODO:如果是续时模式，提示续时时间。
jm_enterOutLog.Remark = string.Format("您的座位可以使用到{0}。", dt.ToShortTimeString());
break;
}
}
}
records.EnterOutLog = jm_enterOutLog;
}
if (param.GetBespeakLog)
{
JsonModel.JM_BespeakLog jm_bespeakLog = null;
SeatManage.ClassModel.BespeakLogInfo bespeakLogs = seatDataService.GetSingleBespeakLogForWait(cardNum);
if (bespeakLogs != null)
{
jm_bespeakLog = new JM_BespeakLog();
jm_bespeakLog.DateTime = bespeakLogs.BsepeakTime.ToString("yyyy-MM-dd HH:mm:ss");
jm_bespeakLog.Id = bespeakLogs.BsepeaklogID;
if (bespeakLogs.BsepeakState == EnumType.BookingStatus.Waiting)
{
jm_bespeakLog.IsValid = true;
}
jm_bespeakLog.RoomName = bespeakLogs.ReadingRoomName;
jm_bespeakLog.RoomNum = bespeakLogs.ReadingRoomNo;
jm_bespeakLog.SeatId = bespeakLogs.SeatNo;
jm_bespeakLog.SeatNum = bespeakLogs.ShortSeatNum;
jm_bespeakLog.Remark = bespeakLogs.Remark;
records.BespeakLog = jm_bespeakLog;
}
}
if (param.GetWaitLog)
{
List <EnterOutLogType> logType = new List <EnterOutLogType>();
logType.Add(EnterOutLogType.Waiting);
List <SeatManage.ClassModel.WaitSeatLogInfo> waitSeatlogs = seatDataService.GetWaitLogList(cardNum, null, null, null, logType);
if (waitSeatlogs.Count > 0)
{
EnterOutLogInfo waitEnterOutLog = seatDataService.GetEnterOutLogInfoById(waitSeatlogs[0].EnterOutLogID);
if (waitEnterOutLog != null)
{
JsonModel.JM_WaitSeatLog jm_waitSeatLog = new JM_WaitSeatLog();
jm_waitSeatLog.CardNo = waitSeatlogs[0].CardNo;
jm_waitSeatLog.CardNoB = waitSeatlogs[0].CardNoB;
jm_waitSeatLog.RoomName = waitEnterOutLog.ReadingRoomName;
jm_waitSeatLog.RoomNum = waitEnterOutLog.ReadingRoomNo;
jm_waitSeatLog.SeatId = waitEnterOutLog.SeatNo;
jm_waitSeatLog.SeatNum = waitEnterOutLog.ShortSeatNo;
jm_waitSeatLog.SeatWaitTime = waitSeatlogs[0].SeatWaitTime.ToString("yyyy-MM-dd HH:mm:ss");
jm_waitSeatLog.SeatWaitingID = waitSeatlogs[0].SeatWaitingID;
records.WaitSeatLog = jm_waitSeatLog;
}
}
}
if (param.GetBlackList)
{
List <BlackListInfo> blacklist = seatDataService.GetBlacklistInfo(cardNum);
if (blacklist.Count > 0)
{
JM_Blacklist jm_blacklist = new JM_Blacklist();
jm_blacklist.AddTime = blacklist[0].AddTime.ToString("yyyy-MM-dd HH:mm:ss");
jm_blacklist.CardNo = blacklist[0].CardNo;
jm_blacklist.ID = blacklist[0].ID;
switch (blacklist[0].BlacklistState)
{
case LogStatus.Valid:
jm_blacklist.IsValid = true;
break;
default:
jm_blacklist.IsValid = false;
break;
}
jm_blacklist.OutBlacklistMode = blacklist[0].OutBlacklistMode.ToString();
jm_blacklist.OutTime = blacklist[0].OutTime.ToString("yyyy-MM-dd HH:mm:ss");
jm_blacklist.ReMark = blacklist[0].ReMark;
records.BlacklistLog = jm_blacklist;
}
}
return(SeatManageComm.JSONSerializer.Serialize(records));
}
catch (Exception ex)
{
SeatManage.SeatManageComm.WriteLog.Write("选择座位遇到异常：" + ex.Message);
JM_HandleResult result = new JM_HandleResult();
result.Result = false;
result.Msg = "执行遇到异常!";
return(SeatManage.SeatManageComm.JSONSerializer.Serialize(result));
}
}
public string SubmitSeat(string cardNo, string seatNum, string readingRoomNum)
{
try
{
if (!IsPushAccount(cardNo))
{
string readCardRemark = ConfigurationManager.AppSettings["ReadCardRemark"] ?? "请先刷卡";
return(readCardRemark);
}
List <string> roomNums = new List <string>();
roomNums.Add(readingRoomNum);
List <ReadingRoomInfo> rooms = seatManage.GetReadingRoomInfo(roomNums);
if (rooms.Count == 0)
{
return("没有找到对应的阅览室");
}
ReadingRoomSetting roomSet = rooms[0].Setting;
ReaderInfo reader = GetReaderInfo(cardNo);
EnterOutLogType nowReaderStatus = EnterOutLogType.Leave;
if (reader.EnterOutLog != null && reader.EnterOutLog.EnterOutState != EnterOutLogType.Leave)
{
nowReaderStatus = reader.EnterOutLog.EnterOutState;
}
else if (reader.BespeakLog.Count > 0)
{
nowReaderStatus = EnterOutLogType.BespeakWaiting;
}
else if (reader.WaitSeatLog != null)
{
nowReaderStatus = EnterOutLogType.Waiting;
}
switch (nowReaderStatus)
{
case EnterOutLogType.Leave:
if (seatManage.GetReaderChooseSeatTimes(cardNo, roomSet.PosTimes.Minutes) >= roomSet.PosTimes.Times)
{
return("选座频繁。");
}
EnterOutLogInfo enterOutlog = new EnterOutLogInfo();
enterOutlog.CardNo = cardNo;
enterOutlog.ReadingRoomNo = readingRoomNum;
enterOutlog.Remark = "读者通过手机客户端选择座位";
enterOutlog.SeatNo = seatNum;
enterOutlog.Flag = EnumType.Operation.Reader;
enterOutlog.EnterOutType = EnumType.LogStatus.Valid;
enterOutlog.EnterOutState = EnumType.EnterOutLogType.SelectSeat;
enterOutlog.EnterOutLogNo = SeatManage.SeatManageComm.SeatComm.RndNum();
int newLogId = -1;
if (seatManage.AddEnterOutLogInfo(enterOutlog, ref newLogId) == HandleResult.Successed)
{
return("选座成功！");
}
else
{
return("未知原因，选择座位失败");
}
break;
case EnterOutLogType.BespeakWaiting:
return("您已有等待签到的座位");
case EnterOutLogType.BookingConfirmation:
case EnterOutLogType.SelectSeat:
case EnterOutLogType.ContinuedTime:
case EnterOutLogType.ComeBack:
case EnterOutLogType.ReselectSeat:
case EnterOutLogType.WaitingSuccess:
case EnterOutLogType.ShortLeave:
return("您已有座位");
case EnterOutLogType.Waiting:
return("您当前在等待其他座位");
}
return("读者状态错误");
}
catch (Exception ex)
{
SeatManageComm.WriteLog.Write(string.Format("扫码入座失败：{0}", ex.Message));
return("系统错误，选择座位失败");
}
}
/// <summary>
/// 选座
/// </summary>
/// <param name="cardNum"></param>
/// <param name="seatNum"></param>
/// <param name="roomNum"></param>
/// <returns></returns>
public string SubmitChooseResult(string cardNum, string seatNum, string roomNum)
{
try
{
JM_HandleResult result = new JM_HandleResult();
result.Result = true;
result.Msg = "";
if (string.IsNullOrEmpty(cardNum))
{
result = new JM_HandleResult();
result.Result = false;
result.Msg = "读者的学号不能为空";
return(SeatManageComm.JSONSerializer.Serialize(result));
}
if (seatNum.Length != 9)
{
result = new JM_HandleResult();
result.Result = false;
result.Msg = "座位编号不正确";
return(SeatManageComm.JSONSerializer.Serialize(result));
}
string roomNo = seatNum.Substring(0, 6);
//验证读者是否可以选择座位
result = SeatManageComm.JSONSerializer.Deserialize <JM_HandleResult>(VerifyCanDoIt(cardNum, roomNo));
if (!result.Result)
{
return(SeatManageComm.JSONSerializer.Serialize(result));
}
SeatManage.ClassModel.Seat seatInfo = seatDataService.GetSeatInfoBySeatNum(seatNum);
if (seatInfo == null)
{
result = new JM_HandleResult();
result.Result = false;
result.Msg = "此座位不存在";
return(SeatManageComm.JSONSerializer.Serialize(result));
}
if (seatInfo.IsSuspended)
{
result = new JM_HandleResult();
result.Result = false;
result.Msg = "座位已停用";
return(SeatManageComm.JSONSerializer.Serialize(result));
}
if (seatInfo.SeatUsedState != EnterOutLogType.Leave)
{
result = new JM_HandleResult();
result.Result = false;
result.Msg = "座位正在被使用";
return(SeatManageComm.JSONSerializer.Serialize(result));
}
List <BespeakLogInfo> bespeaklogList = seatDataService.GetBespeakLogInfoBySeatNo(seatNum, DateTime.Now);
if (bespeaklogList.Count > 0)
{
if (!seatInfo.ReadingRoom.Setting.SeatBespeak.SelectBespeakSeat)
{
result = new JM_HandleResult();
result.Result = false;
result.Msg = "此座位座位已被预约";
return(SeatManageComm.JSONSerializer.Serialize(result));
}
if (bespeaklogList[0].BsepeakTime == bespeaklogList[0].SubmitTime)
{
result = new JM_HandleResult();
result.Result = false;
result.Msg = "此座位座位已被预约";
return(SeatManageComm.JSONSerializer.Serialize(result));
}
if (bespeaklogList[0].BsepeakTime.AddMinutes(-double.Parse(seatInfo.ReadingRoom.Setting.SeatBespeak.ConfirmTime.BeginTime)) <= DateTime.Now)
{
result = new JM_HandleResult();
result.Result = false;
result.Msg = "此座位座位已被预约";
return(SeatManageComm.JSONSerializer.Serialize(result));
}
}
EnterOutLogInfo enterOutlog = seatDataService.GetEnterOutLogInfoByCardNo(cardNum);
if (enterOutlog != null && enterOutlog.EnterOutState != EnterOutLogType.Leave)
{
result.Result = false;
result.Msg = "对不起，您已有正在使用中的座位。";
return(SeatManageComm.JSONSerializer.Serialize(result));
}
if (seatDataService.GetSingleBespeakLogForWait(cardNum) != null)
{
result = new JM_HandleResult();
result.Result = false;
result.Msg = "您有等待签到的预约记录。";
return(SeatManageComm.JSONSerializer.Serialize(result));
}
if (seatDataService.GetWaitLogList(cardNum, null, null, null, new List <EnterOutLogType>()
{
EnterOutLogType.Waiting
}).Count > 0)
{
result = new JM_HandleResult();
result.Result = false;
result.Msg = "您有正在等待的座位。";
return(SeatManageComm.JSONSerializer.Serialize(result));
}
if (enterOutlog == null)
{
enterOutlog = new EnterOutLogInfo();
}
enterOutlog.CardNo = cardNum;
enterOutlog.ReadingRoomNo = seatInfo.ReadingRoomNum;
enterOutlog.Remark = string.Format("通过移动终端，选择{0} {1}号座位", seatInfo.ReadingRoom.Name, seatInfo.ShortSeatNo);
enterOutlog.SeatNo = seatInfo.SeatNo;
enterOutlog.Flag = EnumType.Operation.Reader;
enterOutlog.EnterOutType = EnumType.LogStatus.Valid;
enterOutlog.EnterOutState = EnumType.EnterOutLogType.SelectSeat;
enterOutlog.EnterOutLogNo = SeatManage.SeatManageComm.SeatComm.RndNum();
int newLogId = -1;
if (seatDataService.AddEnterOutLogInfo(enterOutlog, ref newLogId) == HandleResult.Successed)
{
result.Result = false;
result.Msg = "选座成功。";
return(SeatManageComm.JSONSerializer.Serialize(result));
}
else
{
result.Result = false;
result.Msg = "对不起，选座失败，请重新尝试。";
return(SeatManageComm.JSONSerializer.Serialize(result));
}
}
catch (Exception ex)
{
SeatManage.SeatManageComm.WriteLog.Write("选择座位遇到异常：" + ex.Message);
JM_HandleResult result = new JM_HandleResult();
result.Result = false;
result.Msg = "执行遇到异常!";
return(SeatManage.SeatManageComm.JSONSerializer.Serialize(result));
}
}
/// <summary>
/// 管理员对座位进行管理操作
/// </summary>
/// <param name="seatNoList">多选座位列表</param>
/// <param name="operateType">操作类型</param>
/// <param name="loginId">登录名</param>
/// <returns></returns>
public string SeatOperation(string seatNoList, string operateType, string loginId)
{
try
{
JM_HandleResultObject result = new JM_HandleResultObject();
result.Result = false;
List <JM_Seat> list = SeatManage.SeatManageComm.JSONSerializer.Deserialize <List <JM_Seat> >(seatNoList);
int successResult = 0;
int failResult = 0;
List <string> noList = new List <string>();
string no = list[0].ReadingRoomNum;
noList.Add(no);
List <ReadingRoomInfo> room = seatDataService.GetReadingRoomInfo(noList);
switch (operateType)
{
#region 设置暂离
case "shortLeave":
try
{
foreach (JM_Seat seat in list)
{
EnterOutLogInfo model = seatDataService.GetEnterOutLogInfoBySeatNum(seat.SeatNo);
if (model != null && model.EnterOutState != SeatManage.EnumType.EnterOutLogType.ShortLeave)
{
model.EnterOutState = SeatManage.EnumType.EnterOutLogType.ShortLeave;
model.Flag = SeatManage.EnumType.Operation.Admin;
model.Remark = "在" + model.ReadingRoomName + "，" + model.SeatNo + "号座位，被管理员" + loginId + "，通过手持设备设置为暂离";
int newId = -1;
SeatManage.EnumType.HandleResult rs = seatDataService.AddEnterOutLogInfo(model, ref newId);
if (rs == SeatManage.EnumType.HandleResult.Successed)
{
successResult++;
result.Result = true;
}
else
{
failResult++;
}
}
}
result.Msg = "设置读者暂离";
}
catch (Exception ex)
{
SeatManage.SeatManageComm.WriteLog.Write("设置读者暂离遇到异常：" + ex.Message);
result.Result = false;
result.Msg = "执行遇到异常!";
}
break;
#endregion
#region 取消暂离
case "comeBack":
try
{
foreach (JM_Seat seat in list)
{
EnterOutLogInfo model = seatDataService.GetEnterOutLogInfoBySeatNum(seat.SeatNo);
if (model != null && model.EnterOutState == EnterOutLogType.ShortLeave)
{
model.EnterOutState = EnterOutLogType.ComeBack;
model.Flag = Operation.Admin;
model.Remark = "在" + model.ReadingRoomName + "，" + model.SeatNo + "号座位，被管理员" + loginId + "，通过手持设备取消暂离，恢复为在座";
int newId = -1;
SeatManage.EnumType.HandleResult rs = seatDataService.AddEnterOutLogInfo(model, ref newId);
if (rs == SeatManage.EnumType.HandleResult.Successed)
{
List <SeatManage.ClassModel.WaitSeatLogInfo> logs = seatDataService.GetWaitLogList("", model.EnterOutLogID, null, null, null);
WaitSeatLogInfo log = null;
if (logs.Count > 0)
{
log = logs[0];
log.NowState = LogStatus.Fail;
log.OperateType = Operation.OtherReader;
log.WaitingState = EnterOutLogType.WaitingCancel;
if (seatDataService.UpdateWaitLog(log))
{
//result.Result = true;
//result.Msg = "取消读者暂离成功";
successResult++;
result.Result = true;
}
else
{
//result.Result = true;
//result.Msg = "取消读者暂离成功，释放读者等待失败";
successResult++;
result.Result = true;
}
}
else
{
//result.Result = true;
//result.Msg = "取消读者暂离成功";
successResult++;
result.Result = true;
}
}
else
{
//result.Result = false;
//result.Msg = "取消读者暂离失败";
failResult++;
}
}
}
result.Msg = "取消读者暂离";
}
catch (Exception ex)
{
SeatManage.SeatManageComm.WriteLog.Write("取消读者暂离遇到异常：" + ex.Message);
result.Result = false;
result.Msg = "执行遇到异常!";
}
break;
#endregion
#region 释放座位
case "leave":
try
{
foreach (JM_Seat seat in list)
{
EnterOutLogInfo model = seatDataService.GetEnterOutLogInfoBySeatNum(seat.SeatNo);
if (model != null && model.EnterOutState != EnterOutLogType.Leave)
{
model.EnterOutState = EnterOutLogType.Leave;
model.Flag = Operation.Admin;
model.Remark = "在" + model.ReadingRoomName + "，" + model.SeatNo + "号座位，被管理员" + loginId + "，通过手持设备设置离开";
int newId = -1;
HandleResult rs = seatDataService.AddEnterOutLogInfo(model, ref newId);
if (rs == HandleResult.Successed)
{
SeatManage.ClassModel.RegulationRulesSetting rules = seatDataService.GetRegulationRulesSetting();
if (room[0].Setting.IsRecordViolate)
{
if (room[0].Setting.BlackListSetting.Used)
{
if (room[0].Setting.BlackListSetting.ViolateRoule[ViolationRecordsType.LeaveByAdmin])
{
ViolationRecordsLogInfo logs = new ViolationRecordsLogInfo();
logs.CardNo = model.CardNo;
logs.SeatID = model.SeatNo.Substring(model.SeatNo.Length - room[0].Setting.SeatNumAmount, room[0].Setting.SeatNumAmount);
logs.ReadingRoomID = model.ReadingRoomNo;
logs.EnterOutTime = DateTime.Now.ToString();
logs.EnterFlag = ViolationRecordsType.LeaveByAdmin;
logs.Remark = string.Format("在{0}，{1}号座位，被管理员{2}，通过手持设备设置离开", room[0].Name, model.ShortSeatNo, loginId);
logs.BlacklistID = "-1";
seatDataService.AddViolationRecordsLog(logs);
}
}
else if (rules.BlacklistSet.Used && rules.BlacklistSet.ViolateRoule[ViolationRecordsType.LeaveByAdmin])
{
ViolationRecordsLogInfo logs = new ViolationRecordsLogInfo();
logs.CardNo = model.CardNo;
logs.SeatID = model.SeatNo.Substring(model.SeatNo.Length - room[0].Setting.SeatNumAmount, room[0].Setting.SeatNumAmount);
logs.ReadingRoomID = model.ReadingRoomNo;
logs.EnterOutTime = DateTime.Now.ToString();
logs.EnterFlag = ViolationRecordsType.LeaveByAdmin;
logs.Remark = string.Format("在{0}，{1}号座位，被管理员{2}，通过手持设备设置离开", room[0].Name, model.ShortSeatNo, loginId);
logs.BlacklistID = "-1";
seatDataService.AddViolationRecordsLog(logs);
}
}
result.Result = true;
//result.Msg = "成功释放读者座位";
successResult++;
}
else
{
//result.Result = false;
//result.Msg = "释放读者座位失败";
failResult++;
}
}
}
result.Msg = "释放读者座位";
}
catch (Exception ex)
{
SeatManage.SeatManageComm.WriteLog.Write("释放读者座位遇到异常：" + ex.Message);
result.Result = false;
result.Msg = "执行遇到异常!";
}
break;
#endregion
#region 加入计时
case "timing":
try
{
foreach (JM_Seat seat in list)
{
EnterOutLogInfo model = seatDataService.GetEnterOutLogInfoBySeatNum(seat.SeatNo);
if (model != null && model.EnterOutState != EnterOutLogType.ShortLeave)
{
DateTime markTime = DateTime.Now;
if (seatDataService.UpdateMarkTime(model.EnterOutLogID, markTime))
{
//result.Result = true;
//result.Msg = "加入计时成功";
successResult++;
result.Result = true;
}
else
{
//result.Result = false;
//result.Msg = "加入计时失败";
failResult++;
}
}
}
result.Msg = "加入计时";
}
catch (Exception ex)
{
SeatManage.SeatManageComm.WriteLog.Write("加入计时遇到异常：" + ex.Message);
result.Result = false;
result.Msg = "执行遇到异常!";
}
break;
#endregion
#region 取消计时
case "cancelTiming":
try
{
foreach (JM_Seat seat in list)
{
EnterOutLogInfo model = seatDataService.GetEnterOutLogInfoBySeatNum(seat.SeatNo);
if (model != null && !string.IsNullOrEmpty(model.MarkTime.ToString()) && model.MarkTime.CompareTo(DateTime.Parse("1900/1/1")) != 0)
{
DateTime markTime = DateTime.Parse("1900/1/1");
if (seatDataService.UpdateMarkTime(model.EnterOutLogID, markTime))
{
//result.Result = true;
//result.Msg = "取消计时成功";
successResult++;
result.Result = true;
}
else
{
//result.Result = false;
//result.Msg = "取消计时失败";
failResult++;
}
}
}
result.Msg = "取消计时";
}
catch (Exception ex)
{
SeatManage.SeatManageComm.WriteLog.Write("取消计时遇到异常：" + ex.Message);
result.Result = false;
result.Msg = "执行遇到异常!";
}
break;
#endregion
#region 加入黑名单
case "addBlackList":
try
{
int newId = -1;
SeatManage.ClassModel.RegulationRulesSetting rules = seatDataService.GetRegulationRulesSetting();
if (!room[0].Setting.BlackListSetting.Used && !rules.BlacklistSet.Used)
{
result.Result = false;
result.Msg = "阅览室未开启记录黑名单功能";
break;
}
foreach (JM_Seat seat in list)
{
EnterOutLogInfo model = seatDataService.GetEnterOutLogInfoBySeatNum(seat.SeatNo);
if (model != null && model.EnterOutState != EnterOutLogType.Leave)
{
if (room[0] != null && room[0].Setting.BlackListSetting.Used)
{
BlackListInfo info = new BlackListInfo();
info.AddTime = DateTime.Now;
info.BlacklistState = LogStatus.Valid;
info.CardNo = model.CardNo;
info.ReadingRoomID = model.ReadingRoomNo;
info.OutBlacklistMode = rules.BlacklistSet.LeaveBlacklist;
if (info.OutBlacklistMode == LeaveBlacklistMode.AutomaticMode)
{
info.ReMark = string.Format("管理员{0}通过手持设备{0}把读者加入黑名单，记录黑名单{1}天", loginId, room[0].Setting.BlackListSetting.LimitDays);
info.OutTime = info.AddTime.AddDays(room[0].Setting.BlackListSetting.LimitDays);
}
else
{
info.ReMark = string.Format("管理员{0}通过手持设备把读者加入黑名单，手动离开黑名单", loginId);
}
newId = seatDataService.AddBlacklist(info);
}
else if (rules.BlacklistSet.Used)
{
BlackListInfo info = new BlackListInfo();
info.AddTime = DateTime.Now;
info.OutTime = info.AddTime.AddDays(rules.BlacklistSet.LimitDays);
info.BlacklistState = LogStatus.Valid;
info.CardNo = model.CardNo;
info.OutBlacklistMode = rules.BlacklistSet.LeaveBlacklist;
if (info.OutBlacklistMode == LeaveBlacklistMode.AutomaticMode)
{
info.ReMark = string.Format("管理员{0}通过手持设备把读者加入黑名单，记录黑名单{1}天", loginId, rules.BlacklistSet.LimitDays);
info.OutTime = info.AddTime.AddDays(rules.BlacklistSet.LimitDays);
}
else
{
info.ReMark = string.Format("管理员{0}通过手持设备把读者加入黑名单，手动离开黑名单", loginId);
}
newId = seatDataService.AddBlacklist(info);
}
if (newId > 0)
{
model.EnterOutState = EnterOutLogType.Leave;
model.Flag = Operation.Admin;
model.Remark = string.Format("在{0}，{1}号座位，被管理员{2}，通过手持设备设置离开", room[0].Name, model.ShortSeatNo, loginId);
HandleResult rs = seatDataService.AddEnterOutLogInfo(model, ref newId);
if (rs == HandleResult.Successed)
{
//result.Result = true;
//result.Msg = "成功将读者加入黑名单！";
successResult++;
result.Result = true;
}
else
{
//result.Result = false;
//result.Msg = "将读者加入黑名单失败！";
failResult++;
}
}
else
{
//result.Result = false;
//result.Msg = "将读者加入黑名单失败！";
failResult++;
}
}
}
result.Msg = "加入黑名单";
}
catch (Exception ex)
{
SeatManage.SeatManageComm.WriteLog.Write("加入黑名单遇到异常：" + ex.Message);
result.Result = false;
result.Msg = "执行遇到异常!";
}
break;
#endregion
}
StringBuilder str = new StringBuilder();
if (result.Result)
{
str.Append("成功");
}
else
{
str.Append("失败");
}
if (successResult > 0)
{
str.Append(string.Format("，成功{0}条", successResult));
}
if (failResult > 0)
{
str.Append(string.Format("，失败{0}条", failResult));
}
result.Msg = result.Msg + str.ToString();
return(SeatManage.SeatManageComm.JSONSerializer.Serialize(result));
}
catch (Exception ex)
{
SeatManage.SeatManageComm.WriteLog.Write("对座位进行操作遇到异常：" + ex.Message);
JM_HandleResultObject result = new JM_HandleResultObject();
result.Result = false;
result.Msg = "执行遇到异常!";
return(SeatManage.SeatManageComm.JSONSerializer.Serialize(result));
}
}
/// <summary>
/// 更换座位
/// </summary>
/// <param name="cardNo">学号</param>
/// <param name="seatNum">要更换的座位号</param>
/// <param name="readingRoomNum">阅览室编号</param>
/// <returns></returns>
public string ChangeSeat(string cardNo, string seatNum, string readingRoomNum)
{
try
{
List <string> roomNums = new List <string>();
roomNums.Add(readingRoomNum);
List <ReadingRoomInfo> rooms = seatManage.GetReadingRoomInfo(roomNums);
if (rooms.Count == 0)
{
return("没有找到对应的阅览室");
}
ReadingRoomSetting roomSet = rooms[0].Setting;
ReaderInfo reader = GetReaderInfo(cardNo);
EnterOutLogType nowReaderStatus = EnterOutLogType.Leave;
if (reader.EnterOutLog != null && reader.EnterOutLog.EnterOutState != EnterOutLogType.Leave)
{
nowReaderStatus = reader.EnterOutLog.EnterOutState;
}
else if (reader.BespeakLog.Count > 0)
{
nowReaderStatus = EnterOutLogType.BespeakWaiting;
}
else if (reader.WaitSeatLog != null)
{
nowReaderStatus = EnterOutLogType.Waiting;
}
switch (nowReaderStatus)
{
case EnterOutLogType.Leave:
return("你还没有选座");
case EnterOutLogType.BespeakWaiting:
if (reader.BespeakLog[0].SeatNo == seatNum && reader.BespeakLog[0].BsepeakState == BookingStatus.Waiting)
{
EnterOutLogInfo newEnterOutLog = new EnterOutLogInfo(); //构造
newEnterOutLog.CardNo = reader.BespeakLog[0].CardNo;
newEnterOutLog.EnterOutLogNo = SeatComm.RndNum();
newEnterOutLog.EnterOutState = EnterOutLogType.BookingConfirmation;
newEnterOutLog.EnterOutType = LogStatus.Valid;
newEnterOutLog.Flag = Operation.Reader;
newEnterOutLog.ReadingRoomNo = reader.BespeakLog[0].ReadingRoomNo;
newEnterOutLog.SeatNo = reader.BespeakLog[0].SeatNo;
newEnterOutLog.Remark = string.Format("通过扫码入座预约的{0} {1}号座位", reader.BespeakLog[0].ReadingRoomName, reader.BespeakLog[0].ShortSeatNum);
int logid = -1;
try
{
HandleResult result = seatManage.AddEnterOutLogInfo(newEnterOutLog, ref logid); //添加入座记录
if (result == HandleResult.Successed)
{
reader.BespeakLog[0].BsepeakState = BookingStatus.Confinmed;
reader.BespeakLog[0].CancelPerson = Operation.Reader;
reader.BespeakLog[0].CancelTime = seatManage.GetServerDateTime();
reader.BespeakLog[0].Remark = string.Format("通过扫码入座预约的{0} {1}号座位", reader.BespeakLog[0].ReadingRoomName, reader.BespeakLog[0].ShortSeatNum);
seatManage.UpdateBespeakLogInfo(reader.BespeakLog[0]);
}
else
{
return("预约入座失败。");
}
}
catch (Exception ex)
{
SeatManageComm.WriteLog.Write(string.Format("扫码预约入座确认失败：{0}", ex.Message));
return("未知原因，预约入座确认失败");
}
}
else
{
return(string.Format("您已预约{0} {1}号座位，请扫该座位上的条形码", reader.BespeakLog[0].ReadingRoomName, reader.BespeakLog[0].ShortSeatNum));
}
break;
case EnterOutLogType.BookingConfirmation:
case EnterOutLogType.SelectSeat:
case EnterOutLogType.ContinuedTime:
case EnterOutLogType.ComeBack:
case EnterOutLogType.ReselectSeat:
case EnterOutLogType.WaitingSuccess:
case EnterOutLogType.ShortLeave:
if (seatManage.GetReaderChooseSeatTimes(cardNo, roomSet.PosTimes.Minutes) >= roomSet.PosTimes.Times)
{
return("选座频繁。");
}
EnterOutLogInfo enterOutlog = reader.EnterOutLog;
enterOutlog.ReadingRoomNo = readingRoomNum;
enterOutlog.Remark = "通过扫码更换到该座位";
enterOutlog.SeatNo = seatNum;
enterOutlog.Flag = EnumType.Operation.Reader;
enterOutlog.EnterOutType = EnumType.LogStatus.Valid;
enterOutlog.EnterOutState = EnumType.EnterOutLogType.ReselectSeat;
enterOutlog.EnterOutLogNo = SeatManage.SeatManageComm.SeatComm.RndNum();
int newLogId = -1;
if (seatManage.AddEnterOutLogInfo(enterOutlog, ref newLogId) == HandleResult.Successed)
{
return("");
}
else
{
return("未知原因，更换座位失败");
}
case EnterOutLogType.Waiting:
return("您当前在等待其他座位");
}
return("读者状态错误");
}
catch (Exception ex)
{
SeatManageComm.WriteLog.Write(string.Format("扫码入座失败：{0}", ex.Message));
return("系统错误，更换座位失败");
}
}
/// <summary>
/// 获取进出记录
/// </summary>
/// <param name="cardNo">学号</param>
/// <param name="roomNum">阅览室号</param>
/// <param name="seatNo">座位号</param>
/// <param name="beginDate">查询的开始时间</param>
/// <param name="endDate"></param>
/// <returns></returns>
public List <EnterOutLogInfo> GetEnterOutBakLogs(string cardNo, string roomNum, string seatNo, string beginDate, string endDate)
{
StringBuilder strWhere = new StringBuilder();
if (!string.IsNullOrEmpty(cardNo))
{
if (String.IsNullOrEmpty(strWhere.ToString()))
{
strWhere.Append(string.Format(" cardNo='{0}'", cardNo));
}
else
{
strWhere.Append(string.Format(" and cardNo='{0}'", cardNo));
}
}
if (!string.IsNullOrEmpty(seatNo))
{
if (String.IsNullOrEmpty(strWhere.ToString()))
{
strWhere.Append(string.Format(" seatNo='{0}'", seatNo));
}
else
{
strWhere.Append(string.Format(" and seatNo='{0}'", seatNo));
}
}
if (!string.IsNullOrEmpty(roomNum))
{
if (String.IsNullOrEmpty(strWhere.ToString()))
{
strWhere.Append(string.Format(" readingRoomNo='{0}'", roomNum));
}
else
{
strWhere.Append(string.Format(" and readingRoomNo='{0}'", roomNum));
}
}
if (!string.IsNullOrEmpty(beginDate))
{
if (!string.IsNullOrEmpty(endDate))
{
if (String.IsNullOrEmpty(strWhere.ToString()))
{
strWhere.Append(string.Format(" EnterOutTime between '{0}' and '{1}'", beginDate, endDate));
}
else
{
strWhere.Append(string.Format(" and EnterOutTime between '{0}' and '{1}'", beginDate, endDate));
}
}
else
{
if (String.IsNullOrEmpty(strWhere.ToString()))
{
strWhere.Append(string.Format(" EnterOutTime between '{0}' and '{1}'", beginDate, GetServerDateTime().ToString()));
}
else
{
strWhere.Append(string.Format(" and EnterOutTime between '{0}' and '{1}'", beginDate, GetServerDateTime().ToString()));
}
}
}
List <EnterOutLogInfo> list = new List <EnterOutLogInfo>();
try
{
DataSet ds = enteroutlog_bak_dal.GetList(strWhere.ToString(), null);
for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
{
EnterOutLogInfo enterOutLog = DataRowToEnterOutLogBakInfo(ds.Tables[0].Rows[i]);;
list.Add(enterOutLog);
}
return(list);
}
catch
{
throw;
}
}
/// <summary>
/// 预约等待
/// </summary>
public void BespeakSeatWait()
{
DateTime nowDate = ServiceDateTime.Now;
if (clientobject.EnterOutLogData.Student.BespeakLog.Count > 0)
{
BespeakLogInfo bespeaklog = clientobject.EnterOutLogData.Student.BespeakLog[0];
//if (!SelectSeatProven.CheckReadingRoomInThisClient(bespeaklog.ReadingRoomNo, clientobject.ClientSetting.DeviceSetting))
//{ //验证房间号是否属于本触摸屏所管理的阅览室
// Tip_Framework uc = new Tip_Framework(TipType.BeapeatRoomNotExists, 9);
//}
ReadingRoomSetting set = clientobject.EnterOutLogData.Student.AtReadingRoom.Setting;
DateTime dtBegin = bespeaklog.BsepeakTime.AddMinutes(-double.Parse(set.SeatBespeak.ConfirmTime.BeginTime));
DateTime dtEnd = bespeaklog.BsepeakTime.AddMinutes(double.Parse(set.SeatBespeak.ConfirmTime.EndTime));
if (DateTimeOperate.DateAccord(dtBegin, dtEnd, nowDate) || (set.SeatBespeak.NowDayBespeak && bespeaklog.SubmitTime == bespeaklog.BsepeakTime))
{
//TODO:预约时间在开始时间和结束时间之间，执行预约确认操作
//TODO:预约确认时，判断当前座位上是否有人。
EnterOutLogInfo seatUsedInfo = T_SM_EnterOutLog.GetUsingEnterOutLogBySeatNo(bespeaklog.SeatNo);
if (seatUsedInfo != null && seatUsedInfo.EnterOutState != EnterOutLogType.Leave)
{ //条件满足，说明座位正在使用。
seatUsedInfo.EnterOutState = EnterOutLogType.Leave;
seatUsedInfo.EnterOutType = LogStatus.Valid;
seatUsedInfo.Remark = string.Format("预约该座位的读者在离开终端刷卡确认入座，设置在座读者离开");
seatUsedInfo.Flag = Operation.OtherReader;
int newId = -1;
EnterOutOperate.AddEnterOutLog(seatUsedInfo, ref newId);
}
EnterOutLogInfo newEnterOutLog = new EnterOutLogInfo();//构造
newEnterOutLog.CardNo = bespeaklog.CardNo;
newEnterOutLog.EnterOutLogNo = SeatComm.RndNum();
newEnterOutLog.EnterOutState = EnterOutLogType.BookingConfirmation;
newEnterOutLog.EnterOutType = LogStatus.Valid;
newEnterOutLog.Flag = Operation.Reader;
newEnterOutLog.ReadingRoomNo = bespeaklog.ReadingRoomNo;
newEnterOutLog.ReadingRoomName = bespeaklog.ReadingRoomName;
newEnterOutLog.ShortSeatNo = bespeaklog.ShortSeatNum;
newEnterOutLog.SeatNo = bespeaklog.SeatNo;
newEnterOutLog.Remark = string.Format("在离开终端刷卡，入座预约的{0} {1}号座位", bespeaklog.ReadingRoomName, bespeaklog.ShortSeatNum);
clientobject.EnterOutLogData.EnterOutlog = newEnterOutLog;
int logid = -1;
HandleResult result = EnterOutOperate.AddEnterOutLog(newEnterOutLog, ref logid); //添加入座记录
if (result == HandleResult.Successed)
{
bespeaklog.BsepeakState = BookingStatus.Confinmed;
bespeaklog.CancelPerson = Operation.Reader;
bespeaklog.CancelTime = nowDate;
bespeaklog.Remark = string.Format("在离开终端刷卡，入座预约的{0} {1}号座位", bespeaklog.ReadingRoomName, bespeaklog.ShortSeatNum);
T_SM_SeatBespeak.UpdateBespeakList(bespeaklog);
}
if (popMessage != null)
{
popMessage(this, new PopMessage(TipType.BespeatSeatConfirmSuccess, "预约签到成功"));
}
}
else if (nowDate.CompareTo(dtBegin) < 0)
{
if (popMessage != null)
{
popMessage(this, new PopMessage(TipType.BookConfirmWarn, "没到签到时间"));
}
}
else if (nowDate.CompareTo(dtEnd) < 0)
{
//TODO:最迟确认时间为：dtEnd。
}
else
{
//TODO:未知原因，预约确认失败。
}
}
}
/// <summary>
/// 预约等待
/// </summary>
public void BespeakSeatWait()
{
DateTime nowDate = ServiceDateTime.Now;
if (clientobject.EnterOutLogData.Student.BespeakLog.Count > 0)
{
BespeakLogInfo bespeaklog = clientobject.EnterOutLogData.Student.BespeakLog[0];
//if (!SelectSeatProven.CheckReadingRoomInThisClient(bespeaklog.ReadingRoomNo, clientobject.ClientSetting.DeviceSetting))
//{ //验证房间号是否属于本触摸屏所管理的阅览室
// Tip_Framework uc = new Tip_Framework(TipType.BeapeatRoomNotExists, 9);
//}
ReadingRoomSetting set = clientobject.EnterOutLogData.Student.AtReadingRoom.Setting;
DateTime dtBegin = bespeaklog.BsepeakTime.AddMinutes(-double.Parse(set.SeatBespeak.ConfirmTime.BeginTime));
DateTime dtEnd = bespeaklog.BsepeakTime.AddMinutes(double.Parse(set.SeatBespeak.ConfirmTime.EndTime));
if (DateTimeOperate.DateAccord(dtBegin, dtEnd, nowDate) || (set.SeatBespeak.NowDayBespeak && bespeaklog.SubmitTime == bespeaklog.BsepeakTime))
{
//TODO:预约时间在开始时间和结束时间之间，执行预约确认操作
//TODO:预约确认时，判断当前座位上是否有人。
EnterOutLogInfo seatUsedInfo = T_SM_EnterOutLog.GetUsingEnterOutLogBySeatNo(bespeaklog.SeatNo);
if (seatUsedInfo != null && seatUsedInfo.EnterOutState != EnterOutLogType.Leave)
{ //条件满足，说明座位正在使用。
seatUsedInfo.EnterOutState = EnterOutLogType.Leave;
seatUsedInfo.EnterOutType = LogStatus.Valid;
seatUsedInfo.TerminalNum = clientobject.ClientSetting.ClientNo;
seatUsedInfo.Remark = string.Format("预约该座位的读者在终端{0}刷卡确认入座，设置在座读者离开", clientobject.ClientSetting.ClientNo);
seatUsedInfo.Flag = Operation.OtherReader;
int newId = -1;
if (EnterOutOperate.AddEnterOutLog(seatUsedInfo, ref newId) == HandleResult.Successed)
{
List <WaitSeatLogInfo> waitInfoList = SeatManage.Bll.T_SM_SeatWaiting.GetWaitSeatList(null, seatUsedInfo.EnterOutLogID, null, null, null);
if (waitInfoList.Count > 0)
{
this.clientobject.EnterOutLogData.WaitSeatLogModel = waitInfoList[0];
this.clientobject.EnterOutLogData.WaitSeatLogModel.OperateType = Operation.Reader;
this.clientobject.EnterOutLogData.WaitSeatLogModel.WaitingState = EnterOutLogType.WaitingCancel;
this.clientobject.EnterOutLogData.WaitSeatLogModel.NowState = LogStatus.Valid;
if (!T_SM_SeatWaiting.UpdateWaitLog(this.clientobject.EnterOutLogData.WaitSeatLogModel))
{
PopupWindow errorWindow = new PopupWindow(TipType.Exception);
errorWindow.ShowDialog();
return;
}
}
}
else
{
PopupWindow errorWindow = new PopupWindow(TipType.Exception);
errorWindow.ShowDialog();
return;
}
}
EnterOutLogInfo newEnterOutLog = new EnterOutLogInfo();//构造
newEnterOutLog.CardNo = bespeaklog.CardNo;
newEnterOutLog.EnterOutLogNo = SeatComm.RndNum();
newEnterOutLog.EnterOutState = EnterOutLogType.BookingConfirmation;
newEnterOutLog.EnterOutType = LogStatus.Valid;
newEnterOutLog.Flag = Operation.Reader;
newEnterOutLog.ReadingRoomNo = bespeaklog.ReadingRoomNo;
newEnterOutLog.ReadingRoomName = bespeaklog.ReadingRoomName;
newEnterOutLog.ShortSeatNo = bespeaklog.ShortSeatNum;
newEnterOutLog.SeatNo = bespeaklog.SeatNo;
newEnterOutLog.TerminalNum = clientobject.ClientSetting.ClientNo;
newEnterOutLog.Remark = string.Format("在终端{0}刷卡，入座预约的{1} {2}号座位", clientobject.ClientSetting.ClientNo, bespeaklog.ReadingRoomName, bespeaklog.ShortSeatNum);
clientobject.EnterOutLogData.EnterOutlog = newEnterOutLog;
int logid = -1;
HandleResult result = EnterOutOperate.AddEnterOutLog(newEnterOutLog, ref logid); //添加入座记录
if (result == HandleResult.Successed)
{
bespeaklog.BsepeakState = BookingStatus.Confinmed;
bespeaklog.CancelPerson = Operation.Reader;
bespeaklog.CancelTime = nowDate;
bespeaklog.Remark = string.Format("在终端{0}刷卡，入座预约的{1} {2}号座位", clientobject.ClientSetting.ClientNo, bespeaklog.ReadingRoomName, bespeaklog.ShortSeatNum);
T_SM_SeatBespeak.UpdateBespeakList(bespeaklog);
PrintData data = new PrintData();
data.CardNo = bespeaklog.CardNo;;
data.EnterTime = nowDate;
data.ReaderName = clientobject.EnterOutLogData.Student.Name;
data.ReadingRoomName = clientobject.EnterOutLogData.Student.AtReadingRoom.Name;
data.SeatNo = SeatComm.SeatNoToShortSeatNo(set.SeatNumAmount, bespeaklog.SeatNo);
if (clientobject.ClientSetting.DeviceSetting.UsingPrintSlip == PrintSlipMode.AutoPrint)
{
printer.ThreadPrint(PrintStatus.General, data, clientobject.ClientSetting.ClientNo);
}
if (clientobject.ClientSetting.DeviceSetting.UsingPrintSlip == PrintSlipMode.UserChoose)
{
PopupWindow printWindow = new PopupWindow(TipType.PrintConfIrm);
printWindow.ShowDialog();
if (printWindow.viewModel.OperateResule == HandleResult.Successed)
{
printer.ThreadPrint(PrintStatus.General, data, clientobject.ClientSetting.ClientNo);
}
}
}
PopupWindow popWindow = new PopupWindow(TipType.BespeatSeatConfirmSuccess);
popWindow.ShowDialog();
}
else if (nowDate.CompareTo(dtBegin) < 0)
{
//TODO:预约时间过早，请在dtBegin 到dtEnd刷卡确认。
PopupWindow popWindow = new PopupWindow(TipType.BookConfirmWarn);
popWindow.ShowDialog();
if (popWindow.viewModel.OperateResule == HandleResult.Successed)
{
bespeaklog.BsepeakState = BookingStatus.Cencaled;
bespeaklog.CancelPerson = Operation.Reader;
bespeaklog.CancelTime = ServiceDateTime.Now;
bespeaklog.Remark = string.Format("在终端{0}刷卡取消{1}，{2}号座位的预约。", clientobject.ClientSetting.ClientNo, bespeaklog.ReadingRoomName, bespeaklog.ShortSeatNum);
int i = T_SM_SeatBespeak.UpdateBespeakList(bespeaklog);
PopupWindow popWindowCancel = new PopupWindow(TipType.BookCancelSuccess);
popWindowCancel.ShowDialog();
}
}
else if (nowDate.CompareTo(dtEnd) < 0)
{
//TODO:最迟确认时间为：dtEnd。
}
else
{
//TODO:未知原因，预约确认失败。
}
}
}
/// <summary>
/// 开始计算
/// </summary>
private void Statistics()
{
try
{
List <ReadingRoomInfo> rooms = ClientConfigOperate.GetReadingRooms(null);
DateTime sdt = SeatUsageDataOperating.GetLastRoomUsageStatisticsDate();
if (sdt <= DateTime.Parse("2000-1-1"))
{
return;
}
sdt = sdt.AddDays(1);
while (true)
{
//获取进出记录
List <EnterOutLogInfo> enterOutLogList = T_SM_EnterOutLog_bak.GetStatisticsLogsByDate(sdt);
List <BespeakLogInfo> bespeakLogList = T_SM_SeatBespeak.GetBespeakList(null, null, sdt, 0, null);
List <ViolationRecordsLogInfo> violationLogList = T_SM_ViolateDiscipline.GetViolationRecords(null, null, sdt.ToShortDateString(), sdt.Date.AddDays(1).AddSeconds(-1).ToString(), LogStatus.None, LogStatus.None);
//List<BlackListInfo> blacklistList = T_SM_Blacklist.GetAllBlackListInfo(null, LogStatus.None, sdt.ToShortDateString(), sdt.Date.AddDays(1).AddSeconds(-1).ToString());
if (enterOutLogList.Count <= 0 && bespeakLogList.Count <= 0 && violationLogList.Count <= 0 && sdt >= ServiceDateTime.Now.Date.AddDays(-1))
{
break;
}
Dictionary <string, SeatManage.ClassModel.RoomUsageStatistics> roomDir = rooms.ToDictionary(room => room.No, room => new SeatManage.ClassModel.RoomUsageStatistics());
//基本数据及排序处理
foreach (ReadingRoomInfo room in rooms)
{
roomDir[room.No].StatisticsDate = sdt;
roomDir[room.No].ReadingRoomNo = room.No;
roomDir[room.No].SeatAllCount = room.SeatList.Seats.Count;
roomDir[room.No].OpenTime = DateTime.Parse(room.Setting.GetRoomOpenTimeByDate(sdt).BeginTime);
roomDir[room.No].CloseTime = DateTime.Parse(room.Setting.GetRoomOpenTimeByDate(sdt).EndTime);
roomDir[room.No].RoomUsageTime = (int)(roomDir[room.No].CloseTime - roomDir[room.No].OpenTime).TotalMinutes;
roomDir[room.No].SeatUsageCount = enterOutLogList.FindAll(u => u.ReadingRoomNo == room.No).GroupBy(u => u.SeatNo).Count();
roomDir[room.No].UsedReaderCount = enterOutLogList.FindAll(u => u.ReadingRoomNo == room.No).GroupBy(u => u.CardNo).Count();
roomDir[room.No].CanBesapeakSeat = room.Setting.SeatBespeak.BespeakArea.BespeakType == BespeakAreaType.Percentage ? (int)room.Setting.SeatBespeak.BespeakArea.Scale * room.SeatList.Seats.Count : room.SeatList.Seats.Count(u => u.Value.CanBeBespeak);
roomDir[room.No].BespeakedSeat = bespeakLogList.FindAll(u => u.ReadingRoomNo == room.No).GroupBy(u => u.SeatNo).Count();
}
foreach (ViolationRecordsLogInfo vrl in violationLogList)
{
roomDir[vrl.ReadingRoomID].ViolationRecordCount++;
switch (vrl.EnterFlag)
{
case ViolationRecordsType.BookingTimeOut:
roomDir[vrl.ReadingRoomID].VRBookingTimeOut++;
break;
case ViolationRecordsType.LeaveByAdmin:
roomDir[vrl.ReadingRoomID].VRLeaveByAdmin++;
break;
case ViolationRecordsType.LeaveNotReadCard:
roomDir[vrl.ReadingRoomID].VRLeaveNotReadCard++;
break;
case ViolationRecordsType.SeatOutTime:
roomDir[vrl.ReadingRoomID].VRSeatOutTime++;
break;
case ViolationRecordsType.ShortLeaveByAdminOutTime:
roomDir[vrl.ReadingRoomID].VRShortLeaveByAdminOutTime++;
break;
case ViolationRecordsType.ShortLeaveByReaderOutTime:
roomDir[vrl.ReadingRoomID].VRShortLeaveByReaderOutTime++;
break;
case ViolationRecordsType.ShortLeaveByServiceOutTime:
roomDir[vrl.ReadingRoomID].VRShortLeaveByServiceOutTime++;
break;
case ViolationRecordsType.ShortLeaveOutTime:
roomDir[vrl.ReadingRoomID].VRShortLeaveOutTime++;
break;
}
}
//预约记录处理
foreach (BespeakLogInfo bli in bespeakLogList)
{
roomDir[bli.ReadingRoomNo].AllBespeakCount++;
if (bli.BsepeakTime.Date == bli.SubmitTime.Date)
{
switch (bli.BsepeakState)
{
case BookingStatus.Cencaled:
switch (bli.CancelPerson)
{
case Operation.Admin:
case Operation.Reader:
roomDir[bli.ReadingRoomNo].NowDayBespeakCancel++;
break;
case Operation.Service:
roomDir[bli.ReadingRoomNo].NowDayBespeakOverTime++;
break;
}
break;
case BookingStatus.Confinmed:
roomDir[bli.ReadingRoomNo].NowDayBespeakCheck++;
break;
}
roomDir[bli.ReadingRoomNo].NowDayBespeakCount++;
}
else
{
switch (bli.BsepeakState)
{
case BookingStatus.Cencaled:
switch (bli.CancelPerson)
{
case Operation.Admin:
case Operation.Reader:
roomDir[bli.ReadingRoomNo].BespeakCancel++;
break;
case Operation.Service:
roomDir[bli.ReadingRoomNo].BespeakOverTime++;
break;
}
break;
case BookingStatus.Confinmed:
roomDir[bli.ReadingRoomNo].BespeakCheck++;
break;
}
roomDir[bli.ReadingRoomNo].BespeakCount++;
}
}
foreach (EnterOutLogInfo eol in enterOutLogList)
{
//刷卡次数
if (!string.IsNullOrEmpty(eol.TerminalNum) && !(eol.EnterOutState == EnterOutLogType.ContinuedTime && eol.Flag == Operation.Service))
{
roomDir[eol.ReadingRoomNo].RushCardOperatingCount++;
}
//记录类型
switch (eol.EnterOutState)
{
case EnterOutLogType.BookingConfirmation:
roomDir[eol.ReadingRoomNo].CheckBespeakCount++;
if (string.IsNullOrEmpty(eol.TerminalNum))
{
roomDir[eol.ReadingRoomNo].CkeckBespeakInOtherClient++;
}
else
{
roomDir[eol.ReadingRoomNo].CheckBespeakInSeatClient++;
}
break;
case EnterOutLogType.ComeBack:
roomDir[eol.ReadingRoomNo].ComeBackCount++;
switch (eol.Flag)
{
case Operation.Admin:
roomDir[eol.ReadingRoomNo].ComeBackByAdmin++;
break;
case Operation.OtherReader:
roomDir[eol.ReadingRoomNo].ComeBackByOtherReader++;
break;
case Operation.Reader:
roomDir[eol.ReadingRoomNo].ComeBackByReader++;
if (string.IsNullOrEmpty(eol.TerminalNum))
{
roomDir[eol.ReadingRoomNo].ComeBackInOtherClient++;
}
else
{
roomDir[eol.ReadingRoomNo].ComeBackInSeatClient++;
}
break;
}
EnterOutLogInfo slEOL = enterOutLogList.FindLast(u => u.EnterOutState == EnterOutLogType.ShortLeave && u.EnterOutLogNo == eol.EnterOutLogNo && u.EnterOutTime < eol.EnterOutTime);
if (slEOL != null)
{
roomDir[eol.ReadingRoomNo].ShortLeaveTime += (int)(slEOL.EnterOutTime - eol.EnterOutTime).TotalMinutes;
}
break;
case EnterOutLogType.ContinuedTime:
roomDir[eol.ReadingRoomNo].ContinueTimeCount++;
switch (eol.Flag)
{
case Operation.Service:
roomDir[eol.ReadingRoomNo].ContinueTimeByService++;
break;
case Operation.Reader:
roomDir[eol.ReadingRoomNo].ContinueTimeByReader++;
if (string.IsNullOrEmpty(eol.TerminalNum))
{
roomDir[eol.ReadingRoomNo].ContinueTimeInOtherClient++;
}
else
{
roomDir[eol.ReadingRoomNo].ContinueTimeInSeatClient++;
}
break;
}
break;
case EnterOutLogType.Leave:
roomDir[eol.ReadingRoomNo].LeaveCount++;
roomDir[eol.ReadingRoomNo].ReaderUsageCount++;
switch (eol.Flag)
{
case Operation.Service:
roomDir[eol.ReadingRoomNo].LeaveByService++;
break;
case Operation.Admin:
roomDir[eol.ReadingRoomNo].LeaveByAdmin++;
break;
case Operation.Reader:
roomDir[eol.ReadingRoomNo].LeaveByReader++;
if (string.IsNullOrEmpty(eol.TerminalNum))
{
roomDir[eol.ReadingRoomNo].LeaveInOtherClient++;
}
else
{
roomDir[eol.ReadingRoomNo].LeaveInSeatClient++;
}
break;
}
EnterOutLogInfo enterEOL = enterOutLogList.Find(u => (u.EnterOutState == EnterOutLogType.BookingConfirmation || u.EnterOutState == EnterOutLogType.ReselectSeat || u.EnterOutState == EnterOutLogType.SelectSeat || u.EnterOutState == EnterOutLogType.WaitingSuccess) && u.EnterOutLogNo == eol.EnterOutLogNo);
if (enterEOL != null)
{
roomDir[eol.ReadingRoomNo].SeatUsageTime += (int)(eol.EnterOutTime - enterEOL.EnterOutTime).TotalMinutes;
}
break;
case EnterOutLogType.ReselectSeat:
roomDir[eol.ReadingRoomNo].ReselectSeatCount++;
if (string.IsNullOrEmpty(eol.TerminalNum))
{
roomDir[eol.ReadingRoomNo].ReselectSeatInOtherClient++;
}
else
{
roomDir[eol.ReadingRoomNo].ReselectSeatInSeatClient++;
}
break;
case EnterOutLogType.SelectSeat:
roomDir[eol.ReadingRoomNo].SelectSeatCount++;
switch (eol.Flag)
{
case Operation.Admin:
roomDir[eol.ReadingRoomNo].SelectSeatByAdmin++;
break;
case Operation.Reader:
roomDir[eol.ReadingRoomNo].SelectSeatByReader++;
if (string.IsNullOrEmpty(eol.TerminalNum))
{
roomDir[eol.ReadingRoomNo].SelectSeatInOtherClient++;
}
else
{
roomDir[eol.ReadingRoomNo].SelectSeatInSeatClient++;
}
break;
}
break;
case EnterOutLogType.ShortLeave:
roomDir[eol.ReadingRoomNo].ShortLeaveCount++;
switch (eol.Flag)
{
case Operation.OtherReader:
roomDir[eol.ReadingRoomNo].ShortLeaveByOtherReader++;
break;
case Operation.Service:
roomDir[eol.ReadingRoomNo].ShortLeaveByService++;
break;
case Operation.Admin:
roomDir[eol.ReadingRoomNo].ShortLeaveByAdmin++;
break;
case Operation.Reader:
roomDir[eol.ReadingRoomNo].ShortLeaveByReader++;
if (string.IsNullOrEmpty(eol.TerminalNum))
{
roomDir[eol.ReadingRoomNo].ShortLeaveInOtherClient++;
}
else
{
roomDir[eol.ReadingRoomNo].ShortLeaveInSeatClient++;
}
break;
}
break;
case EnterOutLogType.WaitingSuccess:
roomDir[eol.ReadingRoomNo].WaitSeatCount++;
break;
}
}
foreach (SeatManage.ClassModel.RoomUsageStatistics roomUS in roomDir.Values.Where(roomUS => !SeatUsageDataOperating.AddRoomUsageStatistics(roomUS)))
{
WriteLog.Write(string.Format("数据统计服务：添加阅览室:{0} {1} 数据统计出错", roomUS.ReadingRoomNo, roomUS.StatisticsDate));
throw new Exception(string.Format("数据统计服务：添加阅览室:{0} {1} 数据统计出错", roomUS.ReadingRoomNo, roomUS.StatisticsDate));
}
sdt = sdt.AddDays(1);
if (sdt >= ServiceDateTime.Now.Date)
{
break;
}
roomDir = null;
}
WriteLog.Write("数据统计服务：统计阅览室完成使用情况完成");
}
catch (Exception ex)
{
WriteLog.Write(string.Format("数据统计服务：统计阅览室使用情况失败：{0}", ex.Message));
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (Session["LoginId"] == null)
{
Response.Redirect("../Login.aspx");
}
if (!IsPostBack)
{
BindReadingRoomList(Session[CookiesManager.LoginID].ToString());
GetSeatList(selectReadingRomm.Items[selectReadingRomm.SelectedIndex].Value, selectSeatState.Items[selectSeatState.SelectedIndex].Value);
}
cmd = Request.Form["subCmd"];
if (cmd != null)
{
#region 座位相关操作
switch (cmd)
{
case "search": //查询座位
try
{
GetSeatList(selectReadingRomm.Items[selectReadingRomm.SelectedIndex].Value, selectSeatState.Items[selectSeatState.SelectedIndex].Value);
}
catch
{
}
break;
case "ShortLeave": //设置暂离
try
{
string seatStr = hidSeatNo.Value;
string[] noArr = seatStr.Split(',');
string seatNo = "";
for (int i = 0; i < noArr.Length; i++)
{
seatNo = noArr[i].Trim();
EnterOutLogInfo enterOutLog = T_SM_EnterOutLog.GetUsingEnterOutLogBySeatNo(seatNo);
if (enterOutLog != null && enterOutLog.EnterOutState != EnterOutLogType.ShortLeave)
{
ReadingRoomInfo roomInfo = T_SM_ReadingRoom.GetSingleRoomInfo(enterOutLog.ReadingRoomNo);
enterOutLog.EnterOutState = EnterOutLogType.ShortLeave;
enterOutLog.Flag = Operation.Admin;
enterOutLog.Remark = string.Format("在{0}，{1}号座位，被管理员{2}，通过手持设备设置为暂离", roomInfo.Name, enterOutLog.ShortSeatNo, Session["LoginID"]);
int newId = -1;
HandleResult result = EnterOutOperate.AddEnterOutLog(enterOutLog, ref newId);
if (result == HandleResult.Successed)
{
Page.RegisterStartupScript("", "<script>alert('设置读者暂离成功');</script>");
GetSeatList(selectReadingRomm.Items[selectReadingRomm.SelectedIndex].Value, selectSeatState.Items[selectSeatState.SelectedIndex].Value);
}
else
{
Page.RegisterStartupScript("", "<script>alert('设置读者暂离失败');</script>");
}
}
}
}
catch
{
}
break;
case "ReleaseShortLeave": //取消暂离
try
{
string seatStr = hidSeatNo.Value;
string[] noArr = seatStr.Split(',');
string seatNo = "";
for (int i = 0; i < noArr.Length; i++)
{
seatNo = noArr[i].Trim();
EnterOutLogInfo enterOutLog = T_SM_EnterOutLog.GetUsingEnterOutLogBySeatNo(seatNo);
if (enterOutLog != null && enterOutLog.EnterOutState == EnterOutLogType.ShortLeave)
{
ReadingRoomInfo roomInfo = T_SM_ReadingRoom.GetSingleRoomInfo(enterOutLog.ReadingRoomNo);
enterOutLog.EnterOutState = EnterOutLogType.ComeBack;
enterOutLog.Flag = Operation.Admin;
enterOutLog.Remark = string.Format("在{0}，{1}号座位，被管理员{2}，通过手持设备取消暂离，恢复为在座", roomInfo.Name, enterOutLog.ShortSeatNo, Session["LoginID"]);
int newId = -1;
HandleResult result = EnterOutOperate.AddEnterOutLog(enterOutLog, ref newId);
if (result == HandleResult.Successed)
{
List <WaitSeatLogInfo> waitSeatLogs = T_SM_SeatWaiting.GetWaitSeatList("", enterOutLog.EnterOutLogID, null, null, null);
WaitSeatLogInfo waitSeatLog = null;
if (waitSeatLogs.Count > 0)
{
waitSeatLog = waitSeatLogs[0];
waitSeatLog.NowState = LogStatus.Fail;
waitSeatLog.OperateType = Operation.OtherReader;
waitSeatLog.WaitingState = EnterOutLogType.WaitingCancel;
if (T_SM_SeatWaiting.UpdateWaitLog(waitSeatLog))
{
Page.RegisterStartupScript("", "<script>alert('取消读者暂离成功');</script>");
GetSeatList(selectReadingRomm.Items[selectReadingRomm.SelectedIndex].Value, selectSeatState.Items[selectSeatState.SelectedIndex].Value);
}
else
{
Page.RegisterStartupScript("", "<script>alert('取消读者暂离成功，取消读者等待失败');</script>");
GetSeatList(selectReadingRomm.Items[selectReadingRomm.SelectedIndex].Value, selectSeatState.Items[selectSeatState.SelectedIndex].Value);
}
}
else
{
Page.RegisterStartupScript("", "<script>alert('取消读者暂离成功');</script>");
GetSeatList(selectReadingRomm.Items[selectReadingRomm.SelectedIndex].Value, selectSeatState.Items[selectSeatState.SelectedIndex].Value);
}
}
else
{
Page.RegisterStartupScript("", "<script>alert('取消读者暂离失败');</script>");
}
}
}
}
catch
{
}
break;
case "Release": //释放座位
try
{
string seatStr = hidSeatNo.Value;
string[] noArr = seatStr.Split(',');
string seatNo = "";
for (int i = 0; i < noArr.Length; i++)
{
seatNo = noArr[i].Trim();
EnterOutLogInfo enterOutLog = T_SM_EnterOutLog.GetUsingEnterOutLogBySeatNo(seatNo);
if (enterOutLog != null && enterOutLog.EnterOutState != EnterOutLogType.Leave)
{
ReadingRoomInfo roomInfo = T_SM_ReadingRoom.GetSingleRoomInfo(enterOutLog.ReadingRoomNo);
enterOutLog.EnterOutState = EnterOutLogType.Leave;
enterOutLog.Flag = Operation.Admin;
enterOutLog.Remark = string.Format("在{0}，{1}号座位，被管理员{2}，通过手持设备设置离开", roomInfo.Name, enterOutLog.ShortSeatNo, Session["LoginID"]);
int newId = -1;
HandleResult result = EnterOutOperate.AddEnterOutLog(enterOutLog, ref newId);
if (result == HandleResult.Successed)
{
RegulationRulesSetting rulesSet = T_SM_SystemSet.GetRegulationRulesSetting();
if (roomInfo.Setting.IsRecordViolate)
{
if (roomInfo.Setting.BlackListSetting.Used)
{
if (roomInfo.Setting.BlackListSetting.ViolateRoule[ViolationRecordsType.LeaveByAdmin])
{
ViolationRecordsLogInfo violationRecords = new ViolationRecordsLogInfo();
violationRecords.CardNo = enterOutLog.CardNo;
violationRecords.SeatID = enterOutLog.SeatNo.Substring(enterOutLog.SeatNo.Length - roomInfo.Setting.SeatNumAmount, roomInfo.Setting.SeatNumAmount);
violationRecords.ReadingRoomID = enterOutLog.ReadingRoomNo;
violationRecords.EnterOutTime = ServiceDateTime.Now.ToString();
violationRecords.EnterFlag = ViolationRecordsType.LeaveByAdmin;
violationRecords.Remark = string.Format("在{0}，{1}号座位，被管理员{2}，通过手持设备设置离开", roomInfo.Name, enterOutLog.ShortSeatNo, Session["LoginID"]);
violationRecords.BlacklistID = "-1";
T_SM_ViolateDiscipline.AddViolationRecords(violationRecords);
}
}
else if (rulesSet.BlacklistSet.Used && rulesSet.BlacklistSet.ViolateRoule[ViolationRecordsType.LeaveByAdmin])
{
ViolationRecordsLogInfo violationRecords = new ViolationRecordsLogInfo();
violationRecords.CardNo = enterOutLog.CardNo;
violationRecords.SeatID = enterOutLog.SeatNo.Substring(enterOutLog.SeatNo.Length - roomInfo.Setting.SeatNumAmount, roomInfo.Setting.SeatNumAmount);
violationRecords.ReadingRoomID = enterOutLog.ReadingRoomNo;
violationRecords.EnterOutTime = ServiceDateTime.Now.ToString();
violationRecords.EnterFlag = ViolationRecordsType.LeaveByAdmin;
violationRecords.Remark = string.Format("在{0}，{1}号座位，被管理员{2}，通过手持设备设置离开", roomInfo.Name, enterOutLog.ShortSeatNo, Session["LoginID"]);
violationRecords.BlacklistID = "-1";
T_SM_ViolateDiscipline.AddViolationRecords(violationRecords);
}
}
Page.RegisterStartupScript("", "<script>alert('设置读者离开成功');</script>");
GetSeatList(selectReadingRomm.Items[selectReadingRomm.SelectedIndex].Value, selectSeatState.Items[selectSeatState.SelectedIndex].Value);
}
else
{
Page.RegisterStartupScript("", "<script>alert('设置读者离开失败');</script>");
}
}
}
}
catch
{
}
break;
case "onTime": //计时
try
{
string seatStr = hidSeatNo.Value;
string[] noArr = seatStr.Split(',');
string seatNo = "";
for (int i = 0; i < noArr.Length; i++)
{
seatNo = noArr[i].Trim();
EnterOutLogInfo enterOutLog = T_SM_EnterOutLog.GetUsingEnterOutLogBySeatNo(seatNo);
if (enterOutLog != null && enterOutLog.EnterOutState != EnterOutLogType.ShortLeave)
{
DateTime markTime = ServiceDateTime.Now;
EnterOutOperate.UpdateMarkTime(enterOutLog.EnterOutLogID, markTime);
GetSeatList(selectReadingRomm.Items[selectReadingRomm.SelectedIndex].Value, selectSeatState.Items[selectSeatState.SelectedIndex].Value);
}
}
}
catch
{
}
break;
case "offTime": //取消计时
try
{
string seatStr = hidSeatNo.Value;
string[] noArr = seatStr.Split(',');
string seatNo = "";
for (int i = 0; i < noArr.Length; i++)
{
seatNo = noArr[i].Trim();
EnterOutLogInfo enterOutLog = T_SM_EnterOutLog.GetUsingEnterOutLogBySeatNo(seatNo);
if (enterOutLog != null && !string.IsNullOrEmpty(enterOutLog.MarkTime.ToString()) && enterOutLog.MarkTime.CompareTo(DateTime.Parse("1900/1/1")) != 0)
{
DateTime markTime = DateTime.Parse("1900-1-1");
EnterOutOperate.UpdateMarkTime(enterOutLog.EnterOutLogID, markTime);
GetSeatList(selectReadingRomm.Items[selectReadingRomm.SelectedIndex].Value, selectSeatState.Items[selectSeatState.SelectedIndex].Value);
}
}
}
catch
{
}
break;
case "AddBlacklist":
try
{
string seatStr = hidSeatNo.Value;
string[] noArr = seatStr.Split(',');
string seatNo = "";
int newId = -1;
RegulationRulesSetting rulesSet = T_SM_SystemSet.GetRegulationRulesSetting();
for (int i = 0; i < noArr.Length; i++)
{
newId = -1;
seatNo = noArr[i].Trim();
EnterOutLogInfo enterOutLog = T_SM_EnterOutLog.GetUsingEnterOutLogBySeatNo(seatNo);
if (enterOutLog != null && enterOutLog.EnterOutState != EnterOutLogType.Leave)
{
ReadingRoomInfo roomInfo = T_SM_ReadingRoom.GetSingleRoomInfo(enterOutLog.ReadingRoomNo);
if (roomInfo != null && roomInfo.Setting.BlackListSetting.Used)
{
BlackListInfo blacklistModel = new BlackListInfo();
blacklistModel.AddTime = ServiceDateTime.Now;
blacklistModel.ReadingRoomID = roomInfo.No;
blacklistModel.BlacklistState = LogStatus.Valid;
blacklistModel.CardNo = enterOutLog.CardNo;
blacklistModel.OutBlacklistMode = roomInfo.Setting.BlackListSetting.LeaveBlacklist;
if (blacklistModel.OutBlacklistMode == LeaveBlacklistMode.AutomaticMode)
{
blacklistModel.ReMark = string.Format("管理员{0}通过手持设备{0}把读者加入黑名单，记录黑名单{1}天", Session["LoginID"], roomInfo.Setting.BlackListSetting.LimitDays);
blacklistModel.OutTime = blacklistModel.AddTime.AddDays(roomInfo.Setting.BlackListSetting.LimitDays);
}
else
{
blacklistModel.ReMark = string.Format("管理员{0}通过手持设备把读者加入黑名单，手动离开黑名单", Session["LoginID"]);
}
blacklistModel.ReadingRoomID = roomInfo.No;
newId = T_SM_Blacklist.AddBlackList(blacklistModel);
}
else if (rulesSet.BlacklistSet.Used)
{
BlackListInfo blacklistModel = new BlackListInfo();
blacklistModel.AddTime = ServiceDateTime.Now;
blacklistModel.OutTime = blacklistModel.AddTime.AddDays(rulesSet.BlacklistSet.LimitDays);
blacklistModel.BlacklistState = LogStatus.Valid;
blacklistModel.CardNo = enterOutLog.CardNo;
blacklistModel.OutBlacklistMode = rulesSet.BlacklistSet.LeaveBlacklist;
if (blacklistModel.OutBlacklistMode == LeaveBlacklistMode.AutomaticMode)
{
blacklistModel.ReMark = string.Format("管理员{0}通过手持设备把读者加入黑名单，记录黑名单{1}天", Session["LoginID"], rulesSet.BlacklistSet.LimitDays);
blacklistModel.OutTime = blacklistModel.AddTime.AddDays(rulesSet.BlacklistSet.LimitDays);
}
else
{
blacklistModel.ReMark = string.Format("管理员{0}通过手持设备把读者加入黑名单，手动离开黑名单", Session["LoginID"]);
}
blacklistModel.ReadingRoomID = roomInfo.No;
newId = T_SM_Blacklist.AddBlackList(blacklistModel);
}
else
{
Page.RegisterStartupScript("", "<script>alert('对不起，此阅览室以及图书馆没有启用黑名单功能');</script>");
return;
}
if (newId > 0)
{
enterOutLog.EnterOutState = EnterOutLogType.Leave;
enterOutLog.Flag = Operation.Admin;
enterOutLog.Remark = string.Format("在{0}，{1}号座位，被管理员{2}，通过手持设备设置离开", roomInfo.Name, enterOutLog.ShortSeatNo, Session["LoginID"]);
HandleResult result = EnterOutOperate.AddEnterOutLog(enterOutLog, ref newId);
if (result == HandleResult.Successed)
{
Page.RegisterStartupScript("", "<script>alert('设置读者黑名单成功');</script>");
GetSeatList(selectReadingRomm.Items[selectReadingRomm.SelectedIndex].Value, selectSeatState.Items[selectSeatState.SelectedIndex].Value);
}
else
{
Page.RegisterStartupScript("", "<script>alert('设置读者黑名单失败');</script>");
}
}
}
}
}
catch
{
}
break;
case "LoginOut":
HttpCookie aCookie;
string cookieName;
int limit = Request.Cookies.Count;
for (int i = 0; i < limit; i++)
{
cookieName = Request.Cookies[i].Name;
aCookie = new HttpCookie(cookieName);
aCookie.Expires = DateTime.Now.AddDays(-1);
Response.Cookies.Add(aCookie);
}
Response.Redirect("../Login.aspx");
break;
}
#endregion
}
}
/// <summary>
/// 预约等待
/// </summary>
public void BespeakSeatWait()
{
DateTime nowDate = ServiceDateTime.Now;
if (clientobject.EnterOutLogData.Student.BespeakLog.Count > 0)
{
BespeakLogInfo bespeaklog = clientobject.EnterOutLogData.Student.BespeakLog[0];
//if (!SelectSeatProven.CheckReadingRoomInThisClient(bespeaklog.ReadingRoomNo, clientobject.ClientSetting.DeviceSetting))
//{ //验证房间号是否属于本触摸屏所管理的阅览室
// Tip_Framework uc = new Tip_Framework(TipType.BeapeatRoomNotExists, 9);
//}
ReadingRoomSetting set = clientobject.EnterOutLogData.Student.AtReadingRoom.Setting;
DateTime dtBegin = bespeaklog.BsepeakTime.AddMinutes(-double.Parse(set.SeatBespeak.ConfirmTime.BeginTime));
DateTime dtEnd = bespeaklog.BsepeakTime.AddMinutes(double.Parse(set.SeatBespeak.ConfirmTime.EndTime));
if (DateTimeOperate.DateAccord(dtBegin, dtEnd, nowDate))
{
//TODO:预约时间在开始时间和结束时间之间，执行预约确认操作
//TODO:预约确认时，判断当前座位上是否有人。
EnterOutLogInfo seatUsedInfo = T_SM_EnterOutLog.GetUsingEnterOutLogBySeatNo(bespeaklog.SeatNo);
if (seatUsedInfo != null && seatUsedInfo.EnterOutState != EnterOutLogType.Leave)
{ //条件满足，说明座位正在使用。
seatUsedInfo.EnterOutState = EnterOutLogType.Leave;
seatUsedInfo.EnterOutType = LogStatus.Valid;
seatUsedInfo.TerminalNum = clientobject.ClientSetting.ClientNo;
seatUsedInfo.Remark = string.Format("预约该座位的读者在终端{0}刷卡确认入座，设置在座读者离开", clientobject.ClientSetting.ClientNo);
seatUsedInfo.Flag = Operation.OtherReader;
int newId = -1;
EnterOutOperate.AddEnterOutLog(seatUsedInfo, ref newId);
}
EnterOutLogInfo newEnterOutLog = new EnterOutLogInfo();//构造
newEnterOutLog.CardNo = bespeaklog.CardNo;
newEnterOutLog.EnterOutLogNo = SeatComm.RndNum();
newEnterOutLog.EnterOutState = EnterOutLogType.BookingConfirmation;
newEnterOutLog.EnterOutType = LogStatus.Valid;
newEnterOutLog.Flag = Operation.Reader;
newEnterOutLog.ReadingRoomNo = bespeaklog.ReadingRoomNo;
newEnterOutLog.SeatNo = bespeaklog.SeatNo;
newEnterOutLog.TerminalNum = clientobject.ClientSetting.ClientNo;
newEnterOutLog.Remark = string.Format("在终端{0}刷卡，入座预约的{1} {2}号座位", clientobject.ClientSetting.ClientNo, bespeaklog.ReadingRoomName, bespeaklog.ShortSeatNum);
int logid = -1;
HandleResult result = EnterOutOperate.AddEnterOutLog(newEnterOutLog, ref logid); //添加入座记录
if (result == HandleResult.Successed)
{
bespeaklog.BsepeakState = BookingStatus.Confinmed;
bespeaklog.CancelPerson = Operation.Reader;
bespeaklog.CancelTime = nowDate;
bespeaklog.Remark = string.Format("在终端{0}刷卡，入座预约的{1} {2}号座位", clientobject.ClientSetting.ClientNo, bespeaklog.ReadingRoomName, bespeaklog.ShortSeatNum);
T_SM_SeatBespeak.UpdateBespeakList(bespeaklog);
PrintData data = new PrintData();
data.CardNo = bespeaklog.CardNo;;
data.EnterTime = nowDate;
data.ReaderName = clientobject.EnterOutLogData.Student.Name;
data.ReadingRoomName = clientobject.EnterOutLogData.Student.AtReadingRoom.Name;
data.SeatNo = SeatComm.SeatNoToShortSeatNo(set.SeatNumAmount, bespeaklog.SeatNo);
if (clientobject.ClientSetting.DeviceSetting.UsingPrintSlip)
{
printer.Print(PrintStatus.Book, data, clientobject.ClientSetting.ClientNo);//打印
}
}
Tip_Framework tip = new Tip_Framework(TipType.BespeatSeatConfirmSuccess, 9);
tip.ShowDialog();
}
else if (nowDate.CompareTo(dtBegin) < 0)
{
//TODO:预约时间过早，请在dtBegin 到dtEnd刷卡确认。
BookConfirmWarn tipFrom = new BookConfirmWarn();
tipFrom.BeginTime = bespeaklog.BsepeakTime.AddMinutes(-double.Parse(set.SeatBespeak.ConfirmTime.BeginTime)).ToString("HH:mm");
tipFrom.EndTime = bespeaklog.BsepeakTime.AddMinutes(double.Parse(set.SeatBespeak.ConfirmTime.EndTime)).ToString("HH:mm");
tipFrom.ShowDialog();
}
else if (nowDate.CompareTo(dtEnd) < 0)
{
//TODO:最迟确认时间为：dtEnd。
}
else
{
//TODO:未知原因，预约确认失败。
}
}
}
/// <summary>
/// 预约签到
/// </summary>
/// <param name="bookNo"></param>
/// <returns></returns>
public string ConfigSeat(int bookNo)
{
try
{
DateTime nowDate = DateTime.Now;
BespeakLogInfo bespeaklog = seatManage.GetBespeaklogById(bookNo);
if (bespeaklog == null)
{
return("获取预约记录失败");
}
if (bespeaklog.BsepeakState != BookingStatus.Waiting)
{
return("此条记录状态无效，请查询刷新页面");
}
List <ReadingRoomInfo> rooms = seatManage.GetReadingRoomInfo(new List <string>()
{
bespeaklog.ReadingRoomNo
});
if (rooms.Count < 1)
{
return("阅览室设置获取失败");
}
ReadingRoomSetting set = rooms[0].Setting;
DateTime dtBegin = bespeaklog.BsepeakTime.AddMinutes(-double.Parse(set.SeatBespeak.ConfirmTime.BeginTime));
DateTime dtEnd = bespeaklog.BsepeakTime.AddMinutes(double.Parse(set.SeatBespeak.ConfirmTime.EndTime));
if (DateTimeOperate.DateAccord(dtBegin, dtEnd, nowDate) || (set.SeatBespeak.NowDayBespeak && bespeaklog.SubmitTime == bespeaklog.BsepeakTime))
{
//TODO:预约时间在开始时间和结束时间之间，执行预约确认操作
//TODO:预约确认时，判断当前座位上是否有人。
EnterOutLogInfo seatUsedInfo = seatManage.GetEnterOutLogInfoBySeatNum(bespeaklog.SeatNo);
if (seatUsedInfo != null && seatUsedInfo.EnterOutState != EnterOutLogType.Leave)
{ //条件满足，说明座位正在使用。
seatUsedInfo.EnterOutState = EnterOutLogType.Leave;
seatUsedInfo.EnterOutType = LogStatus.Valid;
seatUsedInfo.Remark = string.Format("预约该座位的读者在手机网站签到入座，设置在座读者离开");
seatUsedInfo.Flag = Operation.OtherReader;
int newId = -1;
if (seatManage.AddEnterOutLogInfo(seatUsedInfo, ref newId) == HandleResult.Successed)
{
List <WaitSeatLogInfo> waitInfoList = seatManage.GetWaitLogList(null, seatUsedInfo.EnterOutLogID, null, null, null);
if (waitInfoList.Count > 0)
{
WaitSeatLogInfo WaitSeatLogModel = waitInfoList[0];
WaitSeatLogModel.OperateType = Operation.Reader;
WaitSeatLogModel.WaitingState = EnterOutLogType.WaitingCancel;
WaitSeatLogModel.NowState = LogStatus.Valid;
if (!seatManage.UpdateWaitLog(WaitSeatLogModel))
{
return("取消等待此座位的读者状态失败");
}
}
}
else
{
return("设置当前使用此座位的读者离开失败");
}
}
EnterOutLogInfo newEnterOutLog = new EnterOutLogInfo();//构造
newEnterOutLog.CardNo = bespeaklog.CardNo;
newEnterOutLog.EnterOutLogNo = SeatComm.RndNum();
newEnterOutLog.EnterOutState = EnterOutLogType.BookingConfirmation;
newEnterOutLog.EnterOutType = LogStatus.Valid;
newEnterOutLog.Flag = Operation.Reader;
newEnterOutLog.ReadingRoomNo = bespeaklog.ReadingRoomNo;
newEnterOutLog.ReadingRoomName = bespeaklog.ReadingRoomName;
newEnterOutLog.ShortSeatNo = bespeaklog.ShortSeatNum;
newEnterOutLog.SeatNo = bespeaklog.SeatNo;
newEnterOutLog.Remark = string.Format("在手机预约网站预约签到，入座预约的{0} {1}号座位", bespeaklog.ReadingRoomName, bespeaklog.ShortSeatNum);
int logid = -1;
HandleResult result = seatManage.AddEnterOutLogInfo(newEnterOutLog, ref logid); //添加入座记录
if (result == HandleResult.Successed)
{
bespeaklog.BsepeakState = BookingStatus.Confinmed;
bespeaklog.CancelPerson = Operation.Reader;
bespeaklog.CancelTime = nowDate;
bespeaklog.Remark = string.Format("在手机预约网站预约签到，入座预约的{0} {1}号座位", bespeaklog.ReadingRoomName, bespeaklog.ShortSeatNum);
if (seatManage.UpdateBespeakLogInfo(bespeaklog) > 0)
{
return("");
}
else
{
return("系统错误，签到失败");
}
}
else
{
return("系统错误，签到失败");
}
}
else if (nowDate.CompareTo(dtBegin) < 0)
{
//TODO:预约时间过早，请在dtBegin 到dtEnd刷卡确认。
return("对不起，您预约的座位尚未到达签到时间，请在" + dtBegin.ToShortTimeString() + "到" + dtEnd.ToShortTimeString() + "间进行签到");
}
else if (nowDate.CompareTo(dtEnd) < 0)
{
return("对不起，您预约已超时");
}
else
{
return("系统错误，签到失败");
}
}
catch (Exception ex)
{
SeatManageComm.WriteLog.Write(string.Format("预约签到失败：{0}", ex.Message));
return("系统错误，签到失败");
}
}
/// <summary>
/// 等待座位
/// </summary>
/// <returns></returns>
public bool WaitSeat(SeatButton seatBtn)
{
WaitSeatLogInfo lastWaitInfo = T_SM_SeatWaiting.GetListWaitLogByCardNo(clientObject.EnterOutLogData.EnterOutlog.CardNo, clientObject.EnterOutLogData.EnterOutlog.ReadingRoomNo);
ReadingRoomInfo roomInfo = clientObject.EnterOutLogData.Student.AtReadingRoom;
if (!string.IsNullOrEmpty(clientObject.EnterOutLogData.EnterOutlog.SeatNo))
{
MessageWindow popWindow = new MessageWindow(SeatManage.EnumType.MessageType.WaitSeatWithSeat);
CountDown.Pause();
popWindow.ShowDialog();
CountDown.Start();
return(false);
}
if (lastWaitInfo != null && lastWaitInfo.SeatWaitTime.AddMinutes(roomInfo.Setting.NoManagement.OperatingInterval).CompareTo(ServiceDateTime.Now) >= 0)
{
clientObject.EnterOutLogData.Student.WaitSeatLog = lastWaitInfo;
MessageWindow popWindow = new MessageWindow(SeatManage.EnumType.MessageType.WaitSeatFrequent);
CountDown.Pause();
popWindow.ShowDialog();
CountDown.Start();
return(false);
}
SeatManage.EnumType.SeatLockState lockseat = T_SM_Seat.LockSeat(seatBtn.SeatNo);
if (lockseat == SeatManage.EnumType.SeatLockState.Locked)//座位成功加锁
{
clientObject.EnterOutLogData.WaitSeatLogModel = new WaitSeatLogInfo()
{
SeatNo = seatBtn.ShortSeatNo
};
MessageWindow popWindow = new MessageWindow(SeatManage.EnumType.MessageType.WaitSeatConfirm);
CountDown.Pause();
popWindow.ShowDialog();
CountDown.Start();
if (popWindow.viewModel.OperateResule == SeatManage.EnumType.HandleResult.Successed)
{
//初始化等待记录 记录ID需要待执行之后添加。
WaitSeatLogInfo waitInfo = new WaitSeatLogInfo();
waitInfo.CardNo = clientObject.EnterOutLogData.EnterOutlog.CardNo;
waitInfo.NowState = SeatManage.EnumType.LogStatus.Valid;
waitInfo.OperateType = SeatManage.EnumType.Operation.Reader;
waitInfo.WaitingState = SeatManage.EnumType.EnterOutLogType.Waiting;
EnterOutLogInfo seatUsingEnterOutInfo = SeatManage.Bll.T_SM_EnterOutLog.GetUsingEnterOutLogBySeatNo(seatBtn.SeatNo);
seatUsingEnterOutInfo.EnterOutState = SeatManage.EnumType.EnterOutLogType.ShortLeave;
seatUsingEnterOutInfo.EnterOutType = SeatManage.EnumType.LogStatus.Valid;
seatUsingEnterOutInfo.Flag = SeatManage.EnumType.Operation.OtherReader;
seatUsingEnterOutInfo.TerminalNum = clientObject.ClientSetting.ClientNo;
seatUsingEnterOutInfo.Remark = string.Format("在{0} {1}号座位，被读者{2}在终端{3}设置为暂离并等待该座位", seatUsingEnterOutInfo.ReadingRoomName, seatUsingEnterOutInfo.ShortSeatNo, waitInfo.CardNo, clientObject.ClientSetting.ClientNo);
clientObject.EnterOutLogData.EnterOutlog = seatUsingEnterOutInfo; //要等待读者的暂离记录
clientObject.EnterOutLogData.WaitSeatLogModel = waitInfo; //等待记录
return(true);
}
else
{
T_SM_Seat.UnLockSeat(seatBtn.SeatNo);//确认窗口点击取消或者自动关闭，则解锁。
}
}
else if (lockseat == SeatManage.EnumType.SeatLockState.UnLock)//没有成功加锁
{
MessageWindow popWindow = new MessageWindow(SeatManage.EnumType.MessageType.SeatIsLocked);
CountDown.Pause();
popWindow.ShowDialog();
CountDown.Start();
}
return(false);
}
