Sequential Dialing

    The following examples calls out to a list of phone numbers sequentially. The first call is made to the number in order, with a timeout value to 20s. If the call is not answered within 20s, Plivo will then dial out to the second number.

    Response

    <Response>
        <Dial timeout="20" action="http://foo.com/dial_action/">
            <Number>18217654321</Number>
        </Dial>
        <Dial>
            <Number>15671234567</Number>
        </Dial>
    </Response>
    

    Example Request

    1
    2
    3
    4
    5
    6
    7
    8
    
    from plivo import plivoxml
    
    response = plivoxml.ResponseElement()
    response.add(
        plivoxml.DialElement(action='http://foo.com/dial_action/', time_limit=20)
        .add(plivoxml.NumberElement('18217654321')))
    response.add(plivoxml.DialElement().add(plivoxml.NumberElement('15671234567')))
    print(response.to_string())
    
    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
    
    require 'rubygems'
    require 'plivo'
    
    include Plivo::XML
    include Plivo::Exceptions
    
    begin
      response = Response.new
    
      params = {
          'timeout' => "20",
          'action' => "https://www.foo.com/dial_status/"
      }
    
      first_dial = response.addDial(params)
      first_number = "1111111111"
      first_dial.addNumber(first_number)
    
      second_dial = response.addDial()
      second_number = "2222222222"
      second_dial.addNumber(second_number)
    
      xml = PlivoXML.new(response)
      puts xml.to_xml
    rescue PlivoXMLError => e
      puts 'Exception: ' + e.message
    end
    
    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
    
    var plivo = require('plivo');
    
    var response = plivo.Response();
    
    var params = {
        'timeout': "20",
        'action': "http://www.foo.com/dial_action"
    };
    var first_dial = response.addDial(params);
    var first_number = "1111111111";
    first_dial.addNumber(first_number);
    
    var second_dial = response.addDial();
    var second_number = "2222222222";
    second_dial.addNumber(second_number);
    
    console.log(response.toXML());
    
    /*
    Sample Output
    <Response>
        <Dial timeout="20" action="http://www.foo.com/dial_action">
            <Number>1111111111</Number>
        </Dial>
        <Dial>
            <Number>2222222222</Number>
        </Dial>
    </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
    29
    30
    31
    32
    33
    34
    35
    
    <?php
        require '../vendor/autoload.php';
        use Plivo\XML\Response;
    
        $response = new Response();
    
        $first_params = array(
            'timeout' => "20",
            'action' => "https://www.foo.com/dial_action/"
        );
    
        $first_dial = $response->addDial($first_params);
        $first_number = "1111111111";
        $first_dial->addNumber($first_number);
    
        $second_dial = $response->addDial();
        $second_number = "2222222222";
        $second_dial->addNumber($second_number);
    
        Header('Content-type: text/xml');
        echo($response->toXML());
    
        /*
        Sample Output
    
        <Response>
            <Dial timeout="20" action="https://www.foo.com/dial_action/">
                <Number>1111111111</Number>
            </Dial>
            <Dial>
                <Number>2222222222</Number>
            </Dial>
        </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
    29
    30
    31
    32
    
    // Example for dial - sequential dialing
    package com.plivo.api.xml.samples.dial;
    
    import com.plivo.api.exceptions.PlivoXmlException;
    import com.plivo.api.xml.Dial;
    import com.plivo.api.xml.Number;
    import com.plivo.api.xml.Response;
    
    
    class SequentialDialing {
        public static void main(String[] args) throws PlivoXmlException {
            Response response = new Response()
                    .children(
    
    
                            new Dial()
                                    .action("http://foo.com/dial action/")
                                    .timeout(20)
                                    .children(
                                            new Number("18217654321")
    
                                    ),
    
    
                            new Dial()
                                    .children(
                                            new Number("15671234567")
                                    )
                    );
            System.out.println(response.toXmlString());
        }
    }
    
    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
    42
    43
    44
    45
    46
    
    using System;
    using System.Collections.Generic;
    using Plivo.XML;
    
    namespace Plivo
    {
    	class MainClass
    	{
    		public static void Main(string[] args)
    		{
    			Plivo.XML.Response resp = new Plivo.XML.Response();
    			Plivo.XML.Dial dial1 = new Plivo.XML.Dial(new
    				Dictionary<string, string>() {
    				{"timeout", "20"},
    				{"action", "http://foo.com/dial_action/"}
    			});
    
    			dial1.AddNumber("18217654321",
    				new Dictionary<string, string>() { });
    
    			Plivo.XML.Dial dial2 = new Plivo.XML.Dial(new
    				Dictionary<string, string>()
    			{ });
    			dial2.AddNumber("15671234567",
    				new Dictionary<string, string>() { });
    			resp.Add(dial1);
    			resp.Add(dial2);
    
    			var output = resp.ToString();
    			Console.WriteLine(output);
    
    		}
    	}
    }
    
    
    
    //<Response>
    //  <Dial timeout = "20" 
    //    action="http://foo.com/dial_action/">
    //    <Number>18217654321</Number>
    //  </Dial>
    //  <Dial>
    //    <Number>15671234567</Number>
    //  </Dial>
    //</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
    
    // Example for dial - sequential dialing
    package main
    
    import "github.com/plivo/plivo-go/xml"
    
    func main() {
    	response := xml.ResponseElement{
    		Contents: []interface{}{
    
    			new(xml.DialElement).
    				SetAction("http://foo.com/dial action/").
    				SetTimeout(20).
    				SetContents([]interface{}{
    					new(xml.NumberElement).
    						SetContents("18217654321"),
    				}),
    
    			new(xml.DialElement).
    				SetContents([]interface{}{
    					new(xml.NumberElement).
    						SetContents("15671234567"),
    				}),
    		},
    	}
    	print(response.String())
    }