예제 #1
0
        protected void checkReservations()
        {
            Hashtable tableToClear = new Hashtable();


            foreach (AgentAccount agent in table.Values)
            {
                if (agent.HasIncident)
                {
                    TimeSpan max = new TimeSpan(0, 0, 15);

                    if (TimeSpan.Compare(agent.Reserved, max) > 0)
                    {
                        Int32 incidentId       = agent.IncidentId;
                        Int32 incidentStatusId = BllProxyIncidentHelper.GetIncidentStatus(incidentId);

                        if (incidentStatusId == 1)
                        {
                            BllProxyIncidentHelper.SetIncidentReservation(incidentId, 0);
                            agent.IsBusy = false;

                            tableToClear.Add(agent.AgentId, null);
                        }
                    }
                }
            }



            foreach (Int32 agentId in tableToClear.Keys)
            {
                //this.UnRegisterAgent(agentId);
                this.SetAgentAvailable(agentId, false);
            }
        }
예제 #2
0
        /// <summary>
        /// Clear the Incident's ReservedAgent and Disable Agent not taking the call
        /// </summary>
        /// <param name="dtAllPoolAgents"></param>
        /// <returns></returns>
        protected bool checkReservations(PoolDS.PoolDSDataTable dtAllPoolAgents)
        {
            bool result = false;

            PoolDS.PoolDSRow[] rows = (PoolDS.PoolDSRow[])dtAllPoolAgents.Select("is_available=1 and is_busy=0", "");
            if (rows.Length > 0)
            {
                int cancelInterval = UcConfParameters.UcCallForwardingInterval;     // seconds


                foreach (PoolDS.PoolDSRow row in dtAllPoolAgents.Rows)
                {
                    if ((!row.Isincident_idNull()) && (!row.Isdate_reservedNull()))
                    {
                        DateTime now  = DateTime.Now.ToUniversalTime();
                        TimeSpan span = now.Subtract(row.date_reserved);
                        TimeSpan max  = new TimeSpan(0, 0, cancelInterval);

                        if (TimeSpan.Compare(span, max) > 0)
                        {
                            Int32 incidentId = row.incident_id;

                            Int32 incidentStatusId = 0;
                            Int32 incidentAgentId  = 0;

                            IncidentDS.IncidentDSDataTable dtIncident = BllProxyIncident.SelectIncident(incidentId);
                            if (dtIncident.Rows.Count > 0)
                            {
                                incidentStatusId = dtIncident[0].status_id;
                                if (!dtIncident[0].Isagent_idNull())
                                {
                                    incidentAgentId = dtIncident[0].agent_id;
                                }
                            }



                            if (incidentAgentId == 0)
                            {
                                if (incidentStatusId == 1)
                                {
                                    BllProxyIncidentHelper.SetIncidentReservation(incidentId, 0);
                                    BllProxyPool.SetPoolAgentAvailable(row.agent_id, false);
                                    BllProxyPool.SetPoolAgentBusy(row.agent_id, false);
                                }
                                else
                                {
                                    BllProxyPool.SetPoolAgentAvailable(row.agent_id, true);
                                    BllProxyPool.SetPoolAgentBusy(row.agent_id, true);
                                }
                            }

                            result = true;
                        }
                    }
                }
            }

            return(result);
        }
예제 #3
0
        protected void handleIncidentQueue()
        {
            IncidentDS.IncidentDSDataTable dt;

            DataTable dt0 = convertToDataset(table);

            DataRow[] rows = dt0.Select("", "rating");

            foreach (DataRow agentRow in rows)
            {
                int rating = Convert.ToInt32(agentRow["rating"]);

                Int32        agentId      = Convert.ToInt32(agentRow["agent_id"]);
                AgentAccount agentAccount = this.GetAgent(agentId);


                if ((agentAccount.IsAvailable) && (!agentAccount.IsBusy))
                {
                    dt = BllProxyIncident.GetIncidentQueueList(1, agentAccount.AgentId);   //1:New

                    foreach (IncidentDS.IncidentDSRow rowIncident in dt)
                    {
                        if (rowIncident.Isreserved_agent_idNull())
                        {
                            Int32 incidentId = rowIncident.incident_id;
                            BllProxyIncidentHelper.SetIncidentReservation(incidentId, agentAccount.AgentId);

                            agentAccount.Reserve();
                            agentAccount.IsBusy     = true;
                            agentAccount.IncidentId = incidentId;

                            break;
                        }

                        //---
                    }
                }
            }
        }
예제 #4
0
        /// <summary>
        /// Assign the Incident to the available Agent
        /// </summary>
        /// <param name="dtAllPoolAgents"></param>
        /// <returns></returns>
        protected bool handleIncidentQueue(PoolDS.PoolDSDataTable dtAllPoolAgents)
        {
            bool result = false;

            IncidentDS.IncidentDSDataTable dt;

            PoolDS.PoolDSRow[] rows = (PoolDS.PoolDSRow[])dtAllPoolAgents.Select("", "last_call_time");

            foreach (PoolDS.PoolDSRow row in rows)
            {
                Int32 agentId = row.agent_id;

                if ((row.is_available) && (!row.is_busy))
                {
                    dt = BllProxyIncident.GetIncidentQueueList(1, agentId);   //1:New

                    foreach (IncidentDS.IncidentDSRow rowIncident in dt)
                    {
                        if (rowIncident.Isreserved_agent_idNull())
                        {
                            Int32 incidentId = rowIncident.incident_id;
                            BllProxyIncidentHelper.SetIncidentReservation(incidentId, agentId);

                            BllProxyPool.SetPoolAgentBusy(agentId, true);
                            BllProxyPool.SetPoolAgentIncident(agentId, incidentId);

                            result = true;
                            break;
                        }

                        //---
                    }
                }
            }


            return(result);
        }