On Jun 29, 3:31*pm, mlu... (AT) doxgroup (DOT) com wrote:
Quote:
Anyone every done this? *Maybe from Altigen or another phone system?
Just looking for the best way to handle this. |
If you architect it right, you can make it highly scalable and you
won't have to do "polling". Eg. A CTI application that I did for the
US. Census 2000, had to handle 6000 agent workstations across 30 call
centers (7-timezones) and 7-different PBX switches. Despite the
scale, the solution is fairly common: The client workstations
stations were largely a browser-interface (wrappered inside of a light-
weight C++ application (any desktop technology should work) in-part
to lock down any Agent accesses to their other applications on the
desktop, but mostly to receive CTI push events (from a bridge server)
for preempting new browser pages, or to transmit browser states (when
certain application page(s) were reached; also useful to transmit
heart-beats for communicating system health and/or applying fail-over
technologies.)
Try to think of the fundamental problem as being a "state-driven
workflow engine" (around a logical/physical "bridge" server used to
'consolidate' and 'propagate' state.) The bridge server needn't be
centralized (ie. it could reside in logic managed distributively at
the client, however there are advantages in centralizing.) When calls
come in from the cloud (including possibly via IVR front-ends,
outbound dialers, or are transferred from other Agents; or the caller
initiates a hang up; et al) the bridge would receive events (state-
changes) sent from the PBX and/or IVR data. When Agents are
"available" (within the browser application, ie. whether at a post-
login page, or post their manually dispositioning a previous phone
call) ie. when the browser will arrive at a certain page(s) -- that
indicates the Agent is "ready" (as seen by the C++ wrapper which
processes this navigation monitoring event and propagates it to the
bridge workflow engine. Also, the PBX (upon an agent putting their
headset into available state, "on hold", or hanging up...) would cause
an event to the bridge server (which may elect to propagate such
outward.)
Effectively, the bridge server (or like functionality) is used to
receive the event(s) from the PBX (for caller-side events, Agent-side
events), dialer events, IVR events, the desktop (browser) Application
events -- and upon processing the events against its current state,
can push back (disposition) events to any of the above.
eg. One straightforward thread is: an incoming call goes to an IVR,
the caller navigates the menu and/or answering certain IVR
questions... subsequently requesting transfer to an agent. The
conditions which satisfy that an Agent is "available" (as per both
their telephony and their application desktop) -- is present at the
PBX and when the PBX transfers the call to the Agents telephony
device, the bridge server is informed and then pushes an event to the
appropriate C++ (in our case) control wrapper to pop the CTI
information (ANI and IVR variables) via interjecting such into the
browser application (that may subsequently cause a further server-side
data-dip and/or additional workflow logic to retrieve extra
information as a result of the padded browser request.)