Wrapup Time Per Member

AhmedShehata · February 27, 2023, 12:27pm

Hi All ,

Is there any way to set Wrapup time for a Member in Queue ?

Thank You.

PitzKey · February 27, 2023, 12:38pm

Looks like it

asterisk/asterisk/blob/master/configs/samples/queues.conf.sample#L529


      
          ; hint:<extension>@<context>. If no context is specified then 'default' will
          ; be used.
          ;
          ; It is important to ensure that channel drivers used for members are loaded
          ; before app_queue.so itself or they may be marked invalid until reload. This
          ; can be accomplished by explicitly listing them in modules.conf before
          ; app_queue.so.  Additionally, if you use Local channels as queue members, you
          ; must also preload pbx_config.so and chan_local.so (or pbx_ael.so, pbx_lua.so,
          ; or pbx_realtime.so, depending on how your dialplan is configured).
          ;
          ; syntax: member => interface,[,penalty][,membername][,state_interface][,ringinuse][,wrapuptime]
          ;
          ;member => DAHDI/1
          ;member => DAHDI/2,10
          ;member => DAHDI/3,10,Bob Johnson
          ;member => Local/1001@agents,0,May Flowers,Agent:1001
          ;member => Local/1002@agents,0,John Doe,Agent:1002
          ;member => Local/1000@default,0,John Smith,SIP/1000
          ;member => Local/2000@default,0,Lorem Ipsum,SIP/2000,no

benphone · February 27, 2023, 12:39pm

AddQueueMember(queuename,[interface,[penalty,[options,[membername,[stateinterface,[wrapuptime]]]]]])

AhmedShehata · February 27, 2023, 12:50pm

But there any way to skip Wrapup time that had been set globaly for Queue ?

benphone · February 27, 2023, 12:55pm

is should work like this .
if no Wrapup was set to member it uses the queue Wrapup time
if member is set it should override the Wrapup time defined in queue

AhmedShehata · February 27, 2023, 1:12pm

Do you know location of Wrapup time counter ? like how this work internaly , I am trying to let the memebr skip this wrapup time without relogin again to the queue .

david551 · February 27, 2023, 1:39pm

Asterisk is open source, so the code for this is freely viewable, and easy to find. There isn’t a wrapup time counter. What is actually stored is the end time of the last call and the remaining wrapup time is calculated from that and the allowance:

github.com

asterisk/asterisk/blob/master/apps/app_queue.c#L2615


      
          			/* else fall through */
          		case AST_DEVICE_NOT_INUSE:
          		case AST_DEVICE_UNKNOWN:
          			if (!mem->paused) {
          				available = 1;
          			}
          			break;
          	}
          
          
	/* Let wrapuptimes override device state availability */
          	wrapuptime = get_wrapuptime(q, mem);
          	if (mem->lastcall && wrapuptime && (time(NULL) - wrapuptime < mem->lastcall)) {
          		available = 0;
          	}
          	return available;
          }
          
          
/*! \brief set a member's status based on device state of that member's interface*/
          static void device_state_cb(void *unused, struct stasis_subscription *sub, struct stasis_message *msg)
          {
          	struct ao2_iterator miter, qiter;

The last call time is stored in the member data structure:

github.com

asterisk/asterisk/blob/master/apps/app_queue.c#L1731


      
          	int calls;                           /*!< Number of calls serviced by this member */
          	int dynamic;                         /*!< Are we dynamically added? */
          	int realtime;                        /*!< Is this member realtime? */
          	int status;                          /*!< Status of queue member */
          	int paused;                          /*!< Are we paused (not accepting calls)? */
          	char reason_paused[80];              /*!< Reason of paused if member is paused */
          	int queuepos;                        /*!< In what order (pertains to certain strategies) should this member be called? */
          	int callcompletedinsl;               /*!< Whether the current call was completed within service level */
          	int wrapuptime;                      /*!< Wrapup Time */
          	time_t starttime;                    /*!< The time at which the member answered the current caller. */
          	time_t lastcall;                     /*!< When last successful call was hungup */
          	time_t lastpause;                    /*!< When started the last pause */
          	time_t logintime;                    /*!< The time when started the login */
          	struct call_queue *lastqueue;        /*!< Last queue we received a call */
          	unsigned int dead:1;                 /*!< Used to detect members deleted in realtime */
          	unsigned int delme:1;                /*!< Flag to delete entry on reload */
          	char rt_uniqueid[80];                /*!< Unique id of realtime member entry */
          	unsigned int ringinuse:1;            /*!< Flag to ring queue members even if their status is 'inuse' */
          };
          
          
enum empty_conditions {

You can clear this for all members in the queue, which will cancel all the wrapup times until the respective member next completes a call, but not for an individual member. That is done by clearing the queue statistics.

What is the real world problem you are trying to solve?

Specifically:

github.com

asterisk/asterisk/blob/master/apps/app_queue.c#L1977


      
          
          
/*!
           * \brief Return wrapuptime
           *
           * This function checks if wrapuptime in member is set and return this value.
           * Otherwise return value the wrapuptime in the queue configuration
           * \return integer value
           */
          static int get_wrapuptime(struct call_queue *q, struct member *member)
          {
          	if (member->wrapuptime) {
          		return member->wrapuptime;
          	}
          	return q->wrapuptime;
          }
          
          
/*! \internal
           * \brief ao2_callback, Decreases queuepos of all followers with a queuepos greater than arg.
           * \param obj the member being acted on
           * \param arg pointer to an integer containing the position value that was removed and requires reduction for anything above
           * \param flag unused

AhmedShehata · February 27, 2023, 1:44pm

Thank you david for this great calrification ,my struggle here that I am trying to do something to let the member skip the wrapup time that had been defiend globaly per queue and this only for the member not for the whole queue .

david551 · February 27, 2023, 2:06pm

I think the only way to selectively clear the last call time is to delete and re-add the member.

If it is normal to release a member early from wrap up, it might be better to pause them when they accept a call. You could do that from a queue answer gosub.

I’m not convinced that many peole actual use wrapup time.

benphone · February 27, 2023, 2:18pm

how would you unpause after a certain amount of time ?

david551 · February 27, 2023, 2:31pm

If it’s normal to end wrap up early, you wouldn’t do it automatically.l