acdtapi.c

TAPI ACD Samples

        pEntry->dwNameOffset = dwNameOffset;
        lstrcpy(pName,
                szBuffer);

        dwNameOffset += pEntry->dwNameSize;
        
        pEntry++;

    } // for

    // fill in used size
    pActivityList->dwUsedSize = dwTotalSize;
    
    return 0;
}


#define DWAGENTFEATURES         LINEAGENTFEATURE_SETAGENTGROUP | \
                                LINEAGENTFEATURE_SETAGENTSTATE | \
                                LINEAGENTFEATURE_SETAGENTACTIVITY | \
                                LINEAGENTFEATURE_GETAGENTACTIVITYLIST | \
                                LINEAGENTFEATURE_GETAGENTGROUP

#define DWSTATES                LINEAGENTSTATE_LOGGEDOFF | \
                                LINEAGENTSTATE_NOTREADY | \
                                LINEAGENTSTATE_READY | \
                                LINEAGENTSTATE_BUSYACD | \
                                LINEAGENTSTATE_BUSYINCOMING | \
                                LINEAGENTSTATE_BUSYOUTBOUND | \
                                LINEAGENTSTATE_BUSYOTHER | \
                                LINEAGENTSTATE_WORKINGAFTERCALL | \
                                LINEAGENTSTATE_UNKNOWN | \
                                LINEAGENTSTATE_UNAVAIL

#define DWNEXTSTATES            LINEAGENTSTATE_LOGGEDOFF | \
                                LINEAGENTSTATE_NOTREADY | \
                                LINEAGENTSTATE_READY | \
                                LINEAGENTSTATE_BUSYACD | \
                                LINEAGENTSTATE_BUSYINCOMING | \
                                LINEAGENTSTATE_BUSYOUTBOUND | \
                                LINEAGENTSTATE_BUSYOTHER | \
                                LINEAGENTSTATE_WORKINGAFTERCALL | \
                                LINEAGENTSTATE_UNKNOWN | \
                                LINEAGENTSTATE_UNAVAIL

#define DWSTATUSMESSAGES        LINEAGENTSTATUS_GROUP | \
                                LINEAGENTSTATUS_STATE | \
                                LINEAGENTSTATUS_NEXTSTATE | \
                                LINEAGENTSTATUS_ACTIVITY | \
                                LINEAGENTSTATUS_ACTIVITYLIST | \
                                LINEAGENTSTATUS_GROUPLIST | \
                                LINEAGENTSTATUS_CAPSCHANGE | \
                                LINEAGENTSTATUS_VALIDSTATES | \
                                LINEAGENTSTATUS_VALIDNEXTSTATES


////////////////////////////////////////////////////////////////////
//
//  BOOL IsValidState(DWORD dwState)
//
////////////////////////////////////////////////////////////////////
BOOL IsValidState(DWORD dwState)
{
    if (!dwState)
    {
        return TRUE;
    }

    if ((dwState) & (dwState - 1))
    {
        // more than one bit set
        return FALSE;
    }

    // make sure it's one of the valid states
    return (dwState & DWSTATES);

}


////////////////////////////////////////////////////////////////////
//
//  BOOL IsValidNextState(DWORD dwState)
//
////////////////////////////////////////////////////////////////////
BOOL IsValidNextState(DWORD dwState)
{
    if (!dwState)
    {
        return TRUE;
    }

    if ((dwState) & (dwState - 1))
    {
        // more than one bit set
        return FALSE;
    }

    // make sure it's one of the valid states
    return (dwState & DWNEXTSTATES);

}


///////////////////////////////////////////////////////////////////////
//
//  BOOL IsValidActivityID(DWORD dwActivityID)
//
///////////////////////////////////////////////////////////////////////
BOOL IsValidActivityID(DWORD dwActivityID)
{
    return (dwActivityID <= TOTALACTIVITIES);
}



////////////////////////////////////////////////////////////////////////
//
//  LRESULT MakeAgentCaps(PAGENT pAgent,
//                        LPLINEAGENTCAPS pAgentCaps)
//
//    Creates a LINEAGENTCAPS for pAgent
//    Features/states/messages are hardcoded
//     for this example
//
////////////////////////////////////////////////////////////////////////
LRESULT MakeAgentCaps(PAGENT pAgent,
                      LPLINEAGENTCAPS pAgentCaps)
{
    DWORD       dwStringSize;
    
    dwStringSize = (lstrlen(SZAPPNAME) + 1) * sizeof(TCHAR);

    pAgentCaps->dwNeededSize = sizeof(LINEAGENTCAPS) + dwStringSize;

    if (pAgentCaps->dwTotalSize < pAgentCaps->dwNeededSize)
    {
        pAgentCaps->dwUsedSize = sizeof(LINEAGENTCAPS);
        return 0;
//        return LINEERR_STRUCTURETOOSMALL;
    }

    
    pAgentCaps->dwAgentHandlerInfoSize = dwStringSize;
    pAgentCaps->dwAgentHandlerInfoOffset = sizeof(LINEAGENTCAPS);

    pAgentCaps->dwCapsVersion = TAPI_CURRENT_VERSION;

    // these features are hardcoded here.
    // a real implementation may set specific features
    // per agent or line or address
    pAgentCaps->dwFeatures              = DWAGENTFEATURES;
    pAgentCaps->dwStates                = DWSTATES;
    pAgentCaps->dwNextStates            = DWNEXTSTATES;
    pAgentCaps->dwMaxNumGroupEntries    = NUMGROUPENTRIES;
    pAgentCaps->dwAgentStatusMessages   = DWSTATUSMESSAGES;

    // no extensions
    pAgentCaps->dwNumAgentExtensionIDs = 0;
    pAgentCaps->dwAgentExtensionIDListSize = 0;
    pAgentCaps->dwAgentExtensionIDListOffset = 0;


    pAgentCaps->dwUsedSize = pAgentCaps->dwNeededSize;
    
    return 0;
}


//////////////////////////////////////////////////////////////////////////
//
//  LRESULT GetAgentStatus()
//
//  Creates a LINEAGENTSTATUS for pAgent
//
//////////////////////////////////////////////////////////////////////////
LRESULT GetAgentStatus(PAGENT pAgent,
                       DWORD dwAddress,
                       LPLINEAGENTSTATUS pAgentStatus)
{
    PGROUP                  pGroup;
    LPLINEAGENTGROUPENTRY   pGroupEntry;
    DWORD                   dwTotalSize, dwNameOffset, dwCount;
    TCHAR                   szActivityName[NAMESIZE];
    PGROUP *                ppGroups;
    PLISTITEM               pEntry;

    // init total size
    dwTotalSize = sizeof(LINEAGENTSTATUS);

    if (dwAddress >= pAgent->dwNumAddresses)
    {
        return LINEERR_INVALADDRESSID;
    }
    
    // set know members
    // for valid states / next states / agent features, just setting it to
    // generic stuff.  a real implementation may want to set these
    // field depending on current state / agent / hline
    pAgentStatus->dwState           = pAgent->pAddressInfo[dwAddress].dwState;
    pAgentStatus->dwNextState       = pAgent->pAddressInfo[dwAddress].dwNextState;
    pAgentStatus->dwActivityID      = pAgent->pAddressInfo[dwAddress].dwActivity;
    pAgentStatus->dwAgentFeatures   = DWAGENTFEATURES;
    pAgentStatus->dwValidStates     = DWSTATES;
    pAgentStatus->dwValidNextStates = DWNEXTSTATES;

    // create the activity name
    wsprintf(szActivityName, TEXT("Activity %lu"), pAgent->pAddressInfo[dwAddress].dwActivity);
    dwTotalSize += (lstrlen(szActivityName) + 1) * sizeof(TCHAR);

    ppGroups = (PGROUP *)ACDAlloc(sizeof(PGROUP) * g.dwNumGroups);

    pGroup = g.pGroups;

    pAgentStatus->dwNumEntries = 0;

    // walk list of groups
    while (pGroup)
    {
        pEntry = pGroup->pAgentList;

        // walk each agent in each group
        while (pEntry)
        {
            if (pEntry->pAgent == pAgent)
            {
                if ((!pEntry->bLoggedIn) ||
                    (pEntry->dwAddress != dwAddress))
                {
                    break;
                }

                // save group
                ppGroups[pAgentStatus->dwNumEntries] = pGroup;

                // adjust total size / entries
                pAgentStatus->dwNumEntries++;
                dwTotalSize += sizeof(LINEAGENTGROUPENTRY);
                dwTotalSize += (lstrlen(pGroup->lpszName) + 1) * sizeof(TCHAR);

                break;
            }

            pEntry = pEntry->pNext;
            
        }  // while (pEntry)

        pGroup = pGroup->pNext;
        
    } // while (pGroup)

    // set needed size
    pAgentStatus->dwNeededSize = dwTotalSize;

    // do we have enough room?
    if (pAgentStatus->dwTotalSize < dwTotalSize)
    {
        // if not, return
        pAgentStatus->dwUsedSize = sizeof(LINEAGENTSTATUS);
        ACDFree(ppGroups);

        return 0;
//        return LINEERR_STRUCTURETOOSMALL;
    }


    // set the group entries...

    // first get the offset to the first entry
    pGroupEntry = (LPLINEAGENTGROUPENTRY)(((LPBYTE)pAgentStatus) + sizeof(LINEAGENTSTATUS));
    pAgentStatus->dwGroupListOffset = sizeof(LINEAGENTSTATUS);

    // figure out where the names can go (after all the fixed structures)
    dwNameOffset = sizeof(LINEAGENTSTATUS) +
                   sizeof(LINEAGENTGROUPENTRY) * pAgentStatus->dwNumEntries;

    // loop through all the group that the agent is logged into
    for (dwCount = 0; dwCount < pAgentStatus->dwNumEntries; dwCount++)
    {
        // set the it (just the pGroup)
        pGroupEntry->GroupID.dwGroupID1 = (DWORD)ppGroups[dwCount];
        pGroupEntry->GroupID.dwGroupID2 = 0;
        pGroupEntry->GroupID.dwGroupID3 = 0;
        pGroupEntry->GroupID.dwGroupID4 = 0;

        // set name size and offset
        pGroupEntry->dwNameSize = (lstrlen(ppGroups[dwCount]->lpszName) + 1) * sizeof(TCHAR);
        pGroupEntry->dwNameOffset = dwNameOffset;

        // copy name
        lstrcpy((LPTSTR)(((LPBYTE)pAgentStatus) + dwNameOffset),
                ppGroups[dwCount]->lpszName);

        // fix the name offset
        dwNameOffset += pGroupEntry->dwNameSize;

        // next entry
        pGroupEntry++;
        
    }

    pAgentStatus->dwGroupListSize = dwNameOffset - pAgentStatus->dwGroupListOffset;
    
    // put the activity name at the end
    pAgentStatus->dwActivitySize = (lstrlen(szActivityName) + 1) * sizeof(TCHAR);
    pAgentStatus->dwActivityOffset = dwNameOffset;

    lstrcpy((LPTSTR)(((LPBYTE)pAgentStatus) + dwNameOffset),
            szActivityName);

    
    ACDFree(ppGroups);

    pAgentStatus->dwUsedSize = pAgentStatus->dwNeededSize;
    // return success
    return 0;
}


/////////////////////////////////////////////////////////////////////
//
//  LRESULT SetAgentState()
//
//    Sets the current and next state for pAgent
//    on that specific address
//
//
/////////////////////////////////////////////////////////////////////
LRESULT SetAgentState(PAGENT pAgent,
                      DWORD dwAddress,
                      DWORD dwState,
                      DWORD dwNextState)
{
    // make sure valid
    if ((!IsValidState(dwState)) ||
        (!IsValidNextState(dwNextState)))
    {
        return LINEERR_INVALAGENTSTATE;
    }

    // check address
    if (dwAddress >= pAgent->dwNumAddresses)
    {
        return LINEERR_INVALADDRESSID;
    }

    // set the state if specified
    if (dwState)
    {
        pAgent->pAddressInfo[dwAddress].dwState = dwState;
    }

    if (dwNextState)
    {
        pAgent->pAddressInfo[dwAddress].dwNextState = dwNextState;
    }
    
    return 0;
}


///////////////////////////////////////////////////////////////////////////////
//
//  LRESULT SetAgentActivity()
//
//   Sets the activity for pAgent
//
///////////////////////////////////////////////////////////////////////////////
LRESULT SetAgentActivity(PAGENT pAgent,
                         DWORD dwAddress,
                         DWORD dwActivityID)
{
    if (dwAddress >= pAgent->dwNumAddresses)
    {
        return LINEERR_INVALADDRESSID;
    }

    if (!IsValidActivityID(dwActivityID))
    {
        return LINEERR_INVALAGENTACTIVITY;
    }

    pAgent->pAddressInfo[dwAddress].dwActivity = dwActivityID;
    
    return 0;
}


////////////////////////////////////////////////////////////////////////////////
//
//  BOOL HandleOffering(HCALL hCall)
//
//    Handles a LINECALLSTATE_OFFERING message
//      Determines the group associated with the address
//      that the call came in on, finds an available
//      agent in that group, and transfers the call to that
//      agent.
//
////////////////////////////////////////////////////////////////////////////////
BOOL HandleOffering(HCALL hCall)
{
    LPLINECALLINFO      pLCI;
    PGROUP              pGroup;