void posCardHandle_HandleResult(string m, SeatManage.EnumType.HandleResult r)
 {
     if (r == HandleResult.Failed)
     {
         HandelMessage(m, EnumSimpleTipFormIco.Cry);
     }
     else if (r == HandleResult.Successed)
     {
         HandelMessage(m, EnumSimpleTipFormIco.Small);
     }
 }
        protected void btnSureAllotSeat_Click(object sender, EventArgs e)
        {
            SeatManage.ClassModel.Seat            seat     = SeatManage.Bll.T_SM_Seat.GetSeatInfoBySeatNo(seatNo);
            SeatManage.ClassModel.ReadingRoomInfo roomInfo = SeatManage.Bll.T_SM_ReadingRoom.GetSingleRoomInfo(seat.ReadingRoomNum);
            if (seat == null)
            {
                FineUI.Alert.ShowInTop("座位号错误,没有找到座位的相关信息");
                return;
            }
            //判断当前座位上是否有读者在座。
            SeatManage.ClassModel.EnterOutLogInfo enterOutLogByseatNo = SeatManage.Bll.T_SM_EnterOutLog.GetUsingEnterOutLogBySeatNo(seatNo);
            if (enterOutLogByseatNo != null && enterOutLogByseatNo.EnterOutState != SeatManage.EnumType.EnterOutLogType.Leave)
            {
                FineUI.Alert.ShowInTop("座位已经被其他读者选择");
                return;
            }
            //判断读者是否有座位
            string strCardNo = txtCardNo1.Text;
            List <SeatManage.ClassModel.BlackListInfo> blacklistInfoByCardNo = SeatManage.Bll.T_SM_Blacklist.GetBlackListInfo(strCardNo);

            SeatManage.ClassModel.RegulationRulesSetting rulesSet = SeatManage.Bll.T_SM_SystemSet.GetRegulationRulesSetting();
            if (roomInfo.Setting.UsedBlacklistLimit && blacklistInfoByCardNo.Count > 0)
            {
                if (roomInfo.Setting.BlackListSetting.Used)
                {
                    bool isblack = false;
                    foreach (SeatManage.ClassModel.BlackListInfo blinfo in blacklistInfoByCardNo)
                    {
                        if (blinfo.ReadingRoomID == roomInfo.No)
                        {
                            isblack = true;
                            break;
                        }
                    }
                    if (isblack)
                    {
                        FineUI.Alert.ShowInTop("该读者已进入黑名单,不能在该阅览室为其分配座位");
                        return;
                    }
                }
                else
                {
                    FineUI.Alert.ShowInTop("该读者已进入黑名单,不能在该阅览室为其分配座位");
                    return;
                }
            }
            SeatManage.ClassModel.EnterOutLogInfo enterOutLogByCardNo = SeatManage.Bll.T_SM_EnterOutLog.GetEnterOutLogInfoByCardNo(strCardNo);
            if (enterOutLogByCardNo != null && enterOutLogByCardNo.EnterOutState != SeatManage.EnumType.EnterOutLogType.Leave)
            {
                FineUI.Alert.ShowInTop(string.Format("读者已经在{0},{1}号座位就做", enterOutLogByCardNo.ReadingRoomName, enterOutLogByCardNo.ShortSeatNo));
                return;
            }

            SeatManage.ClassModel.EnterOutLogInfo enterOutLogModel = new SeatManage.ClassModel.EnterOutLogInfo();
            enterOutLogModel.CardNo        = strCardNo;
            enterOutLogModel.EnterOutLogNo = SeatManage.SeatManageComm.SeatComm.RndNum();
            enterOutLogModel.EnterOutState = SeatManage.EnumType.EnterOutLogType.SelectSeat;
            enterOutLogModel.EnterOutTime  = SeatManage.Bll.ServiceDateTime.Now;
            enterOutLogModel.EnterOutType  = SeatManage.EnumType.LogStatus.Valid;
            enterOutLogModel.Flag          = SeatManage.EnumType.Operation.Admin;
            enterOutLogModel.ReadingRoomNo = seat.ReadingRoomNum;
            enterOutLogModel.Remark        = string.Format("在后台管理网站被管理员{0},分配{1},{2}座位", this.LoginId, roomInfo.Name, seat.SeatNo.Substring(seat.SeatNo.Length - roomInfo.Setting.SeatNumAmount));
            enterOutLogModel.SeatNo        = seatNo;
            int newId = -1;

            SeatManage.EnumType.HandleResult result = SeatManage.Bll.EnterOutOperate.AddEnterOutLog(enterOutLogModel, ref newId);
            if (result == SeatManage.EnumType.HandleResult.Successed)
            {
                FineUI.Alert.ShowInTop("分配座位成功", "成功");
                PageContext.RegisterStartupScript(ActiveWindow.GetHidePostBackReference());
            }
            else
            {
                FineUI.Alert.ShowInTop("分配座位失败", "失败");
            }
        }
        protected void btn_SureAddBlacklist(object sender, EventArgs e)
        {
            SeatManage.ClassModel.Seat seat = SeatManage.Bll.T_SM_Seat.GetSeatInfoBySeatNo(seatNo);
            SeatManage.ClassModel.RegulationRulesSetting rulesSet     = SeatManage.Bll.T_SM_SystemSet.GetRegulationRulesSetting();
            SeatManage.ClassModel.BlacklistSetting       blacklistSet = rulesSet.BlacklistSet;
            SeatManage.ClassModel.ReadingRoomInfo        readingroom  = SeatManage.Bll.T_SM_ReadingRoom.GetSingleRoomInfo(seat.ReadingRoomNum);
            int i = -1;

            if (readingroom != null && readingroom.Setting.BlackListSetting.Used)
            {
                SeatManage.ClassModel.BlackListInfo blacklistModel = new SeatManage.ClassModel.BlackListInfo();
                blacklistModel.AddTime          = SeatManage.Bll.ServiceDateTime.Now;
                blacklistModel.ReadingRoomID    = readingroom.No;
                blacklistModel.BlacklistState   = SeatManage.EnumType.LogStatus.Valid;
                blacklistModel.CardNo           = txtCardNo.Text;
                blacklistModel.OutBlacklistMode = readingroom.Setting.BlackListSetting.LeaveBlacklist;
                if (blacklistModel.OutBlacklistMode == SeatManage.EnumType.LeaveBlacklistMode.AutomaticMode)
                {
                    blacklistModel.ReMark  = string.Format("管理员{0}把读者加入黑名单,记录黑名单{1}天,备注:{2}", this.LoginId, readingroom.Setting.BlackListSetting.LimitDays, txtRemark.Text);
                    blacklistModel.OutTime = blacklistModel.AddTime.AddDays(readingroom.Setting.BlackListSetting.LimitDays);
                }
                else
                {
                    blacklistModel.ReMark = string.Format("管理员{0}把读者加入黑名单,手动离开黑名单,备注:{1}", this.LoginId, txtRemark.Text);
                }
                blacklistModel.ReadingRoomID = seat.ReadingRoomNum;
                i = SeatManage.Bll.T_SM_Blacklist.AddBlackList(blacklistModel);
            }
            else if (blacklistSet.Used)
            {
                SeatManage.ClassModel.BlackListInfo blacklistModel = new SeatManage.ClassModel.BlackListInfo();
                blacklistModel.AddTime          = SeatManage.Bll.ServiceDateTime.Now;
                blacklistModel.OutTime          = blacklistModel.AddTime.AddDays(blacklistSet.LimitDays);
                blacklistModel.BlacklistState   = SeatManage.EnumType.LogStatus.Valid;
                blacklistModel.CardNo           = txtCardNo.Text;
                blacklistModel.OutBlacklistMode = blacklistSet.LeaveBlacklist;
                if (blacklistModel.OutBlacklistMode == SeatManage.EnumType.LeaveBlacklistMode.AutomaticMode)
                {
                    blacklistModel.ReMark  = string.Format("管理员{0}把读者加入黑名单,记录黑名单{1}天,备注:{2}", this.LoginId, blacklistSet.LimitDays, txtRemark.Text);
                    blacklistModel.OutTime = blacklistModel.AddTime.AddDays(blacklistSet.LimitDays);
                }
                else
                {
                    blacklistModel.ReMark = string.Format("管理员{0}把读者加入黑名单,手动离开黑名单,备注:{1}", this.LoginId, txtRemark.Text);
                }
                blacklistModel.ReadingRoomID = seat.ReadingRoomNum;
                i = SeatManage.Bll.T_SM_Blacklist.AddBlackList(blacklistModel);
            }
            else
            {
                FineUI.Alert.ShowInTop("对不起,此阅览室以及图书馆没有启用黑名单功能", "失败");
                return;
            }
            if (i > 0)
            {
                SeatManage.ClassModel.EnterOutLogInfo enterOutLogModel = SeatManage.Bll.T_SM_EnterOutLog.GetEnterOutLogInfoByCardNo(txtCardNo.Text);
                SeatManage.EnumType.EnterOutLogType   type             = enterOutLogModel.EnterOutState;
                enterOutLogModel.EnterOutState = SeatManage.EnumType.EnterOutLogType.Leave;
                enterOutLogModel.Flag          = SeatManage.EnumType.Operation.Admin;
                enterOutLogModel.Remark        = string.Format("在{0},{1}号座位,被管理员{2},在后台管理网站加入黑名单并释放座位", enterOutLogModel.ReadingRoomName, enterOutLogModel.ShortSeatNo, this.LoginId);
                SeatManage.EnumType.HandleResult result = SeatManage.Bll.EnterOutOperate.AddEnterOutLog(enterOutLogModel, ref i);
                if (result == SeatManage.EnumType.HandleResult.Successed)
                {
                    //SeatManage.ClassModel.ReaderNoticeInfo rni = new SeatManage.ClassModel.ReaderNoticeInfo();
                    //rni.CardNo = enterOutLogModel.CardNo;
                    //rni.Type = SeatManage.EnumType.NoticeType.ManagerFreeSetWarning;
                    //rni.Note = enterOutLogModel.Remark;
                    //SeatManage.Bll.T_SM_ReaderNotice.AddReaderNotice(rni);

                    //PushMsgInfo msg = new PushMsgInfo();
                    //msg.Title = "您好,您的座位已被释放";
                    //msg.MsgType = MsgPushType.AdminOperation;
                    //msg.StudentNum = enterOutLogModel.CardNo;
                    //msg.Message = enterOutLogModel.Remark;
                    //SeatManage.Bll.T_SM_ReaderNotice.SendPushMsg(msg);


                    if (type == SeatManage.EnumType.EnterOutLogType.ShortLeave)
                    {
                        List <SeatManage.ClassModel.WaitSeatLogInfo> waitSeatLogs = SeatManage.Bll.T_SM_SeatWaiting.GetWaitSeatList("", enterOutLogModel.EnterOutLogID, null, null, null);
                        SeatManage.ClassModel.WaitSeatLogInfo        waitSeatLog  = null;
                        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;
                            if (SeatManage.Bll.T_SM_SeatWaiting.UpdateWaitLog(waitSeatLog))
                            {
                                //rni = new SeatManage.ClassModel.ReaderNoticeInfo();
                                //rni.CardNo = waitSeatLog.CardNo;
                                //rni.Type = SeatManage.EnumType.NoticeType.WaitSeatFail;
                                //rni.Note = "您所等待的座位已被管理员释放,您的等待已被取消";
                                //SeatManage.Bll.T_SM_ReaderNotice.AddReaderNotice(rni);

                                //msg = new PushMsgInfo();
                                //msg.Title = "您好,您已被取消等待";
                                //msg.MsgType = MsgPushType.AdminOperation;
                                //msg.StudentNum = waitSeatLog.CardNo;
                                //msg.Message = "您所等待的座位已被管理员释放,您的等待已被取消";
                                //SeatManage.Bll.T_SM_ReaderNotice.SendPushMsg(msg);
                            }
                        }
                    }

                    FineUI.Alert.ShowInTop("黑名单添加成功", "成功");
                    PageContext.RegisterStartupScript(ActiveWindow.GetHidePostBackReference());
                }
                else
                {
                    FineUI.Alert.ShowInTop("黑名单添加失败", "失败");
                }
            }
            else
            {
                FineUI.Alert.ShowInTop("黑名单添加失败", "失败");
            }
        }
        protected void btn_btnLeave(object sender, EventArgs e)
        {
            SeatManage.ClassModel.EnterOutLogInfo enterOutLog = SeatManage.Bll.T_SM_EnterOutLog.GetUsingEnterOutLogBySeatNo(seatNo);
            SeatManage.ClassModel.ReadingRoomInfo roomInfo    = SeatManage.Bll.T_SM_ReadingRoom.GetSingleRoomInfo(enterOutLog.ReadingRoomNo);
            SeatManage.EnumType.EnterOutLogType   type        = enterOutLog.EnterOutState;
            enterOutLog.EnterOutState = SeatManage.EnumType.EnterOutLogType.Leave;
            enterOutLog.Flag          = SeatManage.EnumType.Operation.Admin;
            enterOutLog.Remark        = string.Format("在{0},{1}号座位,被管理员{2},在后台管理网站设置离开", roomInfo.Name, enterOutLog.ShortSeatNo, this.LoginId);
            int newId = -1;

            SeatManage.EnumType.HandleResult result = SeatManage.Bll.EnterOutOperate.AddEnterOutLog(enterOutLog, ref newId);
            if (result == SeatManage.EnumType.HandleResult.Successed)
            {
                //SeatManage.ClassModel.ReaderNoticeInfo rni = new SeatManage.ClassModel.ReaderNoticeInfo();
                //rni.CardNo = enterOutLog.CardNo;
                //rni.Type = SeatManage.EnumType.NoticeType.ManagerFreeSetWarning;
                //rni.Note = enterOutLog.Remark;
                //SeatManage.Bll.T_SM_ReaderNotice.AddReaderNotice(rni);

                PushMsgInfo msg = new PushMsgInfo();
                msg.Title      = "您好,您的座位已被释放";
                msg.MsgType    = MsgPushType.AdminOperation;
                msg.StudentNum = enterOutLog.CardNo;
                msg.Message    = enterOutLog.Remark;
                SeatManage.Bll.T_SM_ReaderNotice.SendPushMsg(msg);

                if (type == SeatManage.EnumType.EnterOutLogType.ShortLeave)
                {
                    List <SeatManage.ClassModel.WaitSeatLogInfo> waitSeatLogs = SeatManage.Bll.T_SM_SeatWaiting.GetWaitSeatList("", enterOutLog.EnterOutLogID, null, null, null);
                    SeatManage.ClassModel.WaitSeatLogInfo        waitSeatLog  = null;
                    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;
                        if (SeatManage.Bll.T_SM_SeatWaiting.UpdateWaitLog(waitSeatLog))
                        {
                            //rni = new SeatManage.ClassModel.ReaderNoticeInfo();
                            //rni.CardNo = waitSeatLog.CardNo;
                            //rni.Type = SeatManage.EnumType.NoticeType.WaitSeatFail;
                            //rni.Note = "您所等待的座位已被管理员释放,您的等待已被取消";
                            //SeatManage.Bll.T_SM_ReaderNotice.AddReaderNotice(rni);

                            //msg = new PushMsgInfo();
                            //msg.Title = "您好,您的等待已被取消";
                            //msg.MsgType = MsgPushType.AdminOperation;
                            //msg.StudentNum = waitSeatLog.CardNo;
                            //msg.Message = "您所等待的座位已被管理员释放,您的等待已被取消";
                            //SeatManage.Bll.T_SM_ReaderNotice.SendPushMsg(msg);
                        }
                    }
                }

                SeatManage.ClassModel.RegulationRulesSetting rulesSet = SeatManage.Bll.T_SM_SystemSet.GetRegulationRulesSetting();
                if (roomInfo.Setting.IsRecordViolate)
                {
                    if (roomInfo.Setting.BlackListSetting.Used)
                    {
                        if (roomInfo.Setting.BlackListSetting.ViolateRoule[SeatManage.EnumType.ViolationRecordsType.LeaveByAdmin])
                        {
                            SeatManage.ClassModel.ViolationRecordsLogInfo violationRecords = new SeatManage.ClassModel.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  = SeatManage.Bll.ServiceDateTime.Now.ToString();
                            violationRecords.EnterFlag     = SeatManage.EnumType.ViolationRecordsType.LeaveByAdmin;
                            violationRecords.Remark        = string.Format("在{0},{1}号座位,被管理员{2},在后台管理网站设置离开", roomInfo.Name, enterOutLog.ShortSeatNo, this.LoginId);
                            violationRecords.BlacklistID   = "-1";
                            SeatManage.Bll.T_SM_ViolateDiscipline.AddViolationRecords(violationRecords);
                        }
                    }
                    else if (rulesSet.BlacklistSet.Used && rulesSet.BlacklistSet.ViolateRoule[SeatManage.EnumType.ViolationRecordsType.LeaveByAdmin])
                    {
                        SeatManage.ClassModel.ViolationRecordsLogInfo violationRecords = new SeatManage.ClassModel.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  = SeatManage.Bll.ServiceDateTime.Now.ToString();
                        violationRecords.EnterFlag     = SeatManage.EnumType.ViolationRecordsType.LeaveByAdmin;
                        violationRecords.Remark        = string.Format("在{0},{1}号座位,被管理员{2},在后台管理网站设置离开", roomInfo.Name, enterOutLog.ShortSeatNo, this.LoginId);
                        violationRecords.BlacklistID   = "-1";
                        SeatManage.Bll.T_SM_ViolateDiscipline.AddViolationRecords(violationRecords);
                    }
                }

                FineUI.Alert.ShowInTop("设置读者离开成功", "成功");
                PageContext.RegisterStartupScript(ActiveWindow.GetHidePostBackReference());
            }
            else
            {
                FineUI.Alert.ShowInTop("设置读者离开失败", "失败");
            }
        }
        protected void btn_shortLeave(object sender, EventArgs e)
        {
            SeatManage.ClassModel.EnterOutLogInfo enterOutLog = SeatManage.Bll.T_SM_EnterOutLog.GetUsingEnterOutLogBySeatNo(seatNo);
            SeatManage.ClassModel.ReadingRoomInfo roomInfo    = SeatManage.Bll.T_SM_ReadingRoom.GetSingleRoomInfo(enterOutLog.ReadingRoomNo);
            if (btnShortLeave.Text == "暂离")
            {
                enterOutLog.EnterOutState = SeatManage.EnumType.EnterOutLogType.ShortLeave;
                enterOutLog.Flag          = SeatManage.EnumType.Operation.Admin;
                enterOutLog.Remark        = string.Format("在{0},{1}号座位,被管理员{2},在后台管理网站设置为暂离", roomInfo.Name, enterOutLog.ShortSeatNo, this.LoginId);
                int newId = -1;
                SeatManage.EnumType.HandleResult result = SeatManage.Bll.EnterOutOperate.AddEnterOutLog(enterOutLog, ref newId);
                if (result == SeatManage.EnumType.HandleResult.Successed)
                {
                    //SeatManage.ClassModel.ReaderNoticeInfo rni = new SeatManage.ClassModel.ReaderNoticeInfo();
                    //rni.CardNo = enterOutLog.CardNo;
                    //rni.Type = SeatManage.EnumType.NoticeType.ManagerSetShortLeaveWarning;
                    //rni.Note = enterOutLog.Remark;
                    //SeatManage.Bll.T_SM_ReaderNotice.AddReaderNotice(rni);

                    //PushMsgInfo msg = new PushMsgInfo();
                    //msg.Title = "您好,您已被设置为暂离";
                    //msg.MsgType = MsgPushType.AdminOperation;
                    //msg.StudentNum = enterOutLog.CardNo; ;
                    //msg.Message = enterOutLog.Remark;
                    //SeatManage.Bll.T_SM_ReaderNotice.SendPushMsg(msg);

                    FineUI.Alert.ShowInTop("设置读者暂离成功", "成功");
                    PageContext.RegisterStartupScript(FineUI.ActiveWindow.GetHidePostBackReference());
                }
                else
                {
                    FineUI.Alert.ShowInTop("设置读者暂离失败", "失败");
                }
            }
            else
            {
                enterOutLog.EnterOutState = SeatManage.EnumType.EnterOutLogType.ComeBack;
                enterOutLog.Flag          = SeatManage.EnumType.Operation.Admin;
                enterOutLog.Remark        = string.Format("在{0},{1}号座位,被管理员{2},在后台管理网站设置为在座", roomInfo.Name, enterOutLog.ShortSeatNo, this.LoginId);
                int newId = -1;
                SeatManage.EnumType.HandleResult result = SeatManage.Bll.EnterOutOperate.AddEnterOutLog(enterOutLog, ref newId);
                if (result == SeatManage.EnumType.HandleResult.Successed)
                {
                    //SeatManage.ClassModel.ReaderNoticeInfo rni = new SeatManage.ClassModel.ReaderNoticeInfo();
                    //rni.CardNo = enterOutLog.CardNo;
                    //rni.Type = SeatManage.EnumType.NoticeType.RecoverSeat;
                    //rni.Note = enterOutLog.Remark;
                    //SeatManage.Bll.T_SM_ReaderNotice.AddReaderNotice(rni);


                    //PushMsgInfo msg = new PushMsgInfo();
                    //msg.Title = "您好,您已恢复在座";
                    //msg.MsgType = MsgPushType.AdminOperation;
                    //msg.StudentNum = enterOutLog.CardNo; ;
                    //msg.Message = enterOutLog.Remark;
                    //SeatManage.Bll.T_SM_ReaderNotice.SendPushMsg(msg);

                    List <SeatManage.ClassModel.WaitSeatLogInfo> waitSeatLogs = SeatManage.Bll.T_SM_SeatWaiting.GetWaitSeatList("", enterOutLog.EnterOutLogID, null, null, null);
                    SeatManage.ClassModel.WaitSeatLogInfo        waitSeatLog  = null;
                    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;
                        if (SeatManage.Bll.T_SM_SeatWaiting.UpdateWaitLog(waitSeatLog))
                        {
                            //rni = new SeatManage.ClassModel.ReaderNoticeInfo();
                            //rni.CardNo = waitSeatLog.CardNo;
                            //rni.Type = SeatManage.EnumType.NoticeType.WaitSeatFail;
                            //rni.Note = "您所等待的座位已被管理员恢复在座,您的等待已被取消";
                            //SeatManage.Bll.T_SM_ReaderNotice.AddReaderNotice(rni);

                            //msg = new PushMsgInfo();
                            //msg.Title = "您好,您等待已被取消";
                            //msg.MsgType = MsgPushType.AdminOperation;
                            //msg.StudentNum = waitSeatLog.CardNo; ;
                            //msg.Message = "您所等待的座位已被管理员恢复在座,您的等待已被取消";
                            //SeatManage.Bll.T_SM_ReaderNotice.SendPushMsg(msg);


                            FineUI.Alert.ShowInTop("取消读者暂离成功", "成功");
                            PageContext.RegisterStartupScript(FineUI.ActiveWindow.GetHidePostBackReference());
                        }
                        else
                        {
                            FineUI.Alert.ShowInTop("取消读者暂离成功,取消等待失败", "失败");
                        }
                    }
                    else
                    {
                        FineUI.Alert.ShowInTop("取消读者暂离成功", "成功");
                        PageContext.RegisterStartupScript(FineUI.ActiveWindow.GetHidePostBackReference());
                    }
                }
                else
                {
                    FineUI.Alert.ShowInTop("取消读者暂离失败", "失败");
                }
            }
        }
        /// <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));
            }
        }
 protected void btnBespeak_Click(object sender, EventArgs e)
 {
     SeatManage.ClassModel.BespeakLogInfo bespeakModel = new SeatManage.ClassModel.BespeakLogInfo();
     bespeakModel.BsepeakState  = SeatManage.EnumType.BookingStatus.Waiting;
     bespeakModel.BsepeakTime   = date;
     bespeakModel.CardNo        = this.LoginId;
     bespeakModel.ReadingRoomNo = roomNo.Trim();
     if (rblModel.SelectedValue == "1")
     {
         if (!DropDownList_Time.Hidden == true)
         {
             bespeakModel.BsepeakTime = DateTime.Parse(string.Format("{0} {1}", date.ToShortDateString(), DropDownList_Time.SelectedText));
         }
         else
         {
             bespeakModel.BsepeakTime = DateTime.Parse(string.Format("{0} {1}", date.ToShortDateString(), DropDownList_FreeTime.SelectedText));
         }
     }
     SeatManage.ClassModel.ReadingRoomInfo room = SeatManage.Bll.T_SM_ReadingRoom.GetSingleRoomInfo(bespeakModel.ReadingRoomNo);
     if (room.Setting.ReadingRoomOpenState(bespeakModel.BsepeakTime) == ReadingRoomStatus.Close)
     {
         FineUI.Alert.ShowInTop("对不起,当前时间阅览室未开放。");
         PageContext.RegisterStartupScript(FineUI.ActiveWindow.GetHidePostBackReference());
     }
     bespeakModel.Remark     = string.Format("读者通过Web页面预约当天座位");
     bespeakModel.SeatNo     = seatNo;
     bespeakModel.SubmitTime = date;
     if (bespeakModel.BsepeakTime < bespeakModel.SubmitTime)
     {
         FineUI.Alert.ShowInTop("对不起,预约的时间不正确,请刷新页面重新选择。");
         PageContext.RegisterStartupScript(FineUI.ActiveWindow.GetHidePostBackReference());
     }
     try
     {
         Seat seatInfo = SeatManage.Bll.T_SM_Seat.GetSeatInfoBySeatNo(seatNo);
         if (bespeakModel.BsepeakTime == DateTime.Now.Date && seatInfo.SeatUsedState != EnterOutLogType.Leave) //如果启用预约,判断选择的日期是否为当天的日期
         {
             FineUI.Alert.ShowInTop("对不起,你所预约的座位正在使用。");
             PageContext.RegisterStartupScript(FineUI.ActiveWindow.GetHidePostBackReference());
         }
         List <SeatManage.ClassModel.BespeakLogInfo> seatbespeakLog = SeatManage.Bll.T_SM_SeatBespeak.GetBespeakLogInfoBySeatNo(seatNo, date);
         if (seatbespeakLog.Count > 0)
         {
             FineUI.Alert.ShowInTop("对不起,该座位已经被别人预约。");
             PageContext.RegisterStartupScript(FineUI.ActiveWindow.GetHidePostBackReference());
         }
         SeatManage.EnumType.HandleResult result = SeatManage.Bll.T_SM_SeatBespeak.AddBespeakLogInfo(bespeakModel);
         if (result == SeatManage.EnumType.HandleResult.Successed)
         {
             FineUI.Alert.ShowInTop("座位预约成功,请在规定的时间内刷卡确认。");
             PageContext.RegisterStartupScript(FineUI.ActiveWindow.GetHidePostBackReference());
         }
         else
         {
             FineUI.Alert.ShowInTop("预约失败,该座位已经被别人预约。");
             PageContext.RegisterStartupScript(FineUI.ActiveWindow.GetHidePostBackReference());
         }
     }
     catch (Exception ex)
     {
         FineUI.Alert.ShowInTop(string.Format("执行预约操作遇到错误:{0}", ex.Message));
         PageContext.RegisterStartupScript(FineUI.ActiveWindow.GetHidePostBackReference());
     }
 }
Beispiel #8
0
        public JsonResult SureAllotSeat(string seatNo, string seatShortNo, string used, string cardNo)
        {
            JsonResult ret = null;

            SeatManage.ClassModel.Seat            seat     = SeatManage.Bll.T_SM_Seat.GetSeatInfoBySeatNo(seatNo);
            SeatManage.ClassModel.ReadingRoomInfo roomInfo = SeatManage.Bll.T_SM_ReadingRoom.GetSingleRoomInfo(seat.ReadingRoomNum);
            if (seat == null)
            {
                ret = Json(new { status = "no", message = "座位号错误,没有找到座位的相关信息" }, JsonRequestBehavior.AllowGet);
            }
            //判断当前座位上是否有读者在座。
            SeatManage.ClassModel.EnterOutLogInfo enterOutLogByseatNo = SeatManage.Bll.T_SM_EnterOutLog.GetUsingEnterOutLogBySeatNo(seatNo);
            if (enterOutLogByseatNo != null && enterOutLogByseatNo.EnterOutState != SeatManage.EnumType.EnterOutLogType.Leave)
            {
                ret = Json(new { status = "no", message = "座位已经被其他读者选择" }, JsonRequestBehavior.AllowGet);
            }
            //判断读者是否有座位
            string strCardNo = cardNo;// txtCardNo1.Text;
            List <SeatManage.ClassModel.BlackListInfo> blacklistInfoByCardNo = SeatManage.Bll.T_SM_Blacklist.GetBlackListInfo(strCardNo);

            SeatManage.ClassModel.RegulationRulesSetting rulesSet = SeatManage.Bll.T_SM_SystemSet.GetRegulationRulesSetting();
            if (roomInfo.Setting.UsedBlacklistLimit && blacklistInfoByCardNo.Count > 0)
            {
                if (roomInfo.Setting.BlackListSetting.Used)
                {
                    bool isblack = false;
                    foreach (SeatManage.ClassModel.BlackListInfo blinfo in blacklistInfoByCardNo)
                    {
                        if (blinfo.ReadingRoomID == roomInfo.No)
                        {
                            isblack = true;
                            break;
                        }
                    }
                    if (isblack)
                    {
                        ret = Json(new { status = "no", message = "该读者已进入黑名单,不能在该阅览室为其分配座位" }, JsonRequestBehavior.AllowGet);
                    }
                }
                else
                {
                    ret = Json(new { status = "no", message = "该读者已进入黑名单,不能在该阅览室为其分配座位" }, JsonRequestBehavior.AllowGet);
                }
            }
            SeatManage.ClassModel.EnterOutLogInfo enterOutLogByCardNo = SeatManage.Bll.T_SM_EnterOutLog.GetEnterOutLogInfoByCardNo(strCardNo);
            if (enterOutLogByCardNo != null && enterOutLogByCardNo.EnterOutState != SeatManage.EnumType.EnterOutLogType.Leave)
            {
                ret = Json(new { status = "no", message = string.Format("读者已经在{0},{1}号座位就做", enterOutLogByCardNo.ReadingRoomName, enterOutLogByCardNo.ShortSeatNo) }, JsonRequestBehavior.AllowGet);
            }

            SeatManage.ClassModel.EnterOutLogInfo enterOutLogModel = new SeatManage.ClassModel.EnterOutLogInfo();
            enterOutLogModel.CardNo        = strCardNo;
            enterOutLogModel.EnterOutLogNo = SeatManage.SeatManageComm.SeatComm.RndNum();
            enterOutLogModel.EnterOutState = SeatManage.EnumType.EnterOutLogType.SelectSeat;
            enterOutLogModel.EnterOutTime  = SeatManage.Bll.ServiceDateTime.Now;
            enterOutLogModel.EnterOutType  = SeatManage.EnumType.LogStatus.Valid;
            enterOutLogModel.Flag          = SeatManage.EnumType.Operation.Admin;
            enterOutLogModel.ReadingRoomNo = seat.ReadingRoomNum;
            enterOutLogModel.Remark        = string.Format("在后台管理网站被管理员{0},分配{1},{2}座位", this.LoginId, roomInfo.Name, seat.SeatNo.Substring(seat.SeatNo.Length - roomInfo.Setting.SeatNumAmount));
            enterOutLogModel.SeatNo        = seatNo;
            int newId = -1;

            SeatManage.EnumType.HandleResult result = SeatManage.Bll.EnterOutOperate.AddEnterOutLog(enterOutLogModel, ref newId);
            if (result == SeatManage.EnumType.HandleResult.Successed)
            {
                ret = Json(new { status = "yes", message = "分配座位成功" }, JsonRequestBehavior.AllowGet);
            }
            else
            {
                ret = Json(new { status = "no", message = "分配座位失败" }, JsonRequestBehavior.AllowGet);
            }

            return(ret);
        }
Beispiel #9
0
        /// <summary>
        /// 添加黑名单
        /// </summary>
        /// <param name="seatNo"></param>
        /// <param name="seatShortNo"></param>
        /// <param name="used"></param>
        /// <param name="CardNo"></param>
        /// <param name="addBlackListRemark"></param>
        /// <returns></returns>
        public JsonResult SureAddBlacklist(string seatNo, string seatShortNo, string used, string CardNo, string addBlackListRemark)
        {
            addBlackListRemark = string.IsNullOrEmpty(addBlackListRemark) ? "未备注" : addBlackListRemark;

            JsonResult ret = null;

            SeatManage.ClassModel.Seat seat = SeatManage.Bll.T_SM_Seat.GetSeatInfoBySeatNo(seatNo);
            SeatManage.ClassModel.RegulationRulesSetting rulesSet     = SeatManage.Bll.T_SM_SystemSet.GetRegulationRulesSetting();
            SeatManage.ClassModel.BlacklistSetting       blacklistSet = rulesSet.BlacklistSet;
            SeatManage.ClassModel.ReadingRoomInfo        readingroom  = SeatManage.Bll.T_SM_ReadingRoom.GetSingleRoomInfo(seat.ReadingRoomNum);
            int i = -1;

            if (readingroom != null && readingroom.Setting.BlackListSetting.Used)
            {
                SeatManage.ClassModel.BlackListInfo blacklistModel = new SeatManage.ClassModel.BlackListInfo();
                blacklistModel.AddTime          = SeatManage.Bll.ServiceDateTime.Now;
                blacklistModel.ReadingRoomID    = readingroom.No;
                blacklistModel.BlacklistState   = SeatManage.EnumType.LogStatus.Valid;
                blacklistModel.CardNo           = CardNo;
                blacklistModel.OutBlacklistMode = readingroom.Setting.BlackListSetting.LeaveBlacklist;
                if (blacklistModel.OutBlacklistMode == SeatManage.EnumType.LeaveBlacklistMode.AutomaticMode)
                {
                    blacklistModel.ReMark  = string.Format("管理员{0}把读者加入黑名单,记录黑名单{1}天,备注:{2}", this.LoginId, readingroom.Setting.BlackListSetting.LimitDays, addBlackListRemark);
                    blacklistModel.OutTime = blacklistModel.AddTime.AddDays(readingroom.Setting.BlackListSetting.LimitDays);
                }
                else
                {
                    blacklistModel.ReMark = string.Format("管理员{0}把读者加入黑名单,手动离开黑名单,备注:{1}", this.LoginId, addBlackListRemark);
                }
                blacklistModel.ReadingRoomID = seat.ReadingRoomNum;
                i = SeatManage.Bll.T_SM_Blacklist.AddBlackList(blacklistModel);
            }
            else if (blacklistSet.Used)
            {
                SeatManage.ClassModel.BlackListInfo blacklistModel = new SeatManage.ClassModel.BlackListInfo();
                blacklistModel.AddTime          = SeatManage.Bll.ServiceDateTime.Now;
                blacklistModel.OutTime          = blacklistModel.AddTime.AddDays(blacklistSet.LimitDays);
                blacklistModel.BlacklistState   = SeatManage.EnumType.LogStatus.Valid;
                blacklistModel.CardNo           = CardNo;
                blacklistModel.OutBlacklistMode = blacklistSet.LeaveBlacklist;
                if (blacklistModel.OutBlacklistMode == SeatManage.EnumType.LeaveBlacklistMode.AutomaticMode)
                {
                    blacklistModel.ReMark  = string.Format("管理员{0}把读者加入黑名单,记录黑名单{1}天,备注:{2}", this.LoginId, blacklistSet.LimitDays, addBlackListRemark);
                    blacklistModel.OutTime = blacklistModel.AddTime.AddDays(blacklistSet.LimitDays);
                }
                else
                {
                    blacklistModel.ReMark = string.Format("管理员{0}把读者加入黑名单,手动离开黑名单,备注:{1}", this.LoginId, addBlackListRemark);
                }
                blacklistModel.ReadingRoomID = seat.ReadingRoomNum;
                i = SeatManage.Bll.T_SM_Blacklist.AddBlackList(blacklistModel);
            }
            else
            {
                ret = Json(new { status = "no", message = "对不起,此阅览室以及图书馆没有启用黑名单功能" }, JsonRequestBehavior.AllowGet);
            }
            if (i > 0)
            {
                SeatManage.ClassModel.EnterOutLogInfo enterOutLogModel = SeatManage.Bll.T_SM_EnterOutLog.GetEnterOutLogInfoByCardNo(CardNo);
                SeatManage.EnumType.EnterOutLogType   type             = enterOutLogModel.EnterOutState;
                enterOutLogModel.EnterOutState = SeatManage.EnumType.EnterOutLogType.Leave;
                enterOutLogModel.Flag          = SeatManage.EnumType.Operation.Admin;
                enterOutLogModel.Remark        = string.Format("在{0},{1}号座位,被管理员{2},在后台管理网站加入黑名单并释放座位", enterOutLogModel.ReadingRoomName, enterOutLogModel.ShortSeatNo, this.LoginId);
                SeatManage.EnumType.HandleResult result = SeatManage.Bll.EnterOutOperate.AddEnterOutLog(enterOutLogModel, ref i);
                if (result == SeatManage.EnumType.HandleResult.Successed)
                {
                    //SeatManage.ClassModel.ReaderNoticeInfo rni = new SeatManage.ClassModel.ReaderNoticeInfo();
                    //rni.CardNo = enterOutLogModel.CardNo;
                    //rni.Type = SeatManage.EnumType.NoticeType.ManagerFreeSetWarning;
                    //rni.Note = enterOutLogModel.Remark;
                    //SeatManage.Bll.T_SM_ReaderNotice.AddReaderNotice(rni);

                    //PushMsgInfo msg = new PushMsgInfo();
                    //msg.Title = "您好,您的座位已被释放";
                    //msg.MsgType = MsgPushType.AdminOperation;
                    //msg.StudentNum = enterOutLogModel.CardNo;
                    //msg.Message = enterOutLogModel.Remark;
                    //SeatManage.Bll.T_SM_ReaderNotice.SendPushMsg(msg);


                    if (type == SeatManage.EnumType.EnterOutLogType.ShortLeave)
                    {
                        List <SeatManage.ClassModel.WaitSeatLogInfo> waitSeatLogs = SeatManage.Bll.T_SM_SeatWaiting.GetWaitSeatList("", enterOutLogModel.EnterOutLogID, null, null, null);
                        SeatManage.ClassModel.WaitSeatLogInfo        waitSeatLog  = null;
                        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;
                            if (SeatManage.Bll.T_SM_SeatWaiting.UpdateWaitLog(waitSeatLog))
                            {
                                //rni = new SeatManage.ClassModel.ReaderNoticeInfo();
                                //rni.CardNo = waitSeatLog.CardNo;
                                //rni.Type = SeatManage.EnumType.NoticeType.WaitSeatFail;
                                //rni.Note = "您所等待的座位已被管理员释放,您的等待已被取消";
                                //SeatManage.Bll.T_SM_ReaderNotice.AddReaderNotice(rni);

                                //msg = new PushMsgInfo();
                                //msg.Title = "您好,您已被取消等待";
                                //msg.MsgType = MsgPushType.AdminOperation;
                                //msg.StudentNum = waitSeatLog.CardNo;
                                //msg.Message = "您所等待的座位已被管理员释放,您的等待已被取消";
                                //SeatManage.Bll.T_SM_ReaderNotice.SendPushMsg(msg);
                            }
                        }
                    }
                    ret = Json(new { status = "yes", message = "黑名单添加成功" }, JsonRequestBehavior.AllowGet);
                }
                else
                {
                    ret = Json(new { status = "no", message = "黑名单添加失败" }, JsonRequestBehavior.AllowGet);
                }
            }
            else
            {
                ret = Json(new { status = "no", message = "黑名单添加失败" }, JsonRequestBehavior.AllowGet);
            }
            return(ret);
        }
Beispiel #10
0
        public JsonResult Leave(string seatNo, string seatShortNo, string used)
        {
            JsonResult ret = null;

            SeatManage.ClassModel.EnterOutLogInfo enterOutLog = SeatManage.Bll.T_SM_EnterOutLog.GetUsingEnterOutLogBySeatNo(seatNo);
            SeatManage.ClassModel.ReadingRoomInfo roomInfo    = SeatManage.Bll.T_SM_ReadingRoom.GetSingleRoomInfo(enterOutLog.ReadingRoomNo);
            SeatManage.EnumType.EnterOutLogType   type        = enterOutLog.EnterOutState;
            enterOutLog.EnterOutState = SeatManage.EnumType.EnterOutLogType.Leave;
            enterOutLog.Flag          = SeatManage.EnumType.Operation.Admin;
            enterOutLog.Remark        = string.Format("在{0},{1}号座位,被管理员{2},在后台管理网站设置离开", roomInfo.Name, enterOutLog.ShortSeatNo, this.LoginId);
            int newId = -1;

            SeatManage.EnumType.HandleResult result = SeatManage.Bll.EnterOutOperate.AddEnterOutLog(enterOutLog, ref newId);
            if (result == SeatManage.EnumType.HandleResult.Successed)
            {
                //SeatManage.ClassModel.ReaderNoticeInfo rni = new SeatManage.ClassModel.ReaderNoticeInfo();
                //rni.CardNo = enterOutLog.CardNo;
                //rni.Type = SeatManage.EnumType.NoticeType.ManagerFreeSetWarning;
                //rni.Note = enterOutLog.Remark;
                //SeatManage.Bll.T_SM_ReaderNotice.AddReaderNotice(rni);

                PushMsgInfo msg = new PushMsgInfo();
                msg.Title      = "您好,您的座位已被释放";
                msg.MsgType    = MsgPushType.AdminOperation;
                msg.StudentNum = enterOutLog.CardNo;
                msg.Message    = enterOutLog.Remark;
                SeatManage.Bll.T_SM_ReaderNotice.SendPushMsg(msg);

                if (type == SeatManage.EnumType.EnterOutLogType.ShortLeave)
                {
                    List <SeatManage.ClassModel.WaitSeatLogInfo> waitSeatLogs = SeatManage.Bll.T_SM_SeatWaiting.GetWaitSeatList("", enterOutLog.EnterOutLogID, null, null, null);
                    SeatManage.ClassModel.WaitSeatLogInfo        waitSeatLog  = null;
                    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;
                        if (SeatManage.Bll.T_SM_SeatWaiting.UpdateWaitLog(waitSeatLog))
                        {
                            //rni = new SeatManage.ClassModel.ReaderNoticeInfo();
                            //rni.CardNo = waitSeatLog.CardNo;
                            //rni.Type = SeatManage.EnumType.NoticeType.WaitSeatFail;
                            //rni.Note = "您所等待的座位已被管理员释放,您的等待已被取消";
                            //SeatManage.Bll.T_SM_ReaderNotice.AddReaderNotice(rni);

                            //msg = new PushMsgInfo();
                            //msg.Title = "您好,您的等待已被取消";
                            //msg.MsgType = MsgPushType.AdminOperation;
                            //msg.StudentNum = waitSeatLog.CardNo;
                            //msg.Message = "您所等待的座位已被管理员释放,您的等待已被取消";
                            //SeatManage.Bll.T_SM_ReaderNotice.SendPushMsg(msg);
                        }
                    }
                }

                SeatManage.ClassModel.RegulationRulesSetting rulesSet = SeatManage.Bll.T_SM_SystemSet.GetRegulationRulesSetting();
                if (roomInfo.Setting.IsRecordViolate)
                {
                    if (roomInfo.Setting.BlackListSetting.Used)
                    {
                        if (roomInfo.Setting.BlackListSetting.ViolateRoule[SeatManage.EnumType.ViolationRecordsType.LeaveByAdmin])
                        {
                            SeatManage.ClassModel.ViolationRecordsLogInfo violationRecords = new SeatManage.ClassModel.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  = SeatManage.Bll.ServiceDateTime.Now.ToString();
                            violationRecords.EnterFlag     = SeatManage.EnumType.ViolationRecordsType.LeaveByAdmin;
                            violationRecords.Remark        = string.Format("在{0},{1}号座位,被管理员{2},在后台管理网站设置离开", roomInfo.Name, enterOutLog.ShortSeatNo, this.LoginId);
                            violationRecords.BlacklistID   = "-1";
                            SeatManage.Bll.T_SM_ViolateDiscipline.AddViolationRecords(violationRecords);
                        }
                    }
                    else if (rulesSet.BlacklistSet.Used && rulesSet.BlacklistSet.ViolateRoule[SeatManage.EnumType.ViolationRecordsType.LeaveByAdmin])
                    {
                        SeatManage.ClassModel.ViolationRecordsLogInfo violationRecords = new SeatManage.ClassModel.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  = SeatManage.Bll.ServiceDateTime.Now.ToString();
                        violationRecords.EnterFlag     = SeatManage.EnumType.ViolationRecordsType.LeaveByAdmin;
                        violationRecords.Remark        = string.Format("在{0},{1}号座位,被管理员{2},在后台管理网站设置离开", roomInfo.Name, enterOutLog.ShortSeatNo, this.LoginId);
                        violationRecords.BlacklistID   = "-1";
                        SeatManage.Bll.T_SM_ViolateDiscipline.AddViolationRecords(violationRecords);
                    }
                }
                ret = Json(new { status = "yes", message = "设置读者离开成功" }, JsonRequestBehavior.AllowGet);
            }
            else
            {
                ret = Json(new { status = "no", message = "设置读者离开失败" }, JsonRequestBehavior.AllowGet);
            }

            return(ret);
        }
Beispiel #11
0
        public JsonResult ShortLeave(string seatNo, string seatShortNo, string used, string isShortLeave)
        {
            JsonResult ret = null;

            SeatManage.ClassModel.EnterOutLogInfo enterOutLog = SeatManage.Bll.T_SM_EnterOutLog.GetUsingEnterOutLogBySeatNo(seatNo);
            SeatManage.ClassModel.ReadingRoomInfo roomInfo    = SeatManage.Bll.T_SM_ReadingRoom.GetSingleRoomInfo(enterOutLog.ReadingRoomNo);

            if (isShortLeave == "y")
            {
                enterOutLog.EnterOutState = SeatManage.EnumType.EnterOutLogType.ShortLeave;
                enterOutLog.Flag          = SeatManage.EnumType.Operation.Admin;
                enterOutLog.Remark        = string.Format("在{0},{1}号座位,被管理员{2},在后台管理网站设置为暂离", roomInfo.Name, enterOutLog.ShortSeatNo, this.LoginId);
                int newId = -1;
                SeatManage.EnumType.HandleResult result = SeatManage.Bll.EnterOutOperate.AddEnterOutLog(enterOutLog, ref newId);
                if (result == SeatManage.EnumType.HandleResult.Successed)
                {
                    ret = Json(new { status = "yes", message = "设置读者暂离成功" }, JsonRequestBehavior.AllowGet);
                }
                else
                {
                    ret = Json(new { status = "no", message = "设置读者暂离失败" }, JsonRequestBehavior.AllowGet);
                }
            }
            else
            {
                enterOutLog.EnterOutState = SeatManage.EnumType.EnterOutLogType.ComeBack;
                enterOutLog.Flag          = SeatManage.EnumType.Operation.Admin;
                enterOutLog.Remark        = string.Format("在{0},{1}号座位,被管理员{2},在后台管理网站设置为在座", roomInfo.Name, enterOutLog.ShortSeatNo, this.LoginId);
                int newId = -1;
                SeatManage.EnumType.HandleResult result = SeatManage.Bll.EnterOutOperate.AddEnterOutLog(enterOutLog, ref newId);
                if (result == SeatManage.EnumType.HandleResult.Successed)
                {
                    List <SeatManage.ClassModel.WaitSeatLogInfo> waitSeatLogs = SeatManage.Bll.T_SM_SeatWaiting.GetWaitSeatList("", enterOutLog.EnterOutLogID, null, null, null);
                    SeatManage.ClassModel.WaitSeatLogInfo        waitSeatLog  = null;
                    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;
                        if (SeatManage.Bll.T_SM_SeatWaiting.UpdateWaitLog(waitSeatLog))
                        {
                            ret = Json(new { status = "yes", message = "取消读者暂离成功" }, JsonRequestBehavior.AllowGet);
                        }
                        else
                        {
                            ret = Json(new { status = "yes", message = "取消读者暂离成功,取消等待失败" }, JsonRequestBehavior.AllowGet);
                        }
                    }
                    else
                    {
                        ret = Json(new { status = "yes", message = "取消读者暂离成功" }, JsonRequestBehavior.AllowGet);
                    }
                }
                else
                {
                    ret = Json(new { status = "no", message = "取消读者暂离失败" }, JsonRequestBehavior.AllowGet);
                }
            }
            return(ret);
        }
Beispiel #12
0
        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();
                            SeatManage.ClassModel.EnterOutLogInfo enterOutLog = SeatManage.Bll.T_SM_EnterOutLog.GetUsingEnterOutLogBySeatNo(seatNo);
                            if (enterOutLog != null && enterOutLog.EnterOutState != SeatManage.EnumType.EnterOutLogType.ShortLeave)
                            {
                                SeatManage.ClassModel.ReadingRoomInfo roomInfo = SeatManage.Bll.T_SM_ReadingRoom.GetSingleRoomInfo(enterOutLog.ReadingRoomNo);
                                enterOutLog.EnterOutState = SeatManage.EnumType.EnterOutLogType.ShortLeave;
                                enterOutLog.Flag          = SeatManage.EnumType.Operation.Admin;
                                enterOutLog.Remark        = string.Format("在{0},{1}号座位,被管理员{2},通过手持设备设置为暂离", roomInfo.Name, enterOutLog.ShortSeatNo, Session["LoginID"].ToString());
                                int newId = -1;
                                SeatManage.EnumType.HandleResult result = SeatManage.Bll.EnterOutOperate.AddEnterOutLog(enterOutLog, ref newId);
                                if (result == SeatManage.EnumType.HandleResult.Successed)
                                {
                                    //PushMsgInfo msg = new PushMsgInfo();
                                    //msg.Title = "您好,您已被设置为暂离";
                                    //msg.MsgType = MsgPushType.AdminOperation;
                                    //msg.StudentNum = enterOutLog.CardNo;
                                    //msg.Message = enterOutLog.Remark;
                                    //SeatManage.Bll.T_SM_ReaderNotice.SendPushMsg(msg);


                                    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();
                            SeatManage.ClassModel.EnterOutLogInfo enterOutLog = SeatManage.Bll.T_SM_EnterOutLog.GetUsingEnterOutLogBySeatNo(seatNo);
                            if (enterOutLog != null && enterOutLog.EnterOutState == SeatManage.EnumType.EnterOutLogType.ShortLeave)
                            {
                                SeatManage.ClassModel.ReadingRoomInfo roomInfo = SeatManage.Bll.T_SM_ReadingRoom.GetSingleRoomInfo(enterOutLog.ReadingRoomNo);
                                enterOutLog.EnterOutState = SeatManage.EnumType.EnterOutLogType.ComeBack;
                                enterOutLog.Flag          = SeatManage.EnumType.Operation.Admin;
                                enterOutLog.Remark        = string.Format("在{0},{1}号座位,被管理员{2},通过手持设备取消暂离,恢复为在座", roomInfo.Name, enterOutLog.ShortSeatNo, Session["LoginID"].ToString());
                                int newId = -1;
                                SeatManage.EnumType.HandleResult result = SeatManage.Bll.EnterOutOperate.AddEnterOutLog(enterOutLog, ref newId);
                                if (result == SeatManage.EnumType.HandleResult.Successed)
                                {
                                    //PushMsgInfo msg = new PushMsgInfo();
                                    //msg.Title = "您好,您已恢复在座";
                                    //msg.MsgType = MsgPushType.AdminOperation;
                                    //msg.StudentNum = enterOutLog.CardNo;
                                    //msg.Message = enterOutLog.Remark;
                                    //SeatManage.Bll.T_SM_ReaderNotice.SendPushMsg(msg);

                                    List <SeatManage.ClassModel.WaitSeatLogInfo> waitSeatLogs = SeatManage.Bll.T_SM_SeatWaiting.GetWaitSeatList("", enterOutLog.EnterOutLogID, null, null, null);
                                    SeatManage.ClassModel.WaitSeatLogInfo        waitSeatLog  = null;
                                    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;
                                        if (SeatManage.Bll.T_SM_SeatWaiting.UpdateWaitLog(waitSeatLog))
                                        {
                                            //msg = new PushMsgInfo();
                                            //msg.Title = "您好,您的等待已被取消";
                                            //msg.MsgType = MsgPushType.AdminOperation;
                                            //msg.StudentNum = waitSeatLog.CardNo;
                                            //msg.Message = "您所等待的座位已被管理员释放,您的等待已被取消";
                                            //SeatManage.Bll.T_SM_ReaderNotice.SendPushMsg(msg);


                                            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();
                            SeatManage.ClassModel.EnterOutLogInfo enterOutLog = SeatManage.Bll.T_SM_EnterOutLog.GetUsingEnterOutLogBySeatNo(seatNo);
                            if (enterOutLog != null && enterOutLog.EnterOutState != SeatManage.EnumType.EnterOutLogType.Leave)
                            {
                                SeatManage.ClassModel.ReadingRoomInfo roomInfo = SeatManage.Bll.T_SM_ReadingRoom.GetSingleRoomInfo(enterOutLog.ReadingRoomNo);

                                enterOutLog.EnterOutState = SeatManage.EnumType.EnterOutLogType.Leave;
                                enterOutLog.Flag          = SeatManage.EnumType.Operation.Admin;
                                enterOutLog.Remark        = string.Format("在{0},{1}号座位,被管理员{2},通过手持设备设置离开", roomInfo.Name, enterOutLog.ShortSeatNo, Session["LoginID"].ToString());
                                int newId = -1;
                                SeatManage.EnumType.HandleResult result = SeatManage.Bll.EnterOutOperate.AddEnterOutLog(enterOutLog, ref newId);
                                if (result == SeatManage.EnumType.HandleResult.Successed)
                                {
                                    //PushMsgInfo msg = new PushMsgInfo();
                                    //msg.Title = "您好,您的座位已被释放";
                                    //msg.MsgType = MsgPushType.AdminOperation;
                                    //msg.StudentNum = enterOutLog.CardNo;
                                    //msg.Message = enterOutLog.Remark;
                                    //SeatManage.Bll.T_SM_ReaderNotice.SendPushMsg(msg);

                                    List <SeatManage.ClassModel.WaitSeatLogInfo> waitSeatLogs = SeatManage.Bll.T_SM_SeatWaiting.GetWaitSeatList("", enterOutLog.EnterOutLogID, null, null, null);
                                    SeatManage.ClassModel.WaitSeatLogInfo        waitSeatLog  = null;
                                    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;


                                        if (SeatManage.Bll.T_SM_SeatWaiting.UpdateWaitLog(waitSeatLog))
                                        {
                                            //msg = new PushMsgInfo();
                                            //msg.Title = "您好,您的等待已被取消";
                                            //msg.MsgType = MsgPushType.AdminOperation;
                                            //msg.StudentNum = waitSeatLog.CardNo;
                                            //msg.Message = "您所等待的座位已被管理员释放,您的等待已被取消";
                                            //SeatManage.Bll.T_SM_ReaderNotice.SendPushMsg(msg);
                                        }
                                    }
                                    SeatManage.ClassModel.RegulationRulesSetting rulesSet = SeatManage.Bll.T_SM_SystemSet.GetRegulationRulesSetting();
                                    if (roomInfo.Setting.IsRecordViolate)
                                    {
                                        if (roomInfo.Setting.BlackListSetting.Used)
                                        {
                                            if (roomInfo.Setting.BlackListSetting.ViolateRoule[SeatManage.EnumType.ViolationRecordsType.LeaveByAdmin])
                                            {
                                                SeatManage.ClassModel.ViolationRecordsLogInfo violationRecords = new SeatManage.ClassModel.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  = SeatManage.Bll.ServiceDateTime.Now.ToString();
                                                violationRecords.EnterFlag     = SeatManage.EnumType.ViolationRecordsType.LeaveByAdmin;
                                                violationRecords.Remark        = string.Format("在{0},{1}号座位,被管理员{2},通过手持设备设置离开", roomInfo.Name, enterOutLog.ShortSeatNo, Session["LoginID"].ToString());
                                                violationRecords.BlacklistID   = "-1";
                                                SeatManage.Bll.T_SM_ViolateDiscipline.AddViolationRecords(violationRecords);
                                            }
                                        }
                                        else if (rulesSet.BlacklistSet.Used && rulesSet.BlacklistSet.ViolateRoule[SeatManage.EnumType.ViolationRecordsType.LeaveByAdmin])
                                        {
                                            SeatManage.ClassModel.ViolationRecordsLogInfo violationRecords = new SeatManage.ClassModel.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  = SeatManage.Bll.ServiceDateTime.Now.ToString();
                                            violationRecords.EnterFlag     = SeatManage.EnumType.ViolationRecordsType.LeaveByAdmin;
                                            violationRecords.Remark        = string.Format("在{0},{1}号座位,被管理员{2},通过手持设备设置离开", roomInfo.Name, enterOutLog.ShortSeatNo, Session["LoginID"].ToString());
                                            violationRecords.BlacklistID   = "-1";
                                            SeatManage.Bll.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();
                            SeatManage.ClassModel.EnterOutLogInfo enterOutLog = SeatManage.Bll.T_SM_EnterOutLog.GetUsingEnterOutLogBySeatNo(seatNo);
                            if (enterOutLog != null && enterOutLog.EnterOutState != SeatManage.EnumType.EnterOutLogType.ShortLeave)
                            {
                                DateTime markTime = SeatManage.Bll.ServiceDateTime.Now;
                                SeatManage.Bll.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();
                            SeatManage.ClassModel.EnterOutLogInfo enterOutLog = SeatManage.Bll.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");
                                SeatManage.Bll.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;
                        SeatManage.ClassModel.RegulationRulesSetting rulesSet = SeatManage.Bll.T_SM_SystemSet.GetRegulationRulesSetting();
                        for (int i = 0; i < noArr.Length; i++)
                        {
                            newId  = -1;
                            seatNo = noArr[i].Trim();
                            SeatManage.ClassModel.EnterOutLogInfo enterOutLog = SeatManage.Bll.T_SM_EnterOutLog.GetUsingEnterOutLogBySeatNo(seatNo);
                            if (enterOutLog != null && enterOutLog.EnterOutState != SeatManage.EnumType.EnterOutLogType.Leave)
                            {
                                SeatManage.ClassModel.ReadingRoomInfo roomInfo = SeatManage.Bll.T_SM_ReadingRoom.GetSingleRoomInfo(enterOutLog.ReadingRoomNo);
                                if (roomInfo != null && roomInfo.Setting.BlackListSetting.Used)
                                {
                                    SeatManage.ClassModel.BlackListInfo blacklistModel = new SeatManage.ClassModel.BlackListInfo();
                                    blacklistModel.AddTime          = SeatManage.Bll.ServiceDateTime.Now;
                                    blacklistModel.ReadingRoomID    = roomInfo.No;
                                    blacklistModel.BlacklistState   = SeatManage.EnumType.LogStatus.Valid;
                                    blacklistModel.CardNo           = enterOutLog.CardNo;
                                    blacklistModel.OutBlacklistMode = roomInfo.Setting.BlackListSetting.LeaveBlacklist;
                                    if (blacklistModel.OutBlacklistMode == SeatManage.EnumType.LeaveBlacklistMode.AutomaticMode)
                                    {
                                        blacklistModel.ReMark  = string.Format("管理员{0}通过手持设备{0}把读者加入黑名单,记录黑名单{1}天", Session["LoginID"].ToString(), roomInfo.Setting.BlackListSetting.LimitDays);
                                        blacklistModel.OutTime = blacklistModel.AddTime.AddDays(roomInfo.Setting.BlackListSetting.LimitDays);
                                    }
                                    else
                                    {
                                        blacklistModel.ReMark = string.Format("管理员{0}通过手持设备把读者加入黑名单,手动离开黑名单", Session["LoginID"].ToString());
                                    }
                                    blacklistModel.ReadingRoomID = roomInfo.No;
                                    newId = SeatManage.Bll.T_SM_Blacklist.AddBlackList(blacklistModel);
                                }
                                else if (rulesSet.BlacklistSet.Used)
                                {
                                    SeatManage.ClassModel.BlackListInfo blacklistModel = new SeatManage.ClassModel.BlackListInfo();
                                    blacklistModel.AddTime          = SeatManage.Bll.ServiceDateTime.Now;
                                    blacklistModel.OutTime          = blacklistModel.AddTime.AddDays(rulesSet.BlacklistSet.LimitDays);
                                    blacklistModel.BlacklistState   = SeatManage.EnumType.LogStatus.Valid;
                                    blacklistModel.CardNo           = enterOutLog.CardNo;
                                    blacklistModel.OutBlacklistMode = rulesSet.BlacklistSet.LeaveBlacklist;
                                    if (blacklistModel.OutBlacklistMode == SeatManage.EnumType.LeaveBlacklistMode.AutomaticMode)
                                    {
                                        blacklistModel.ReMark  = string.Format("管理员{0}通过手持设备把读者加入黑名单,记录黑名单{1}天", Session["LoginID"].ToString(), rulesSet.BlacklistSet.LimitDays);
                                        blacklistModel.OutTime = blacklistModel.AddTime.AddDays(rulesSet.BlacklistSet.LimitDays);
                                    }
                                    else
                                    {
                                        blacklistModel.ReMark = string.Format("管理员{0}通过手持设备把读者加入黑名单,手动离开黑名单", Session["LoginID"].ToString());
                                    }
                                    blacklistModel.ReadingRoomID = roomInfo.No;
                                    newId = SeatManage.Bll.T_SM_Blacklist.AddBlackList(blacklistModel);
                                }
                                else
                                {
                                    Page.RegisterStartupScript("", "<script>alert('对不起,此阅览室以及图书馆没有启用黑名单功能');</script>");
                                    return;
                                }
                                if (newId > 0)
                                {
                                    enterOutLog.EnterOutState = SeatManage.EnumType.EnterOutLogType.Leave;
                                    enterOutLog.Flag          = SeatManage.EnumType.Operation.Admin;
                                    enterOutLog.Remark        = string.Format("在{0},{1}号座位,被管理员{2},通过手持设备设置离开", roomInfo.Name, enterOutLog.ShortSeatNo, Session["LoginID"].ToString());

                                    SeatManage.EnumType.HandleResult result = SeatManage.Bll.EnterOutOperate.AddEnterOutLog(enterOutLog, ref newId);
                                    if (result == SeatManage.EnumType.HandleResult.Successed)
                                    {
                                        Page.RegisterStartupScript("", "<script>alert('设置读者黑名单成功');</script>");
                                        GetSeatList(selectReadingRomm.Items[selectReadingRomm.SelectedIndex].Value, selectSeatState.Items[selectSeatState.SelectedIndex].Value);
                                    }
                                    else
                                    {
                                        Page.RegisterStartupScript("", "<script>alert('设置读者黑名单失败');</script>");
                                    }
                                }
                                else
                                {
                                }
                            }
                        }
                    }
                    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
            }
        }