private void DoLineupCall(LineUpData lineupInfo, QueueData queueData)
        {
            DateTime callTime = _qm.GetServerStamp();

            lineupInfo.检查房间 = _stationInfo.RoomName;

            if (lineupInfo.附加信息.首次呼叫时间 == default(DateTime))
            {
                lineupInfo.附加信息.首次呼叫时间 = callTime;
            }
            lineupInfo.附加信息.末次呼叫时间 = callTime;
            lineupInfo.附加信息.播放站点   = queueData.队列信息.播放站点;

            if (lineupInfo.排队状态 == LineUpState.qsQueueing)
            {
                lineupInfo.排队状态 = LineUpState.qsWaitCall;
            }

            lineupInfo.附加信息.CopyBasePro(lineupInfo);


            LineCallData callInfo = new LineCallData();

            callInfo.呼叫ID = SqlHelper.GetNumGuid();
            callInfo.排队ID = lineupInfo.排队ID;
            callInfo.队列ID = lineupInfo.队列ID;
            callInfo.生成日期 = callTime;
            callInfo.呼叫站点 = queueData.队列信息.播放站点;


            callInfo.呼叫信息.原始内容 = queueData.队列信息.呼叫格式.Replace("[排队号码]", lineupInfo.号码前缀 + lineupInfo.排队号码).Replace("[患者姓名]", lineupInfo.患者姓名).Replace("[检查房间]", lineupInfo.检查房间).Replace("[科室名称]", lineupInfo.科室名称);
            callInfo.呼叫信息.格式内容 = queueData.队列信息.呼叫格式.Replace("[排队号码]", lineupInfo.号码前缀 + lineupInfo.排队号码).Replace("[患者姓名]", PYConvert.FormatCallSurname(lineupInfo.患者姓名)).Replace("[检查房间]", lineupInfo.检查房间).Replace("[科室名称]", lineupInfo.科室名称);

            callInfo.呼叫信息.CopyBasePro(callInfo);


            _qm.TransactionBegin();

            try
            {
                _qm.UpdateLineupInfo(lineupInfo);

                _qm.NewCall(callInfo);

                _qm.TransactionCommit();
            }
            catch (Exception ex)
            {
                _qm.TransactionRollback();

                throw ex;
            }
        }
示例#2
0
        private void LoopPlay()
        {
            DataRow drPlay = _dtCall.Rows[0];

            if (_isStop)
            {
                return;
            }


            LineCallData linecallInfo = new LineCallData();

            linecallInfo.BindRowData(drPlay);

            LineUpData lineupInfo = QueueModel.GetLineupInfo(linecallInfo.排队ID);


            //更新状态未正在呼叫
            lineupInfo.排队状态 = LineUpState.qsCalling;

            lineupInfo.附加信息.末次呼叫时间 = QueueModel.GetServerDate();
            lineupInfo.附加信息.CopyBasePro(lineupInfo);

            QueueModel.UpdateLineupInfo(lineupInfo);

            if (_isStop)
            {
                return;
            }

            DoActions(QueueVoiceEventDefine.Refresh, null);

            if (_isStop)
            {
                return;
            }

            //播放声音
            StartPlay(linecallInfo, lineupInfo);

            if (_isStop)
            {
                return;
            }
        }
示例#3
0
        private void StartPlay(LineCallData lineupCallInfo, LineUpData lineupInfo)
        {
            BackgroundWorker bgWork = new BackgroundWorker();

            bgWork.DoWork             += DoWork;
            bgWork.ProgressChanged    += ProgessChanged;
            bgWork.RunWorkerCompleted += WorkerCompleted;

            bgWork.WorkerReportsProgress      = false;
            bgWork.WorkerSupportsCancellation = true;

            ThreadVoicePar lineVoicePar = new ThreadVoicePar();

            lineVoicePar.LineCallInfo = lineupCallInfo;
            lineVoicePar.LineUpInfo   = lineupInfo;

            bgWork.RunWorkerAsync(lineVoicePar);
        }
示例#4
0
        private void DoWork(object sender, DoWorkEventArgs e)
        {
            lock (objLockWork)
            {
                if (e.Argument == null)
                {
                    throw new Exception("播放参数传递无效。");
                }

                ThreadVoicePar lineVoicePar = e.Argument as ThreadVoicePar;
                if (lineVoicePar == null)
                {
                    throw new Exception("播放参数信息无效。");
                }

                LineCallData lineCallInfo = lineVoicePar.LineCallInfo;
                LineUpData   lineupInfo   = lineVoicePar.LineUpInfo;
                try
                {
                    if (_isStop)
                    {
                        return;
                    }

                    if (_queueVoiceDesign.PlayHintSound)
                    {
                        SoundPlayer sp = new SoundPlayer(Properties.Resources.DingDong);
                        sp.PlaySync();
                    }

                    if (_isStop)
                    {
                        return;
                    }

                    //执行语音播放
                    for (int i = 0; i < _queueVoiceDesign.PlayCount; i++)
                    {
                        if (_isStop)
                        {
                            break;
                        }
                        PlaySound(lineCallInfo.呼叫信息.格式内容);
                    }

                    //更新状态为呼叫完成
                    lineupInfo.排队状态 = LineUpState.qsCalled;

                    QueueModel.TransactionBegin();

                    try
                    {
                        QueueModel.UpdateLineupInfo(lineupInfo);

                        //删除播放内容
                        QueueModel.DelCallInfoByCallId(lineCallInfo.呼叫ID);

                        QueueModel.TransactionCommit();

                        DataRow drBind = lineCallInfo.GetBindRow();
                        if (drBind != null)
                        {
                            _dtCall.Rows.Remove(drBind);
                        }
                        //e.Result = lineCallInfo.GetBindRow();
                    }
                    catch (Exception ex)
                    {
                        QueueModel.TransactionRollback();
                        throw new Exception("更新语音播放后的排队信息出现错误", ex);;
                    }
                }
                catch (Exception ex)
                {
                    try
                    {
                        lineupInfo.排队状态        = LineUpState.qsWaitCall;
                        lineupInfo.附加信息.末次呼叫时间 = QueueModel.GetServerDate();

                        QueueModel.UpdateLineupInfo(lineupInfo);
                    }
                    catch (Exception exd)
                    {
                        throw new Exception("恢复语音播放前的排队状态错误", exd);
                    }

                    throw new Exception("排队语音播放错误", ex);
                }
            }
        }