/// <summary>
/// 增加一条数据
/// </summary>
public int Add(WaitSeatLogInfo model)
{
StringBuilder strSql = new StringBuilder();
strSql.Append("insert into T_SM_SeatWaiting(");
strSql.Append("CardNo,EnterOutLogID,WaitingState,OperateType,StateChangeTime)");
strSql.Append(" values (");
strSql.Append("@CardNo,@EnterOutLogID,@WaitingState,@OperateType,@StateChangeTime)");
strSql.Append(";select @@IDENTITY");
SqlParameter[] parameters =
{
new SqlParameter("@CardNo", SqlDbType.NVarChar, 50),
new SqlParameter("@EnterOutLogID", SqlDbType.Int, 4),
new SqlParameter("@WaitingState", SqlDbType.Int, 4),
new SqlParameter("@OperateType", SqlDbType.Int, 4),
new SqlParameter("@StateChangeTime", SqlDbType.DateTime)
};
parameters[0].Value = model.CardNo;
parameters[1].Value = model.EnterOutLogID;
parameters[2].Value = model.WaitingState;
parameters[3].Value = model.OperateType;
parameters[4].Value = model.StatsChangeTime;
object obj = DbHelperSQL.GetSingle(strSql.ToString(), parameters);
if (obj == null)
{
return(0);
}
else
{
return(Convert.ToInt32(obj));
}
}
/// <summary>
/// 等待座位
/// </summary>
public void WaitingSeat()
{
WaitSeatLogInfo waitLog = clientobject.EnterOutLogData.Student.WaitSeatLog;
ReadingRoomInfo roomInfo = clientobject.EnterOutLogData.Student.AtReadingRoom;
string shortSeatNo = SeatComm.SeatNoToShortSeatNo(roomInfo.Setting.SeatNumAmount, waitLog.SeatNo);
WaitSeatCancel askForm = new WaitSeatCancel(roomInfo.Name, shortSeatNo);
askForm.ShowDialog();
if (askForm.IsTrue)
{
//处理等待记录的Id
this.clientobject.EnterOutLogData.WaitSeatLogModel = waitLog;
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))
{ //恢复读者的在座状态
this.clientobject.EnterOutLogData.EnterOutlog = T_SM_EnterOutLog.GetEnterOutLogInfoById(this.clientobject.EnterOutLogData.WaitSeatLogModel.EnterOutLogID);
System.TimeSpan shortleavetimelong = ServiceDateTime.Now - clientobject.EnterOutLogData.EnterOutlog.EnterOutTime;
this.clientobject.EnterOutLogData.EnterOutlog.EnterOutState = EnterOutLogType.ComeBack;
this.clientobject.EnterOutLogData.EnterOutlog.EnterOutType = LogStatus.Valid;
this.clientobject.EnterOutLogData.EnterOutlog.Flag = Operation.OtherReader;
clientobject.EnterOutLogData.EnterOutlog.TerminalNum = clientobject.ClientSetting.ClientNo;
this.clientobject.EnterOutLogData.EnterOutlog.Remark = string.Format("读者{0}在{1}终端取消等待{2} {3}号座位，您暂离{4}分钟后恢复为在座状态",
this.clientobject.EnterOutLogData.WaitSeatLogModel.CardNo,
this.clientobject.ClientSetting.ClientNo,
this.clientobject.EnterOutLogData.EnterOutlog.ReadingRoomName,
this.clientobject.EnterOutLogData.EnterOutlog.ShortSeatNo,
shortleavetimelong.Minutes);
int newId = -1;
EnterOutOperate.AddEnterOutLog(this.clientobject.EnterOutLogData.EnterOutlog, ref newId);
}
}
}
/// <summary>
/// 获取读者最后一条等待记录
/// </summary>
/// <param name="cardNo"></param>
/// <returns></returns>
public WaitSeatLogInfo GetListWaitLogByCardNo(string cardNo, string roomNum)
{
StringBuilder strSql = new StringBuilder();
if (!string.IsNullOrEmpty(cardNo))
{
strSql.Append(string.Format(" cardNo='{0}'", cardNo));
}
if (!string.IsNullOrEmpty(roomNum))
{
if (!string.IsNullOrEmpty(strSql.ToString()))
{
strSql.Append(string.Format(" and ReadingRoomNo ='{0}'", roomNum));
}
else
{
strSql.Append(string.Format(" ReadingRoomNo ='{0}'", roomNum));
}
}
DataSet ds = t_sm_seatwaiting_dal.GetList(1, strSql.ToString(), "[StateChangeTime] desc", null);
WaitSeatLogInfo waitSeatLog = null;
if (ds.Tables[0].Rows.Count > 0)
{
waitSeatLog = DataRowToWaitSeatLogInfo(ds.Tables[0].Rows[0]);
}
return(waitSeatLog);
}
public bool IsCanWaitSeat(string CardNo, string roomNo)
{
try
{
WaitSeatLogInfo lastWaitInfo = seatManage.GetListWaitLogByCardNo(CardNo, roomNo);
if (lastWaitInfo == null)
{
return(true);
}
List <ReadingRoomInfo> roomInfos = seatManage.GetReadingRooms(new List <string>()
{
roomNo
}, null, null);
if (roomInfos.Count > 0)
{
if (lastWaitInfo != null && lastWaitInfo.SeatWaitTime.AddMinutes(roomInfos[0].Setting.NoManagement.OperatingInterval).CompareTo(DateTime.Now) >= 0)
{
return(false);
}
else
{
return(true);
}
}
else
{
throw new Exception("获取信息失败!");
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 等待座位
/// </summary>
public void WaitingSeat()
{
WaitSeatLogInfo waitLog = Clientobject.EnterOutLogData.Student.WaitSeatLog;
//ReadingRoomInfo roomInfo = Clientobject.EnterOutLogData.Student.AtReadingRoom;
//string shortSeatNo = SeatComm.SeatNoToShortSeatNo(roomInfo.Setting.SeatNumAmount, waitLog.SeatNo);
PopupWindowsObject.GetInstance().Window.ShowMessage(TipType.WaitSeatCancelWarn);
if (PopupWindowsObject.GetInstance().Window.ViewModel.OperateResule != HandleResult.Successed)
{
return;
}
//处理等待记录的Id
Clientobject.EnterOutLogData.WaitSeatLogModel = waitLog;
Clientobject.EnterOutLogData.WaitSeatLogModel.OperateType = Operation.Reader;
Clientobject.EnterOutLogData.WaitSeatLogModel.WaitingState = EnterOutLogType.WaitingCancel;
Clientobject.EnterOutLogData.WaitSeatLogModel.NowState = LogStatus.Valid;
if (!T_SM_SeatWaiting.UpdateWaitLog(Clientobject.EnterOutLogData.WaitSeatLogModel))
{
PopupWindowsObject.GetInstance().Window.ShowMessage(TipType.Exception);
return; //恢复读者的在座状态
}
Clientobject.EnterOutLogData.EnterOutlog = T_SM_EnterOutLog.GetEnterOutLogInfoById(Clientobject.EnterOutLogData.WaitSeatLogModel.EnterOutLogID);
TimeSpan shortleavetimelong = ServiceDateTime.Now - Clientobject.EnterOutLogData.EnterOutlog.EnterOutTime;
Clientobject.EnterOutLogData.EnterOutlog.EnterOutState = EnterOutLogType.ComeBack;
Clientobject.EnterOutLogData.EnterOutlog.EnterOutType = LogStatus.Valid;
Clientobject.EnterOutLogData.EnterOutlog.Flag = Operation.OtherReader;
Clientobject.EnterOutLogData.EnterOutlog.TerminalNum = Clientobject.ClientSetting.ClientNo;
Clientobject.EnterOutLogData.EnterOutlog.Remark = string.Format("读者{0}在{1}终端取消等待{2} {3}号座位，您暂离{4}分钟后恢复为在座状态", Clientobject.EnterOutLogData.WaitSeatLogModel.CardNo, Clientobject.ClientSetting.ClientNo, Clientobject.EnterOutLogData.EnterOutlog.ReadingRoomName, Clientobject.EnterOutLogData.EnterOutlog.ShortSeatNo, shortleavetimelong.Minutes);
int newId = -1;
PopupWindowsObject.GetInstance().Window.ShowMessage(EnterOutOperate.AddEnterOutLog(Clientobject.EnterOutLogData.EnterOutlog, ref newId) == HandleResult.Successed ? TipType.WaitSeatCancel : TipType.Exception);
}
/// <summary>
/// 添加等待记录
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static int AddWaitSeatLog(WaitSeatLogInfo model)
{
IWCFService.ISeatManageService seatService = WcfAccessProxy.ServiceProxy.CreateChannelSeatManageService();
bool error = false;
try
{
return(seatService.AddWaitLog(model));
}
catch (Exception ex)
{
error = true;
SeatManageComm.WriteLog.Write("添加等待记录失败：" + ex.Message);
return(-1);
}
finally
{
ICommunicationObject ICommObjectService = seatService as ICommunicationObject;
try
{
if (ICommObjectService.State == CommunicationState.Faulted)
{
ICommObjectService.Abort();
}
else
{
ICommObjectService.Close();
}
}
catch
{
ICommObjectService.Abort();
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (this.LoginUserInfo == null || this.UserSchoolInfo == null)
{
Response.Redirect(LoginUrl());
}
seatNo = Request.QueryString["seatNo"];
seatShortNo = Request.QueryString["seatShortNo"];
roomNo = Request.QueryString["roomNo"];
if (!IsPostBack)
{
BindUIElement(seatNo, seatShortNo);
}
string cmd = Request.Form["subCmd"];
switch (cmd)
{
case "query":
WaitSeatLogInfo waitInfo = new WaitSeatLogInfo();
waitInfo.CardNo = this.LoginUserInfo.CardNo;
waitInfo.SeatNo = seatNo;
waitInfo.NowState = SeatManage.EnumType.LogStatus.Valid;
waitInfo.OperateType = SeatManage.EnumType.Operation.Reader;
waitInfo.WaitingState = SeatManage.EnumType.EnterOutLogType.Waiting;
try
{
string resultValue = handler.SubmitWaitInfo(this.UserSchoolInfo, waitInfo); //bookSeatMessageBll.AddBespeakLogInfo(bespeakModel, Session["SchoolConnectionString"].ToString());
if (!string.IsNullOrEmpty(resultValue))
{
page1.Style.Add("display", "none");
page2.Style.Add("display", "none");
page3.Style.Add("display", "block");
MessageTip.InnerText = resultValue;
this.LoginUserInfo = handler1.GetReaderInfo(this.UserSchoolInfo, this.LoginUserInfo.CardNo);
}
else
{
page1.Style.Add("display", "none");
page2.Style.Add("display", "none");
page3.Style.Add("display", "block");
MessageTip.InnerText = "未知错误";
return;
}
}
catch (Exception ex)
{
page1.Style.Add("display", "none");
page2.Style.Add("display", "none");
page3.Style.Add("display", "block");
MessageTip.InnerText = ex.Message;
return;
}
break;
}
}
/// <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);
}
}
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>
public void CometoBack()
{
Clientobject.EnterOutLogData.EnterOutlog.EnterOutState = EnterOutLogType.ComeBack;//设置读者状态为暂回来
Clientobject.EnterOutLogData.EnterOutlog.TerminalNum = Clientobject.ClientSetting.ClientNo;
TimeSpan shortleavetimelong = ServiceDateTime.Now - Clientobject.EnterOutLogData.EnterOutlog.EnterOutTime;
Clientobject.EnterOutLogData.EnterOutlog.Remark = string.Format("在终端{0}刷卡暂离回来，暂离时长{1}分钟，继续使用{2} {3}号座位", Clientobject.ClientSetting.ClientNo, shortleavetimelong.Minutes, Clientobject.EnterOutLogData.EnterOutlog.ReadingRoomName, Clientobject.EnterOutLogData.EnterOutlog.ShortSeatNo);
int newLogId = -1;
PopupWindowsObject.GetInstance().Window.ShowMessage(EnterOutOperate.AddEnterOutLog(Clientobject.EnterOutLogData.EnterOutlog, ref newLogId) == HandleResult.Failed ? TipType.Exception : TipType.ComeToBack);
if (Clientobject.EnterOutLogData.Student.AtReadingRoom.Setting.NoManagement.Used)
{
List <WaitSeatLogInfo> waitSeatLogs = T_SM_SeatWaiting.GetWaitSeatList("", Clientobject.EnterOutLogData.EnterOutlog.EnterOutLogID, null, null, null);
if (waitSeatLogs.Count > 0)
{
WaitSeatLogInfo waitSeatLog = waitSeatLogs[0];
waitSeatLog.NowState = LogStatus.Fail;
waitSeatLog.OperateType = Operation.OtherReader;
waitSeatLog.WaitingState = EnterOutLogType.WaitingCancel;
T_SM_SeatWaiting.UpdateWaitLog(waitSeatLog);
}
}
if (!Clientobject.EnterOutLogData.Student.AtReadingRoom.Setting.SeatUsedTimeLimit.Used)
{
return;
}
if (Clientobject.EnterOutLogData.Student.CanContinuedTime.AddMinutes(Clientobject.EnterOutLogData.Student.AtReadingRoom.Setting.SeatUsedTimeLimit.CanDelayTime) > ServiceDateTime.Now)
{
return;
}
if (Clientobject.EnterOutLogData.Student.AtReadingRoom.Setting.SeatUsedTimeLimit.ContinuedTimes == 0 || Clientobject.EnterOutLogData.Student.ContinuedTimeCount < Clientobject.EnterOutLogData.Student.AtReadingRoom.Setting.SeatUsedTimeLimit.ContinuedTimes)
{
Clientobject.EnterOutLogData.EnterOutlog.EnterOutState = EnterOutLogType.ContinuedTime;
Clientobject.EnterOutLogData.EnterOutlog.Flag = Operation.Service;
Clientobject.EnterOutLogData.EnterOutlog.TerminalNum = Clientobject.ClientSetting.ClientNo;
Clientobject.EnterOutLogData.EnterOutlog.Remark = string.Format("在终端{0}刷卡暂离回来，暂离期间在座超时，系统自动延长{1} {2}号座位使用时间", Clientobject.ClientSetting.ClientNo, Clientobject.EnterOutLogData.Student.AtReadingRoom.Name, Clientobject.EnterOutLogData.EnterOutlog.ShortSeatNo);
PopupWindowsObject.GetInstance().Window.ShowMessage(EnterOutOperate.AddEnterOutLog(Clientobject.EnterOutLogData.EnterOutlog, ref newLogId) == HandleResult.Successed ? TipType.AutoContinuedTime : TipType.Exception);
}
else
{
Clientobject.EnterOutLogData.EnterOutlog.EnterOutState = EnterOutLogType.Leave;
Clientobject.EnterOutLogData.EnterOutlog.Flag = Operation.Service;
Clientobject.EnterOutLogData.EnterOutlog.TerminalNum = Clientobject.ClientSetting.ClientNo;
Clientobject.EnterOutLogData.EnterOutlog.Remark = string.Format("在终端{0}刷卡暂离回来，暂离期间在座超时，续时次数已用完，系统自动释放{1} {2}号座位", Clientobject.ClientSetting.ClientNo, Clientobject.EnterOutLogData.Student.AtReadingRoom.Name, Clientobject.EnterOutLogData.EnterOutlog.ShortSeatNo);
PopupWindowsObject.GetInstance().Window.ShowMessage(EnterOutOperate.AddEnterOutLog(Clientobject.EnterOutLogData.EnterOutlog, ref newLogId) == HandleResult.Successed ? TipType.AutoContinuedTimeNoCount : TipType.Exception);
}
}
/// <summary>
/// 修改等待记录
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static bool UpdateWaitLog(WaitSeatLogInfo model)
{
IWCFService.ISeatManageService seatService = new WcfServiceForSeatManage.SeatManageDateService();
bool error = false;
try
{
return(seatService.UpdateWaitLog(model));
}
catch (Exception ex)
{
error = true;
SeatManageComm.WriteLog.Write("修改等待记录失败：" + ex.Message);
return(false);
}
}
private WaitSeatLogInfo DataRowToWaitSeatLogInfo(DataRow dr)
{
WaitSeatLogInfo wsli = new WaitSeatLogInfo();
//SeatWaitingID,CardNo,CardNoB,ReadingRoomNo,EnterOutLogID,SeatWaitTime,StateChangeTime,WaitingState,OperateType
wsli.SeatWaitingID = dr["SeatWaitingID"].ToString();
wsli.CardNo = dr["CardNo"].ToString();
wsli.CardNoB = dr["CardNoB"].ToString();
wsli.ReadingRoomNo = dr["ReadingRoomNo"].ToString();
wsli.EnterOutLogID = int.Parse(dr["EnterOutLogID"].ToString());
wsli.SeatWaitTime = DateTime.Parse(dr["SeatWaitTime"].ToString());
wsli.StatsChangeTime = DateTime.Parse(dr["StateChangeTime"].ToString());
wsli.WaitingState = (EnterOutLogType)int.Parse(dr["WaitingState"].ToString());
wsli.OperateType = (Operation)int.Parse(dr["OperateType"].ToString());
wsli.SeatNo = dr["SeatNo"].ToString();
return(wsli);
}
/// <summary>
/// 等待座位
/// </summary>
public void WaitingSeat()
{
WaitSeatLogInfo waitLog = clientobject.EnterOutLogData.Student.WaitSeatLog;
ReadingRoomInfo roomInfo = clientobject.EnterOutLogData.Student.AtReadingRoom;
string shortSeatNo = SeatComm.SeatNoToShortSeatNo(roomInfo.Setting.SeatNumAmount, waitLog.SeatNo);
MessageWindow popWindowCancel = new MessageWindow(MessageType.CancelWaitConfirm);
popWindowCancel.ShowDialog();
if (popWindowCancel.viewModel.OperateResule == HandleResult.Successed)
{
//处理等待记录的Id
this.clientobject.EnterOutLogData.WaitSeatLogModel = waitLog;
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))
{ //恢复读者的在座状态
this.clientobject.EnterOutLogData.EnterOutlog = T_SM_EnterOutLog.GetEnterOutLogInfoById(this.clientobject.EnterOutLogData.WaitSeatLogModel.EnterOutLogID);
System.TimeSpan shortleavetimelong = ServiceDateTime.Now - clientobject.EnterOutLogData.EnterOutlog.EnterOutTime;
this.clientobject.EnterOutLogData.EnterOutlog.EnterOutState = EnterOutLogType.ComeBack;
this.clientobject.EnterOutLogData.EnterOutlog.EnterOutType = LogStatus.Valid;
this.clientobject.EnterOutLogData.EnterOutlog.Flag = Operation.OtherReader;
clientobject.EnterOutLogData.EnterOutlog.TerminalNum = clientobject.ClientSetting.ClientNo;
this.clientobject.EnterOutLogData.EnterOutlog.Remark = string.Format("读者{0}在{1}终端取消等待{2} {3}号座位，您暂离{4}分钟后恢复为在座状态",
this.clientobject.EnterOutLogData.WaitSeatLogModel.CardNo,
this.clientobject.ClientSetting.ClientNo,
this.clientobject.EnterOutLogData.EnterOutlog.ReadingRoomName,
this.clientobject.EnterOutLogData.EnterOutlog.ShortSeatNo,
shortleavetimelong.Minutes);
int newId = -1;
if (EnterOutOperate.AddEnterOutLog(this.clientobject.EnterOutLogData.EnterOutlog, ref newId) == HandleResult.Successed)
{
MessageWindow popWindow = new MessageWindow(MessageType.CancleWaitSuccess);
popWindow.ShowDialog();
}
else
{
MessageWindow popWindow = new MessageWindow(MessageType.Exception);
popWindow.ShowDialog();
}
}
}
}
public string SubmitWaitInfo(WaitSeatLogInfo waitInfo)
{
try
{
SeatManage.ClassModel.EnterOutLogInfo enterOutLog = seatManage.GetEnterOutLogInfoBySeatNum(waitInfo.SeatNo);
if (enterOutLog == null)
{
return("等待座位失败，请刷新页面重新尝试");
}
if (enterOutLog.EnterOutState == EnterOutLogType.BookingConfirmation ||
enterOutLog.EnterOutState == EnterOutLogType.ComeBack ||
enterOutLog.EnterOutState == EnterOutLogType.ContinuedTime ||
enterOutLog.EnterOutState == EnterOutLogType.ReselectSeat ||
enterOutLog.EnterOutState == EnterOutLogType.SelectSeat ||
enterOutLog.EnterOutState == EnterOutLogType.WaitingSuccess)
{
enterOutLog.EnterOutState = SeatManage.EnumType.EnterOutLogType.ShortLeave;
enterOutLog.EnterOutType = SeatManage.EnumType.LogStatus.Valid;
enterOutLog.Flag = SeatManage.EnumType.Operation.OtherReader;
enterOutLog.Remark = string.Format("在{0} {1}号座位，被读者{2}在手机预约网站设置为暂离并等待该座位", enterOutLog.ReadingRoomName, enterOutLog.ShortSeatNo, waitInfo.CardNo);
int newLogId = -1;
HandleResult result = seatManage.AddEnterOutLogInfo(enterOutLog, ref newLogId);//插入进出记录
if (result == HandleResult.Successed)
{
waitInfo.EnterOutLogID = newLogId;
seatManage.AddWaitLog(waitInfo);
return(string.Format("您以成功等待{0} {1}号座位", enterOutLog.ReadingRoomName, enterOutLog.ShortSeatNo));
}
else
{
return("等待座位失败！");
}
}
else
{
return("此座位不能被等待，请重新选择！");
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 增加一条等待记录
/// </summary>
/// <param name="model">等待记录</param>
/// <returns></returns>
public int AddWaitLog(WaitSeatLogInfo model)
{
int r = t_sm_seatwaiting_dal.Add(model);
WaitSeatLogInfo wsli = GetListWaitLogByCardNo(model.CardNo, null);
if (wsli == null)
{
return(r);
}
PushMsgInfo msg = new PushMsgInfo();
msg.Title = "您好，您已等待成功";
msg.MsgType = MsgPushType.UserOperation;
msg.StudentNum = wsli.CardNo;
msg.SeatNum = wsli.EnterOutLog.ShortSeatNo;
msg.RoomName = wsli.EnterOutLog.ReadingRoomName;
msg.Message = string.Format("您已成功等待{0} {1}号座位。", msg.RoomName, msg.SeatNum);
SendMsg(msg);
return(r);
}
/// <summary>
/// 修改一条等待记录
/// </summary>
/// <param name="model">等待记录</param>
/// <returns></returns>
public bool UpdateWaitLog(WaitSeatLogInfo model)
{
model.SeatWaitTime = GetServerDateTime();
if (model.OperateType == Operation.OtherReader)
{
if (model.WaitingState == EnterOutLogType.WaitingCancel)
{
PushMsgInfo msg = new PushMsgInfo();
msg.Title = "您好，您等待已失效";
msg.MsgType = MsgPushType.UserOperation;
msg.StudentNum = model.CardNo;
msg.SeatNum = model.EnterOutLog.ShortSeatNo;
msg.RoomName = model.EnterOutLog.ReadingRoomName;
msg.Message = string.Format("您等待的{0} {1}号座位已取消", msg.RoomName, msg.SeatNum);
switch (model.OperateType)
{
case Operation.Admin:
msg.Message = string.Format("您等待的{0} {1}号座位已被管理员取消", msg.RoomName, msg.SeatNum);
break;
case Operation.OtherReader:
msg.Message = string.Format("原用户归来，您等待的{0} {1}号座位已取消", msg.RoomName, msg.SeatNum);
break;
case Operation.Service:
msg.Message = string.Format("您等待的{0} {1}号座位已被系统取消", msg.RoomName, msg.SeatNum);
break;
}
SendMsg(msg);
}
}
return(t_sm_seatwaiting_dal.Update(model));
}
/// <summary>
/// 更新一条数据
/// </summary>
public bool Update(WaitSeatLogInfo model)
{
StringBuilder strSql = new StringBuilder();
strSql.Append("update T_SM_SeatWaiting set ");
strSql.Append("CardNo=@CardNo,");
strSql.Append("EnterOutLogID=@EnterOutLogID,");
strSql.Append("StateChangeTime=@StateChangeTime,");
strSql.Append("WaitingState=@WaitingState,");
strSql.Append("OperateType=@OperateType");
strSql.Append(" where SeatWaitingID=@SeatWaitingID ");
SqlParameter[] parameters =
{
new SqlParameter("@CardNo", SqlDbType.NVarChar, 50),
new SqlParameter("@EnterOutLogID", SqlDbType.Int, 4),
new SqlParameter("@StateChangeTime", SqlDbType.DateTime),
new SqlParameter("@WaitingState", SqlDbType.Int, 4),
new SqlParameter("@OperateType", SqlDbType.Int, 4),
new SqlParameter("@SeatWaitingID", SqlDbType.Int, 4)
};
parameters[0].Value = model.CardNo;
parameters[1].Value = model.EnterOutLogID;
parameters[2].Value = model.SeatWaitTime;
parameters[3].Value = model.WaitingState;
parameters[4].Value = model.OperateType;
parameters[5].Value = model.SeatWaitingID;
int rows = DbHelperSQL.ExecuteSql(strSql.ToString(), parameters);
if (rows > 0)
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
///暂离回来
/// </summary>
public void CometoBack()
{
clientobject.ReaderInfo.EnterOutLog.EnterOutState = SeatManage.EnumType.EnterOutLogType.ComeBack;//设置读者状态为暂回来
clientobject.ReaderInfo.EnterOutLog.Flag = SeatManage.EnumType.Operation.Reader;
List <WaitSeatLogInfo> waitSeatLogs = T_SM_SeatWaiting.GetWaitSeatList("", clientobject.ReaderInfo.EnterOutLog.EnterOutLogID, null, null, null);
WaitSeatLogInfo waitSeatLog = null;
string clientType = "终端";
switch (LeaveClientSetting.LeaveState)
{
case LeaveState.FreeSeat:
clientType = "离开终端";
break;
case LeaveState.ShortLeave:
clientType = "暂离终端";
break;
case LeaveState.ContinuedTime:
clientType = "续时终端";
break;
case LeaveState.Choose:
clientType = "自助终端";
break;
}
int newLogId = -1;
System.TimeSpan shortleavetimelong = ServiceDateTime.Now - clientobject.ReaderInfo.EnterOutLog.EnterOutTime;
clientobject.ReaderInfo.EnterOutLog.Remark = string.Format("在{0}刷卡暂离回来，暂离时长{1}分钟，继续使用{2} {3}号座位",
clientType,
shortleavetimelong.Minutes,
clientobject.ReaderInfo.EnterOutLog.ReadingRoomName,
clientobject.ReaderInfo.EnterOutLog.ShortSeatNo);
clientobject.ReaderInfo.EnterOutLog.TerminalNum = clientobject.ClientSetting.ClientNo;
try
{
SeatManage.EnumType.HandleResult result = EnterOutOperate.AddEnterOutLog(clientobject.ReaderInfo.EnterOutLog, ref newLogId);//插入进出记录
if (result == SeatManage.EnumType.HandleResult.Successed)
{
if (waitSeatLogs.Count > 0)
{
waitSeatLog = waitSeatLogs[0];
waitSeatLog.NowState = SeatManage.EnumType.LogStatus.Fail;
waitSeatLog.OperateType = SeatManage.EnumType.Operation.OtherReader;
waitSeatLog.WaitingState = SeatManage.EnumType.EnterOutLogType.WaitingCancel;
T_SM_SeatWaiting.UpdateWaitLog(waitSeatLog);//取消等待
}
if (HandleResult != null)
{
HandleResult(string.Format(" 欢迎回来，您的座位在{0} {1}号。", clientobject.ReaderInfo.EnterOutLog.ReadingRoomName, clientobject.ReaderInfo.EnterOutLog.ShortSeatNo), SeatManage.EnumType.HandleResult.Successed);
if (clientobject.ReaderInfo.AtReadingRoom.Setting.SeatUsedTimeLimit.Used)
{
List <SeatManage.EnumType.EnterOutLogType> typeList = new List <SeatManage.EnumType.EnterOutLogType>();
typeList.Add(SeatManage.EnumType.EnterOutLogType.BookingConfirmation);
typeList.Add(SeatManage.EnumType.EnterOutLogType.SelectSeat);
typeList.Add(SeatManage.EnumType.EnterOutLogType.ReselectSeat);
typeList.Add(SeatManage.EnumType.EnterOutLogType.WaitingSuccess);
typeList.Add(SeatManage.EnumType.EnterOutLogType.ContinuedTime);
List <EnterOutLogInfo> seatTimeEnterOutLog = SeatManage.Bll.T_SM_EnterOutLog.GetEnterOutLogByNo(clientobject.ReaderInfo.EnterOutLog.EnterOutLogNo, typeList, 1);
if (seatTimeEnterOutLog.Count > 0)
{
if (seatTimeEnterOutLog[0].EnterOutState == SeatManage.EnumType.EnterOutLogType.ContinuedTime)
{
if (seatTimeEnterOutLog[0].EnterOutTime.AddMinutes(clientobject.ReaderInfo.AtReadingRoom.Setting.SeatUsedTimeLimit.DelayTimeLength) < ServiceDateTime.Now)
{
if (clientobject.ReaderInfo.AtReadingRoom.Setting.SeatUsedTimeLimit.ContinuedTimes == 0 || clientobject.ReaderInfo.ContinuedTimeCount < clientobject.ReaderInfo.AtReadingRoom.Setting.SeatUsedTimeLimit.ContinuedTimes)
{
clientobject.ReaderInfo.EnterOutLog.EnterOutState = SeatManage.EnumType.EnterOutLogType.ContinuedTime;
clientobject.ReaderInfo.EnterOutLog.TerminalNum = clientobject.ClientSetting.ClientNo;
clientobject.ReaderInfo.EnterOutLog.Remark = string.Format("在{0}刷卡暂离回来，暂离期间在座超时，系统自动延长{1}，{2}号座位使用时间", clientType, clientobject.ReaderInfo.AtReadingRoom.Name, clientobject.ReaderInfo.EnterOutLog.ShortSeatNo);
result = EnterOutOperate.AddEnterOutLog(clientobject.ReaderInfo.EnterOutLog, ref newLogId);//插入进出记录
if (result == SeatManage.EnumType.HandleResult.Successed)
{
HandleResult(string.Format(" 暂离期间在座超时，系统自动延长{0}，{1}号座位使用时间。", clientobject.ReaderInfo.EnterOutLog.ReadingRoomName, clientobject.ReaderInfo.EnterOutLog.ShortSeatNo), SeatManage.EnumType.HandleResult.Successed);
}
else
{
//TODO:错误提示
}
}
else
{
clientobject.ReaderInfo.EnterOutLog.EnterOutState = SeatManage.EnumType.EnterOutLogType.Leave;
clientobject.ReaderInfo.EnterOutLog.TerminalNum = clientobject.ClientSetting.ClientNo;
clientobject.ReaderInfo.EnterOutLog.Remark = string.Format("在{0}刷卡暂离回来，暂离期间在座超时，续时次数已用完，系统自动释放{1}，{2}号座位", clientType, clientobject.ReaderInfo.AtReadingRoom.Name, clientobject.ReaderInfo.EnterOutLog.ShortSeatNo);
result = EnterOutOperate.AddEnterOutLog(clientobject.ReaderInfo.EnterOutLog, ref newLogId);//插入进出记录
if (result == SeatManage.EnumType.HandleResult.Successed)
{
HandleResult(string.Format(" 暂离期间在座超时，续时次数已用完，系统自动释放{0}，{1}号座位。", clientobject.ReaderInfo.EnterOutLog.ReadingRoomName, clientobject.ReaderInfo.EnterOutLog.ShortSeatNo), SeatManage.EnumType.HandleResult.Successed);
}
else
{
//TODO:错误提示
}
}
}
}
else
{
if (seatTimeEnterOutLog[0].EnterOutTime.AddMinutes(clientobject.ReaderInfo.AtReadingRoom.Setting.SeatUsedTimeLimit.UsedTimeLength) < ServiceDateTime.Now)
{
if (clientobject.ReaderInfo.AtReadingRoom.Setting.SeatUsedTimeLimit.IsCanContinuedTime)
{
if (clientobject.ReaderInfo.AtReadingRoom.Setting.SeatUsedTimeLimit.ContinuedTimes == 0 || clientobject.ReaderInfo.ContinuedTimeCount < clientobject.ReaderInfo.AtReadingRoom.Setting.SeatUsedTimeLimit.ContinuedTimes)
{
clientobject.ReaderInfo.EnterOutLog.EnterOutState = SeatManage.EnumType.EnterOutLogType.ContinuedTime;
clientobject.ReaderInfo.EnterOutLog.TerminalNum = clientobject.ClientSetting.ClientNo;
clientobject.ReaderInfo.EnterOutLog.Remark = string.Format("在{0}刷卡暂离回来，暂离期间在座超时，系统自动延长{1}，{2}号座位使用时间", clientType, clientobject.ReaderInfo.AtReadingRoom.Name, clientobject.ReaderInfo.EnterOutLog.ShortSeatNo);
result = EnterOutOperate.AddEnterOutLog(clientobject.ReaderInfo.EnterOutLog, ref newLogId);//插入进出记录
if (result == SeatManage.EnumType.HandleResult.Successed)
{
HandleResult(string.Format(" 暂离期间在座超时，系统自动延长{0}，{1}号座位使用时间。", clientobject.ReaderInfo.EnterOutLog.ReadingRoomName, clientobject.ReaderInfo.EnterOutLog.ShortSeatNo), SeatManage.EnumType.HandleResult.Successed);
}
else
{
//TODO:错误提示
}
}
else
{
clientobject.ReaderInfo.EnterOutLog.EnterOutState = SeatManage.EnumType.EnterOutLogType.Leave;
clientobject.ReaderInfo.EnterOutLog.TerminalNum = clientobject.ClientSetting.ClientNo;
clientobject.ReaderInfo.EnterOutLog.Remark = string.Format("在{0}刷卡暂离回来，暂离期间在座超时，续时次数已用完，系统自动释放{1}，{2}号座位", clientType, clientobject.ReaderInfo.AtReadingRoom.Name, clientobject.ReaderInfo.EnterOutLog.ShortSeatNo);
result = EnterOutOperate.AddEnterOutLog(clientobject.ReaderInfo.EnterOutLog, ref newLogId);//插入进出记录
if (result == SeatManage.EnumType.HandleResult.Successed)
{
HandleResult(string.Format(" 暂离期间在座超时，续时次数已用完，系统自动释放{0}，{1}号座位。", clientobject.ReaderInfo.EnterOutLog.ReadingRoomName, clientobject.ReaderInfo.EnterOutLog.ShortSeatNo), SeatManage.EnumType.HandleResult.Successed);
}
else
{
//TODO:错误提示
}
}
}
else
{
clientobject.ReaderInfo.EnterOutLog.EnterOutState = SeatManage.EnumType.EnterOutLogType.Leave;
clientobject.ReaderInfo.EnterOutLog.TerminalNum = clientobject.ClientSetting.ClientNo;
clientobject.ReaderInfo.EnterOutLog.Remark = string.Format("在{0}刷卡暂离回来，暂离期间在座超时，系统自动释放{1}，{2}号座位", clientType, clientobject.ReaderInfo.AtReadingRoom.Name, clientobject.ReaderInfo.EnterOutLog.ShortSeatNo);
result = EnterOutOperate.AddEnterOutLog(clientobject.ReaderInfo.EnterOutLog, ref newLogId);//插入进出记录
if (result == SeatManage.EnumType.HandleResult.Successed)
{
HandleResult(string.Format(" 暂离期间在座超时，系统自动释放{0}，{1}号座位。", clientobject.ReaderInfo.EnterOutLog.ReadingRoomName, clientobject.ReaderInfo.EnterOutLog.ShortSeatNo), SeatManage.EnumType.HandleResult.Successed);
}
else
{
//TODO:错误提示
}
}
}
}
}
}
}
}
else
{
if (HandleResult != null)
{
HandleResult("操作失败！", SeatManage.EnumType.HandleResult.Failed);
}
}
}
catch (Exception ex)
{
SeatManage.SeatManageComm.WriteLog.Write(string.Format("读者{0}暂离回来操作失败：{1}", clientobject.ReaderInfo.CardNo, ex.Message));
if (HandleResult != null)
{
HandleResult("操作失败！", SeatManage.EnumType.HandleResult.Failed);
}
}
}
/// <summary>
/// 读者等待座位
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void seatBtn_WaitSeat(object sender, MouseButtonEventArgs e)
{
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))
{
SeatManage.SeatClient.Tip.Tip_Framework tipForm = new SeatManage.SeatClient.Tip.Tip_Framework(SeatManage.EnumType.TipType.WaitSeatWithSeat, 7);
countDownSeconds.Pause();
tipForm.ShowDialog();
countDownSeconds.Start();
return;
}
if (lastWaitInfo != null && lastWaitInfo.SeatWaitTime.AddMinutes(roomInfo.Setting.NoManagement.OperatingInterval).CompareTo(ServiceDateTime.Now) >= 0)
{
SeatManage.SeatClient.Tip.Tip_Framework tipForm = new SeatManage.SeatClient.Tip.Tip_Framework(SeatManage.EnumType.TipType.WaitSeatFrequent, 7);
countDownSeconds.Pause();
tipForm.ShowDialog();
countDownSeconds.Start();
return;
}
SeatButton seatBtn = sender as SeatButton;
SeatManage.EnumType.SeatLockState lockseat = T_SM_Seat.LockSeat(seatBtn.SeatNo);
if (lockseat == SeatManage.EnumType.SeatLockState.Locked)//座位成功加锁
{
SetShortWarning warnForm = new SetShortWarning(seatBtn.ShortSeatNo);
countDownSeconds.Pause();
warnForm.ShowDialog();
countDownSeconds.Start();
if (warnForm.IsTrue)
{
//初始化等待记录 记录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; //等待记录
this.Hide();
}
else
{
T_SM_Seat.UnLockSeat(seatBtn.SeatNo);//确认窗口点击取消或者自动关闭，则解锁。
}
}
else if (lockseat == SeatManage.EnumType.SeatLockState.UnLock) //没有成功加锁
{
SeatManage.SeatClient.Tip.Tip_Framework tip = new SeatManage.SeatClient.Tip.Tip_Framework(SeatManage.EnumType.TipType.SeatLocking, frmResolution.ViewModel.CountDownSeconds); //显示提示窗体
tip.ShowDialog();
drowSeatLayout();
}
}
/// <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="SaetNo">座位号</param>
/// <param name="enterOutLogNo">进出记录编号</param>
/// <param name="logStatus">记录状态</param>
/// <returns></returns>
public List <WaitSeatLogInfo> GetWaitLogList(string cardNo, string enterOutLogNo, string begindate, string enddate, List <EnterOutLogType> logType)
{
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(enterOutLogNo))
{
if (String.IsNullOrEmpty(strWhere.ToString()))
{
strWhere.Append(string.Format(" EnterOutLogID='{0}'", enterOutLogNo));
}
else
{
strWhere.Append(string.Format(" and EnterOutLogID='{0}'", enterOutLogNo));
}
}
if (!string.IsNullOrEmpty(begindate))
{
if (string.IsNullOrEmpty(strWhere.ToString()))
{
strWhere.AppendFormat(" StateChangeTime >= {0}", begindate);
}
else
{
strWhere.AppendFormat(" and StateChangeTime >= {0}", begindate);
}
}
if (!string.IsNullOrEmpty(enddate))
{
if (string.IsNullOrEmpty(strWhere.ToString()))
{
strWhere.AppendFormat(" StateChangeTime <= {0}", enddate);
}
else
{
strWhere.AppendFormat(" and StateChangeTime <= {0}", enddate);
}
}
if (logType != null && logType.Count > 0)
{
for (int i = 0; i < logType.Count; i++)
{
if (i == 0)
{
if (string.IsNullOrEmpty(strWhere.ToString()))
{
strWhere.AppendFormat(" WaitingState in ({0}", (int)logType[i]);
}
else
{
strWhere.AppendFormat(" and WaitingState in ({0}", (int)logType[i]);
}
}
else if (i != logType.Count - 1)
{
strWhere.Append(string.Format("，{0}", (int)logType[i]));
}
if (i == logType.Count - 1)
{
strWhere.Append(string.Format(" ,{0})", (int)logType[i]));
}
}
}
List <WaitSeatLogInfo> list = new List <WaitSeatLogInfo>();
try
{
DataSet ds = t_sm_seatwaiting_dal.GetList(strWhere.ToString(), null);
for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
{
WaitSeatLogInfo waitSeatLog = DataRowToWaitSeatLogInfo(ds.Tables[0].Rows[0]);
list.Add(waitSeatLog);
}
return(list);
}
catch
{
throw;
}
}
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
}
}
//private SeatManage.IPocketBespeak.IMainFunctionPageBll handler = new SeatManage.PocketBespeak.PocketBespeak_MainFunctionPageBll();
//private SeatManage.IPocketBespeak.IQueryLogs handler1 = new SeatManage.PocketBespeak.PocketBespeak_QueryLogs();
//private SeatManage.IPocketBespeak.IWaitSeat handler2 = new SeatManage.PocketBespeak.PocketBespeak_WaitSeat();
//private SeatManage.IPocketBespeak.IBespeakSeatListForm handler3 = new SeatManage.PocketBespeak.PocketBespeak_BespeakSeat();
protected void Page_Load(object sender, EventArgs e)
{
string strparam = Request.QueryString["param"];
if (string.IsNullOrEmpty(strparam))
{
spanWarmInfo.InnerText = "非正常的访问！";
divHanderPanel.Style.Add("display", "none");
return;
}
ScanCodeParamModel param = new ScanCodeParamModel(strparam);
seatNo = param.SeatNum;
readingRoomNo = param.ReadingRoomNum;
if (LoginUserInfo != null)//存在记录的cookies信息
{
cardNo = LoginUserInfo.CardNo;
}
else
{
string url = Request.Url.AbsoluteUri;
//string url = "/QRcodeDecode/SeatInfo.aspx?param=" + strparam;
Response.Redirect(LoginUrl() + "?url=" + url);
}
//UserInfo user = SeatManage.Bll.Users_ALL.GetUserInfo(cardNo);
//SeatManage.ClassModel.ManagerPotency potency = SeatManage.Bll.T_SM_ManagerPotency.GetManangePotencyByLoginID(cardNo);
//if (user == null || user.UserType != SeatManage.EnumType.UserType.Admin || potency.RightRoomList.All(u => u.No != readingRoomNo))
//{
// spanWarmInfo.InnerText = "您没有权限！";
// divHanderPanel.Style.Add("display", "none");
// return;
//}
if (!IsPostBack)
{
//DataBind(cardNo, param.SeatNum, param.ReadingRoomNum);
ShowReaderState();
}
else
{
string cmd = Request.Form["subCmd"];
string result;
switch (cmd)
{
case "changeSeat":
result = handler.ChangeSeat(cardNo, param.SeatNum, param.ReadingRoomNum);
if (!string.IsNullOrEmpty(result))
{
spanWarmInfo.InnerText = result;
}
else
{
spanWarmInfo.InnerText = "更换座位成功";
//DataBind(cardNo, param.SeatNum, param.ReadingRoomNum);
ShowReaderState();
//this.divHanderPanel.Style.Add("display", "none");
}
break;
case "selectSeat":
result = handler.SelectSeat(cardNo, param.SeatNum, param.ReadingRoomNum);
if (!string.IsNullOrEmpty(result))
{
spanWarmInfo.InnerText = result;
}
else
{
spanWarmInfo.InnerText = "选择座位成功";
//DataBind(cardNo, param.SeatNum, param.ReadingRoomNum);
ShowReaderState();
//this.divHanderPanel.Style.Add("display", "none");
}
break;
case "waitSeat":
if (!handler.IsCanWaitSeat(LoginUserInfo.CardNo, readingRoomNo))
{
spanWarmInfo.Visible = true;
spanWarmInfo.InnerText = "您等待座位的间隔过短，请稍后重试。";
}
else
{
WaitSeatLogInfo waitInfo = new WaitSeatLogInfo();
waitInfo.CardNo = LoginUserInfo.CardNo;
waitInfo.SeatNo = seatNo;
waitInfo.NowState = LogStatus.Valid;
waitInfo.OperateType = Operation.Reader;
waitInfo.WaitingState = EnterOutLogType.Waiting;
result = handler.SubmitWaitInfo(waitInfo);
if (!string.IsNullOrEmpty(result))
{
spanWarmInfo.InnerText = result;
}
else
{
spanWarmInfo.InnerText = "等待座位成功";
}
}
ShowReaderState();
break;
case "shortLeave":
shortLeaveHandle(); //设置读者暂离
//this.LoginUserInfo = handler.GetReaderInfo(this.UserSchoolInfo, this.LoginUserInfo.CardNo);//重新绑定读者状态
ShowReaderState();
break;
case "leave":
//释放读者座位
freeSeat();
//this.LoginUserInfo = handler.GetReaderInfo(this.UserSchoolInfo, this.LoginUserInfo.CardNo);
ShowReaderState();
break;
case "LoginOut":
Session.Clear();
Response.Cookies["userInfo"].Expires = DateTime.Now.AddDays(-1);
CookiesManager.RefreshNum = 0;
Response.Redirect(LogoutUrl());
break;
case "ContinuedWhen":
LoginUserInfo = handler.GetReaderInfo(LoginUserInfo.CardNo);
if (LoginUserInfo.EnterOutLog != null && LoginUserInfo.EnterOutLog.EnterOutState != EnterOutLogType.Leave)
{
switch (LoginUserInfo.EnterOutLog.EnterOutState)
{
case EnterOutLogType.BookingConfirmation:
case EnterOutLogType.SelectSeat:
case EnterOutLogType.ContinuedTime:
case EnterOutLogType.ComeBack:
case EnterOutLogType.ReselectSeat:
case EnterOutLogType.WaitingSuccess:
LoginUserInfo.EnterOutLog.Remark = "通过手机预约网站延长座位使用时间";
LoginUserInfo.EnterOutLog.EnterOutState = EnterOutLogType.ContinuedTime;
ContinuedWhen();
ShowReaderState();
break;
case EnterOutLogType.ShortLeave:
spanWarmInfo.Visible = true;
spanWarmInfo.InnerText = "续时失败，你处于暂离状态";
break;
}
}
else
{
spanWarmInfo.Visible = true;
spanWarmInfo.InnerText = "续时失败，您还没有选座";
}
break;
case "ComeBack":
LoginUserInfo = handler.GetReaderInfo(LoginUserInfo.CardNo);
if (LoginUserInfo.EnterOutLog != null && LoginUserInfo.EnterOutLog.EnterOutState == EnterOutLogType.ShortLeave)
{
LoginUserInfo.EnterOutLog.Remark = "通过手机预约网站恢复在座";
LoginUserInfo.EnterOutLog.EnterOutState = EnterOutLogType.ComeBack;
ComeBack();
ShowReaderState();
}
spanWarmInfo.Visible = true;
spanWarmInfo.InnerText = "暂离回来失败，您还没有暂离";
break;
case "cancel":
CancelBookLog(bookNo);
confrimSeat();
//this.LoginUserInfo = handler.GetReaderInfo(this.UserSchoolInfo, this.LoginUserInfo.CardNo);//重新绑定读者状态
ShowReaderState();
break;
case "CancelWait":
if (LoginUserInfo.WaitSeatLog != null)
{
spanWarmInfo.Visible = true;
spanWarmInfo.InnerText = handler.CancelWait(LoginUserInfo.WaitSeatLog);
ShowReaderState();
}
else
{
spanWarmInfo.Visible = true;
spanWarmInfo.InnerText = "当前没有等待的座位";
}
break;
case "CancelBook":
if (LoginUserInfo.BespeakLog != null && LoginUserInfo.BespeakLog.Count > 0)
{
spanWarmInfo.Visible = true;
if (handler.UpdateBookLogsState(int.Parse(LoginUserInfo.BespeakLog[0].BsepeaklogID)))
{
spanWarmInfo.InnerText = "取消预约成功";
//confrimSeat();
//this.LoginUserInfo = handler.GetReaderInfo(this.UserSchoolInfo, this.LoginUserInfo.CardNo);//重新绑定读者状态
ShowReaderState();
}
else
{
spanWarmInfo.InnerText = "取消预约取消失败";
}
}
else
{
spanWarmInfo.Visible = true;
spanWarmInfo.InnerText = "当前没有预约的座位";
}
break;
case "BookConfirm":
if (LoginUserInfo.BespeakLog != null && LoginUserInfo.BespeakLog.Count > 0)
{
confrimSeat();
//this.LoginUserInfo = handler.GetReaderInfo(this.UserSchoolInfo, this.LoginUserInfo.CardNo);//重新绑定读者状态
ShowReaderState();
}
else
{
spanWarmInfo.Visible = true;
spanWarmInfo.InnerText = "当前没有预约的座位";
}
break;
}
subCmd.Value = "";
}
}
/// <summary>
///
/// </summary>
/// <param name="cardNo"></param>
/// <returns></returns>
public string ComeBack(string cardNo)
{
try
{
JsonModel.JM_HandleResult result = new JsonModel.JM_HandleResult();
if (string.IsNullOrEmpty(cardNo))
{
result.Result = false;
result.Msg = "读者学号为空。";
return(SeatManageComm.JSONSerializer.Serialize(result));
}
ReaderInfo reader = seatDataService.GetReader(cardNo, true);
if (reader == null)
{
result.Result = false;
result.Msg = "获取读者信息失败。";
return(SeatManageComm.JSONSerializer.Serialize(result));
}
if (reader.EnterOutLog == null || reader.EnterOutLog.EnterOutState == EnterOutLogType.Leave)
{
result.Result = false;
result.Msg = "您还没有选座。";
return(SeatManageComm.JSONSerializer.Serialize(result));
}
if (reader.EnterOutLog.EnterOutState != EnterOutLogType.ShortLeave)
{
result.Result = false;
result.Msg = "您当前不是暂离状态。";
return(SeatManageComm.JSONSerializer.Serialize(result));
}
reader.EnterOutLog.EnterOutState = EnterOutLogType.ComeBack;
reader.EnterOutLog.Remark = "读者通过移动客户端设置暂离回来。";
reader.EnterOutLog.Flag = Operation.Reader;
reader.EnterOutLog.EnterOutTime = DateTime.Now;
result.Result = true;
int newId = -1;
if (seatDataService.AddEnterOutLogInfo(reader.EnterOutLog, ref newId) != HandleResult.Successed)
{
result.Result = false;
result.Msg = "执行遇到异常!";
return(SeatManage.SeatManageComm.JSONSerializer.Serialize(result));
}
else
{
result.Result = true;
result.Msg = "欢迎回来";
List <WaitSeatLogInfo> waitSeatLogs = seatDataService.GetWaitLogList("", reader.EnterOutLog.EnterOutLogID, null, null, null);
if (waitSeatLogs.Count > 0)
{
WaitSeatLogInfo waitSeatLog = waitSeatLogs[0];
waitSeatLog.NowState = LogStatus.Fail;
waitSeatLog.OperateType = Operation.OtherReader;
waitSeatLog.WaitingState = EnterOutLogType.WaitingCancel;
seatDataService.UpdateWaitLog(waitSeatLog);
}
}
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>
public void CometoBack()
{
clientobject.EnterOutLogData.EnterOutlog.EnterOutState = EnterOutLogType.ComeBack;//设置读者状态为暂回来
clientobject.EnterOutLogData.EnterOutlog.Flag = Operation.Reader;
List <WaitSeatLogInfo> waitSeatLogs = T_SM_SeatWaiting.GetWaitSeatList("", clientobject.EnterOutLogData.EnterOutlog.EnterOutLogID, null, null, null);
WaitSeatLogInfo waitSeatLog = null;
int newLogId = -1;
System.TimeSpan shortleavetimelong = ServiceDateTime.Now - clientobject.EnterOutLogData.EnterOutlog.EnterOutTime;
clientobject.EnterOutLogData.EnterOutlog.Remark = string.Format("在终端{0}刷卡暂离回来，暂离时长{1}分钟，继续使用{2} {3}号座位",
clientobject.ClientSetting.ClientNo,
shortleavetimelong.Minutes,
clientobject.EnterOutLogData.EnterOutlog.ReadingRoomName,
clientobject.EnterOutLogData.EnterOutlog.ShortSeatNo);
clientobject.EnterOutLogData.EnterOutlog.TerminalNum = clientobject.ClientSetting.ClientNo;
HandleResult result = EnterOutOperate.AddEnterOutLog(clientobject.EnterOutLogData.EnterOutlog, ref newLogId);//插入进出记录
if (result == HandleResult.Successed)
{
if (waitSeatLogs.Count > 0)
{
waitSeatLog = waitSeatLogs[0];
waitSeatLog.NowState = LogStatus.Fail;
waitSeatLog.OperateType = Operation.OtherReader;
waitSeatLog.WaitingState = EnterOutLogType.WaitingCancel;
T_SM_SeatWaiting.UpdateWaitLog(waitSeatLog);
}
PopupWindow popWindow = new PopupWindow(TipType.ComeToBack);
popWindow.ShowDialog();
if (clientobject.EnterOutLogData.Student.AtReadingRoom.Setting.SeatUsedTimeLimit.Used && clientobject.EnterOutLogData.Student.AtReadingRoom.Setting.SeatUsedTimeLimit.Mode == "Free")
{
List <EnterOutLogType> typeList = new List <EnterOutLogType>();
typeList.Add(EnterOutLogType.BookingConfirmation);
typeList.Add(EnterOutLogType.SelectSeat);
typeList.Add(EnterOutLogType.ReselectSeat);
typeList.Add(EnterOutLogType.WaitingSuccess);
typeList.Add(EnterOutLogType.ContinuedTime);
List <EnterOutLogInfo> seatTimeEnterOutLog = SeatManage.Bll.T_SM_EnterOutLog.GetEnterOutLogByNo(clientobject.EnterOutLogData.EnterOutlog.EnterOutLogNo, typeList, 1);
if (seatTimeEnterOutLog.Count > 0)
{
if (seatTimeEnterOutLog[0].EnterOutState == EnterOutLogType.ContinuedTime)
{
if (seatTimeEnterOutLog[0].EnterOutTime.AddMinutes(clientobject.EnterOutLogData.Student.AtReadingRoom.Setting.SeatUsedTimeLimit.DelayTimeLength) < ServiceDateTime.Now)
{
if (clientobject.EnterOutLogData.Student.AtReadingRoom.Setting.SeatUsedTimeLimit.ContinuedTimes == 0 || clientobject.EnterOutLogData.Student.ContinuedTimeCount < clientobject.EnterOutLogData.Student.AtReadingRoom.Setting.SeatUsedTimeLimit.ContinuedTimes)
{
clientobject.EnterOutLogData.EnterOutlog.EnterOutState = EnterOutLogType.ContinuedTime;
clientobject.EnterOutLogData.EnterOutlog.TerminalNum = clientobject.ClientSetting.ClientNo;
clientobject.EnterOutLogData.EnterOutlog.Remark = string.Format("在终端{0}刷卡暂离回来，暂离期间在座超时，系统自动延长{1} {2}号座位使用时间", clientobject.ClientSetting.ClientNo, clientobject.EnterOutLogData.Student.AtReadingRoom.Name, clientobject.EnterOutLogData.EnterOutlog.ShortSeatNo);
result = EnterOutOperate.AddEnterOutLog(clientobject.EnterOutLogData.EnterOutlog, ref newLogId);//插入进出记录
if (result == HandleResult.Successed)
{
PopupWindow popWindow_Continue = new PopupWindow(TipType.AutoContinuedTime);
popWindow_Continue.ShowDialog();
}
else
{
PopupWindow popWindow_Continue = new PopupWindow(TipType.Exception);
popWindow_Continue.ShowDialog();
}
}
else
{
clientobject.EnterOutLogData.EnterOutlog.EnterOutState = EnterOutLogType.Leave;
clientobject.EnterOutLogData.EnterOutlog.TerminalNum = clientobject.ClientSetting.ClientNo;
clientobject.EnterOutLogData.EnterOutlog.Remark = string.Format("在终端{0}刷卡暂离回来，暂离期间在座超时，续时次数已用完，系统自动释放{1} {2}号座位", clientobject.ClientSetting.ClientNo, clientobject.EnterOutLogData.Student.AtReadingRoom.Name, clientobject.EnterOutLogData.EnterOutlog.ShortSeatNo);
result = EnterOutOperate.AddEnterOutLog(clientobject.EnterOutLogData.EnterOutlog, ref newLogId);//插入进出记录
if (result == HandleResult.Successed)
{
PopupWindow popWindow_Continue = new PopupWindow(TipType.AutoContinuedTimeNoCount);
popWindow_Continue.ShowDialog();
}
else
{
PopupWindow popWindow_Continue = new PopupWindow(TipType.Exception);
popWindow_Continue.ShowDialog();
}
}
}
}
else
{
if (seatTimeEnterOutLog[0].EnterOutTime.AddMinutes(clientobject.EnterOutLogData.Student.AtReadingRoom.Setting.SeatUsedTimeLimit.UsedTimeLength) < ServiceDateTime.Now)
{
if (clientobject.EnterOutLogData.Student.AtReadingRoom.Setting.SeatUsedTimeLimit.IsCanContinuedTime)
{
if (clientobject.EnterOutLogData.Student.AtReadingRoom.Setting.SeatUsedTimeLimit.ContinuedTimes == 0 || clientobject.EnterOutLogData.Student.ContinuedTimeCount < clientobject.EnterOutLogData.Student.AtReadingRoom.Setting.SeatUsedTimeLimit.ContinuedTimes)
{
clientobject.EnterOutLogData.EnterOutlog.EnterOutState = EnterOutLogType.ContinuedTime;
clientobject.EnterOutLogData.EnterOutlog.TerminalNum = clientobject.ClientSetting.ClientNo;
clientobject.EnterOutLogData.EnterOutlog.Remark = string.Format("在终端{0}刷卡暂离回来，暂离期间在座超时，系统自动延长{1} {2}号座位使用时间", clientobject.ClientSetting.ClientNo, clientobject.EnterOutLogData.Student.AtReadingRoom.Name, clientobject.EnterOutLogData.EnterOutlog.ShortSeatNo);
result = EnterOutOperate.AddEnterOutLog(clientobject.EnterOutLogData.EnterOutlog, ref newLogId);//插入进出记录
if (result == HandleResult.Successed)
{
PopupWindow popWindow_Continue = new PopupWindow(TipType.AutoContinuedTime);
popWindow_Continue.ShowDialog();
}
else
{
PopupWindow popWindow_Continue = new PopupWindow(TipType.Exception);
popWindow_Continue.ShowDialog();
}
}
else
{
clientobject.EnterOutLogData.EnterOutlog.EnterOutState = EnterOutLogType.Leave;
clientobject.EnterOutLogData.EnterOutlog.TerminalNum = clientobject.ClientSetting.ClientNo;
clientobject.EnterOutLogData.EnterOutlog.Remark = string.Format("在终端{0}刷卡暂离回来，暂离期间在座超时，续时次数已用完，系统自动释放{1} {2}号座位", clientobject.ClientSetting.ClientNo, clientobject.EnterOutLogData.Student.AtReadingRoom.Name, clientobject.EnterOutLogData.EnterOutlog.ShortSeatNo);
result = EnterOutOperate.AddEnterOutLog(clientobject.EnterOutLogData.EnterOutlog, ref newLogId);//插入进出记录
if (result == HandleResult.Successed)
{
PopupWindow popWindow_Continue = new PopupWindow(TipType.AutoContinuedTimeNoCount);
popWindow_Continue.ShowDialog();
}
else
{
PopupWindow popWindow_Continue = new PopupWindow(TipType.Exception);
popWindow_Continue.ShowDialog();
}
}
}
else
{
clientobject.EnterOutLogData.EnterOutlog.EnterOutState = EnterOutLogType.Leave;
clientobject.EnterOutLogData.EnterOutlog.TerminalNum = clientobject.ClientSetting.ClientNo;
clientobject.EnterOutLogData.EnterOutlog.Remark = string.Format("在终端{0}刷卡暂离回来，暂离期间在座超时，系统自动释放{1} {2}号座位", clientobject.ClientSetting.ClientNo, clientobject.EnterOutLogData.Student.AtReadingRoom.Name, clientobject.EnterOutLogData.EnterOutlog.ShortSeatNo);
result = EnterOutOperate.AddEnterOutLog(clientobject.EnterOutLogData.EnterOutlog, ref newLogId);//插入进出记录
if (result == HandleResult.Successed)
{
PopupWindow popWindow_Continue = new PopupWindow(TipType.AutoContinuedTimeNoCount);
popWindow_Continue.ShowDialog();
}
else
{
PopupWindow popWindow_Continue = new PopupWindow(TipType.Exception);
popWindow_Continue.ShowDialog();
}
}
}
}
}
}
}
else
{
PopupWindow popWindow_Continue = new PopupWindow(TipType.Exception);
popWindow_Continue.ShowDialog();
}
}
public string QRcodeOperation(string codeStr, string studentNo)
{
try
{
AJM_HandleResult result = new AJM_HandleResult();
string[] scanResultArray = codeStr.Split('?');
ClientCheckCodeParamModel scancode = null;
if (scanResultArray.Length >= 2)
{
string[] strParam = scanResultArray[1].Split('=');
if (strParam.Length >= 2)
{
scancode = ClientCheckCodeParamModel.Prase(strParam[1]);//兼容url的二维码。
}
}
else
{
scancode = ClientCheckCodeParamModel.Prase(codeStr);
}
DateTime ndt = DateTime.Now;
if (scancode == null)
{
result.Result = false;
result.Msg = "对不起，二维码错误!";
return(JSONSerializer.Serialize(result));
}
if (scancode.CodeTime.AddMinutes(1) <= ndt)
{
result.Result = false;
result.Msg = "对不起，二维码超时!";
return(JSONSerializer.Serialize(result));
}
if (string.IsNullOrEmpty(studentNo))
{
result.Result = false;
result.Msg = "读者学号为空。";
return(JSONSerializer.Serialize(result));
}
ReaderInfo reader = SeatManageDateService.GetReader(studentNo, true);
if (reader == null)
{
result.Result = false;
result.Msg = "获取读者信息失败。";
return(JSONSerializer.Serialize(result));
}
if (reader.EnterOutLog == null && reader.BespeakLog.Count < 1)
{
result.Result = false;
result.Msg = "对不起，您还没有座位，请先选择或预约一个座位。";
}
if (reader.EnterOutLog != null)
{
switch (reader.EnterOutLog.EnterOutState)
{
case EnterOutLogType.BookingConfirmation: //预约入座
case EnterOutLogType.SelectSeat: //选座
case EnterOutLogType.ContinuedTime: //续时
case EnterOutLogType.ComeBack: //暂离回来
case EnterOutLogType.ReselectSeat: //重新选座
case EnterOutLogType.WaitingSuccess: //等待入座
result.Result = false;
result.Msg = "您当前已有座位。";
break;
case EnterOutLogType.ShortLeave:
reader.EnterOutLog.EnterOutState = EnterOutLogType.ComeBack;
reader.EnterOutLog.Remark = string.Format("您在选座终端{0}扫描二维码恢复在座，本次暂离时长{1}分钟。", scancode.ClientNo, ((int)(ndt - reader.EnterOutLog.EnterOutTime).TotalMinutes));
reader.EnterOutLog.Flag = Operation.Reader;
reader.EnterOutLog.EnterOutTime = ndt;
result.Result = true;
int newId = -1;
if (SeatManageDateService.AddEnterOutLogInfo(reader.EnterOutLog, ref newId) != HandleResult.Successed)
{
result.Result = false;
result.Msg = "对不起，暂离回来失败!";
return(JSONSerializer.Serialize(result));
}
result.Result = true;
result.Msg = reader.EnterOutLog.Remark;
List <WaitSeatLogInfo> waitSeatLogs = SeatManageDateService.GetWaitLogList("", reader.EnterOutLog.EnterOutLogID, null, null, null);
if (waitSeatLogs.Count > 0)
{
WaitSeatLogInfo waitSeatLog = waitSeatLogs[0];
waitSeatLog.NowState = LogStatus.Fail;
waitSeatLog.OperateType = Operation.OtherReader;
waitSeatLog.WaitingState = EnterOutLogType.WaitingCancel;
SeatManageDateService.UpdateWaitLog(waitSeatLog);
}
break;
case EnterOutLogType.Leave:
result.Result = false;
result.Msg = "对不起，您还没有座位，请先选择或预约一个座位。";
break;
default:
result.Result = false;
result.Msg = "对不起，您还没有座位，请先选择或预约一个座位。";
break;
}
return(JSONSerializer.Serialize(result));
}
ReadingRoomSetting set = reader.AtReadingRoom.Setting;
DateTime dtBegin = reader.BespeakLog[0].BsepeakTime.AddMinutes(-double.Parse(set.SeatBespeak.ConfirmTime.BeginTime));
DateTime dtEnd = reader.BespeakLog[0].BsepeakTime.AddMinutes(double.Parse(set.SeatBespeak.ConfirmTime.EndTime));
if (!DateTimeOperate.DateAccord(dtBegin, dtEnd, ndt) && (!set.SeatBespeak.NowDayBespeak || reader.BespeakLog[0].SubmitTime != reader.BespeakLog[0].BsepeakTime))
{
result.Result = false;
result.Msg = "对不起，您预约的座位没有到达签到时间";
return(JSONSerializer.Serialize(result));
}
EnterOutLogInfo seatUsedInfo = SeatManageDateService.GetEnterOutLogInfoBySeatNum(reader.BespeakLog[0].SeatNo);
if (seatUsedInfo != null && seatUsedInfo.EnterOutState != EnterOutLogType.Leave)
{
//条件满足，说明座位正在使用。
seatUsedInfo.EnterOutState = EnterOutLogType.Leave;
seatUsedInfo.EnterOutType = LogStatus.Valid;
seatUsedInfo.Remark = "您正在使用的座位已被原预约的读者";
seatUsedInfo.Flag = Operation.OtherReader;
int newId = -1;
if (SeatManageDateService.AddEnterOutLogInfo(seatUsedInfo, ref newId) != HandleResult.Successed)
{
result.Result = false;
result.Msg = "对不起，此阅览室尚未开放。";
return(JSONSerializer.Serialize(result));
}
List <WaitSeatLogInfo> waitInfoList = SeatManageDateService.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;
SeatManageDateService.UpdateWaitLog(waitSeatLogModel);
}
}
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.ReadingRoomName = reader.BespeakLog[0].ReadingRoomName;
newEnterOutLog.ShortSeatNo = reader.BespeakLog[0].ShortSeatNum;
newEnterOutLog.SeatNo = reader.BespeakLog[0].SeatNo;
newEnterOutLog.Remark = string.Format("您在选座终端{0}扫描二维码，签到入座预约的{1} {2}号座位", scancode.ClientNo, reader.BespeakLog[0].ReadingRoomName, reader.BespeakLog[0].ShortSeatNum);
int logid = -1;
if (SeatManageDateService.AddEnterOutLogInfo(newEnterOutLog, ref logid) == HandleResult.Successed)
{
reader.BespeakLog[0].BsepeakState = BookingStatus.Confinmed;
reader.BespeakLog[0].CancelPerson = Operation.Reader;
reader.BespeakLog[0].CancelTime = ndt;
reader.BespeakLog[0].Remark = newEnterOutLog.Remark;
SeatManageDateService.UpdateBespeakLogInfo(reader.BespeakLog[0]);
}
result.Result = true;
result.Msg = newEnterOutLog.Remark;
return(JSONSerializer.Serialize(result));
}
catch (Exception ex)
{
WriteLog.Write("读者签到/回来遇到异常：" + ex.Message);
AJM_HandleResult result = new AJM_HandleResult();
result.Result = false;
result.Msg = "执行遇到异常";
return(JSONSerializer.Serialize(result));
}
}
/// <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);
}
