Hold a member

    Places a member in the Multi-Party Call on hold. When a member places the call on hold, the member will be muted and the other members will hear the hold music. Agent Hold music and Customer hold music can be configured in the component.

    API Endpoint

    POST https://phlorunner.plivo.com/v1/phlo/{phlo_id}/multi_party_call/{node_id}/members/{member_address}

    Arguments

    URL Params

    ParamDescription/Allowed Values
    phlo_idRequiredstring

    Unique identifier of the PHLO. PHLO ID is available here.

    node_idRequiredstring

    Unique identifier of the node. The ID is available in the configuration section of the corresponding Multi-Party Call node in the PHLO.

    member_address
    Required

    Phone number or SIP endpoint address of the member to put on hold.

    Payload

    ParamDescription/Allowed Values
    action
    Requiredstring

    hold

    Returns

    Returns a Member object.

    Response

    HTTP Status Code: 201

    {
        "api_id": "11d8c251-d7bf-4aba-9763-985f21bcb455",
        "error": ""
    }
    

    Example Request

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    
    import plivo
    
    auth_id = 'Your AUTH ID'
    auth_token = 'Your AUTH Token'
    phlo_id = 'Your PHLO ID' # https://console.plivo.com/phlo/list/
    node_id = 'Your Node ID'
    phlo_client = plivo.phlo.RestClient(auth_id=auth_id, auth_token=auth_token)
    phlo = phlo_client.phlo.get(phlo_id)
    
    member_address = '1111111111'
    
    #Hold:
    response = phlo.multi_party_call(node_id).member(member_address).hold()
    
    print str(response)
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    
    require 'rubygems'
    require 'plivo'
    
    include Plivo
    
    AUTH_ID = 'AUTH_ID'
    AUTH_TOKEN = 'AUTH_TOKEN'
    
    client = Phlo.new(AUTH_ID, AUTH_TOKEN)
    
    # if credentials are stored in the PLIVO_AUTH_ID and the PLIVO_AUTH_TOKEN environment variables
    # then initialize client as:
    # client = Phlo.new
    
    # provide the phlo_id in params
    phlo = client.phlo.get('phlo_id')
    multi_party_call = phlo.multi_party_call('node_id')
    
    # member_address => phone number of the member who is being put on hold
    #
    # multi_party_call.member(<member_address>).hold
    
    begin
        response = multi_party_call.member('9999999999').hold
        puts response
      rescue PlivoRESTError => e
        puts 'Exception: ' + e.message
      end
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    
    var plivo = require('plivo');
    var PhloClient = plivo.PhloClient;
    
    var authId = 'auth-id';
    var authToken = 'auth-token';
    var phloId = 'PHLO_ID';
    var mpcId = 'Multiparty_call_NodeID';
    var phloClient = phlo = null;
    var mpcSourceNo = 'member_id'; //Trigger source address
    
    // Hold - Phlo Member
    phloClient = new PhloClient(authId, authToken);
    phloClient.phlo(phloId).multiPartyCall(mpcId).member(mpcSourceNo).hold().then(function (result) {
        console.log('hold result -', result);
    }).catch(function (err) {
        console.log('hold failed', err);
    });
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    
    <?php
    /**
     * Example for MultiParty Hold
     */
    require 'vendor/autoload.php';
    use Plivo\Resources\PHLO\PhloRestClient;
    use Plivo\Exceptions\PlivoRestException;
    
    $memberAddress = "Member_ID";
    
    $client = new PhloRestClient("YOUR_AUTH_ID", "YOUR_AUTH_TOKEN");
    $phlo = $client->phlo->get("YOUR_PHLO_ID");
    $multiPartyCall = $phlo->multiPartyCall()->get("YOUR_NODE_ID");
    $multiPartyCallMember = $multiPartyCall->member($memberAddress);
    try {
        $response = $multiPartyCallMember->hold();
        print_r($response);
    } catch (PlivoRestException $ex) {
        print_r($ex);
    }
    ?>
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    
    import com.plivo.api.Plivo;
    import com.plivo.api.PlivoClient;
    import com.plivo.api.exceptions.PlivoRestException;
    import com.plivo.api.models.node.MultiPartyCall;
    import com.plivo.api.models.node.MultiPartyCallActionType;
    import com.plivo.api.models.node.MultiPartyCallUpdateResponse;
    import com.plivo.api.models.phlo.Phlo;
    import java.io.IOException;
    
    public class Example
    {
        privatestatic final  String authId = "Your AUTH_ID";
        private static final String authToken = "Your AUTH_TOKEN";
        private static PlivoClient client = new PlivoClient(authId, authToken);
        public static void main(String[] args) throws IOException, PlivoRestException
        {
            String phloId = "Your PHLO_ID";
            String nodeId = "Your NODE_ID";
            String to = "11111111112";
            String memberId = to;
            Plivo.init(authId, authToken);
            Phlo phlo = Phlo.getter(phloId).client(client).get();
    
            MultiPartyCall mpc = MultiPartyCall.getter(phloId, nodeId).get();
    
            //Hold:
            MultiPartyCallUpdateResponse response = MultiPartyCall.updater(phloId, nodeId).member(memberId).hold().update();
        }
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    
    using System;
    using Plivo;
    
    namespace test_PHLO_dotnet
    {
        class Program
        {
            public static void Main(string[] args)
            {
                var phloClient = new PhloApi("auth_id", "auth_token");
                var phloID = "phlo_id";
                var nodeID = "node_id";
                var phlo = phloClient.Phlo.Get(phloID);
                var multiPartyCallObj = phlo.MultiPartyCall("nodeID");
    
                var MemberId = "19620074923";
    
                Console.WriteLine(multiPartyCallObj.Member(MemberId).Hold());
            }
        }
    }
    
    1
    2
    3
    4
    5
    
    curl --request POST \
      --user AUTH_ID:AUTH_TOKEN \
      --url 'https://phlorunner.plivo.com/v1/phlo/{phlo_id}/multi_party_call/{node_id}/members/{MemberAddress}' \
      --header 'Content-Type: application/json' \
      --data '{"action":"hold"}'
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    
    package main
    
    import (
    	"fmt"
    	"plivo-go"
    )
    
    // Initialize the following params with corresponding values to trigger resources
    
    const authId  = "auth_id"
    const authToken = "auth_token"
    const phloId = "phlo_id"
    const nodeId = "node_id"
    const memberId  = "member_id"
    
    //HOLD
    
    func main() {
    	testMultiPartyCallMemberHold()
    }
    
    func testMultiPartyCallMemberHold() {
    	phloClient,err := plivo.NewPhloClient(authId, authToken, &plivo.ClientOptions{})
    	if err != nil {
    		panic(err)
    	}
    	phloGet, err := phloClient.Phlos.Get(phloId)
    	if err != nil {
    		panic(err)
    	}
    	MPCGet, err := phloGet.MultiPartyCall(nodeId)
    	if err != nil {
    		panic(err)
    	}
    	response, err := MPCGet.Member(memberId).Hold()
    	if (err != nil) {
    		fmt.Println(err)
    	}
    	fmt.Printf("Response: %#v\n", response)
    
    }