Get Started with Number Masking Using Ruby

Overview

Phone number masking hides the phone numbers of parties in a call from each other. Many businesses find it advantageous to anonymize communication between two parties — for example, between a customer and a delivery agent on a food delivery service platform or a driver and a rider using a ride-hailing application. Businesses can implement phone number masking by sending calls through an intermediate phone number that acts as a proxy between the two parties. A Plivo number can serve as the intermediate number to connect the two parties while keeping their contact information private.

Outline

• Customer calls agent
• Agent calls customer

Implementation

As an example, we’ll build a number-masking application for a food delivery service that lets the company connect customers with delivery agents and vice versa without revealing any actual phone numbers. To do this, you

1. Create a customer-to-agent phone number mapping in your application’s back end.
2. Create the number masking application using Plivo.
3. Assign the number masking application to a Plivo number.

In this section, we’ll walk through how to set up a Rails server in five minutes and start handling incoming calls.

First, install Rails with the command gem install rails. Then run the command rails new numbermasking to create a numbermasking directory with the necessary folders and files for development.

Install Plivo

Add the Plivo Ruby SDK by editing the Gemfile and adding the line:

gem 'plivo', '~> 4.16.0'

You can use this command to install the Plivo-Ruby gem into the bundle:

$ bundle install

Create a 1:1 map with actual numbers

Now create customer-to-agent phone number mapping for the application. Whenever a customer places an order, their phone number should be stored in a database for your application to access. A delivery agent will be assigned for the order, and the agent’s number will also be stored in your database, and will be mapped to the customer’s number:

Customer’s Number		<->		Agent’s Number
  1-415-666-7777					1-415-666-7778

We created sample mapping data in a config/application.rb file:

# customer <> agent map
config.base_map = {"14156667777" => "14156667778", "14156667779" => "14156667780", "14156667781" => "14156667782"}

Create a Rails controller for number masking

Change the newly created numbermasking directory and run the command rails generate controller Numbermasking to create a Rails controller named numbermasking_controller in the app/controllers/ directory. Edit the app/controllers/numbermasking_controller.rb file and paste in this code:

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
include Plivo

include Plivo::XML
include Plivo::Exceptions

\# Handle incoming calls to a Plivo number, connect agent with customer and vice versa without revealing their actual phone numbers. 
class NumbermaskingController < ApplicationController
    def handle_incoming
        customer_agent_map = Rails.application.config.base_map
        agent_customer_map = customer_agent_map.invert
        from_number = params[:From]
        to_number = params[:To]
        response = Response.new()
        customer_to_agent = customer_agent_map.include?(from_number) # To check if the Customer's number is existing in the Customer-Agent mapping
        agent_to_customer = agent_customer_map.include?(from_number) # To check if the Agent's number is existing in the Customer-Agent mapping
        if(customer_to_agent == true)
            dest_number = customer_agent_map[from_number] # This will assign the Value from the customer-agent array to dest_number variable
            params = {
            'callerId' => to_number # Plivo number will be used as the caller ID for the call towards Agent
            }
            dial = response.addDial(params)
            dial.addNumber(dest_number)
        elsif(agent_to_customer == true)
            dest_number = agent_customer_map[from_number] # This will assign the Key from the customer-agent array to dest_number variable
            params = {
            'callerId' => to_number # Plivo number will be used as the caller ID for the call towards Customer
            }
            dial = response.addDial(params)
            dial.addNumber(dest_number)
        end
        xml = PlivoXML.new(response)
        puts xml.to_xml()
        render xml: xml.to_xml
    end
end

Add a route

Add a route for the handle_incoming function in NumbermaskingController class. Open the config/routes.rb file and add this line after the outbound route:

get 'numbermasking/handle_incoming'

To start the Rails server to forward incoming calls, run

$ rails server

You should see your basic server app in action on http://localhost:3000/numbermasking/handle_incoming/

Expose your local server to the internet

To receive incoming calls, your local server should be able to connect with Plivo API services. For that, we recommend using ngrok, which exposes local servers behind NATs and firewalls to the public internet over secure tunnels.

Install ngrok and run it on the command line, specifying the port that hosts the application on which you want to receive messages (3000 in this case):

./ngrok http 3000

Ngrok will display a forwarding link that you can use as a webhook to access your local server over the public network.

# Whitelist ngrok domain
config.hosts << /[a-z0-9]+\.ngrok\.io/

Now people can call your Plivo number. If an incoming call to your Plivo number is from one of the customer phone numbers in the Customer <-> Agent Map — for example, if the caller number is 14156667777 — then Plivo will send the XML response to process the incoming call as below, and you can check the XML document in your browser.

If the incoming call to your Plivo number is from one of the agent phone numbers in the Customer <-> Agent Map — for example, if the caller number is 14156667778 — then Plivo will send the XML response to process the incoming call as below, and you can check the XML document in your browser.

Create a Plivo application

1. Create a Plivo application by visiting the Voice > Applications > XML page of the console and clicking on Add New Application, or by using Plivo’s Application API.

2. Give your application a name — we used Number Masking. Enter your server URL (for example, https://61d8fb8f250c.ngrok.io/handleincoming/) in the Primary Answer URL field and set the method as GET. See our Application API docs to learn how to modify your application through our APIs.

3. Click on Create Application to save your application.

Assign a Plivo number to your application

1. Navigate to the Numbers page and select the phone number you want to use for the application.
2. Select XML Application from the Application Type drop-down list, and Number Masking (the name of the application) from the Plivo Application drop-down list.

3. Click on Update Number to save the number assignment.

   

Test and validate

To test the application, you need two Plivo mobile numbers. Set up one of your mobile numbers as a customer and another as an agent in the customer-to-agent mapping data in the config file. Make a call from each of your mobile numbers to the Plivo number you mapped to the application. You should see that the call is forwarded to the other number, and the incoming call has the Plivo number as the caller ID.