Receiving SMS and MMS messages

$ npm install @ringcentral/sdk @ringcentral/subscriptions --save

const RC = require('@ringcentral/sdk').SDK
const Subscriptions = require('@ringcentral/subscriptions').Subscriptions;

// Instantiate the SDK and get the platform and the subscription instances
const rcsdk = new RC({
    server: "https://platform.ringcentral.com",
    clientId: "RC_APP_CLIENT_ID",
    clientSecret: "RC_APP_CLIENT_SECRET"
});
const subscriptions = new Subscriptions({
   sdk: rcsdk
});

var platform = rcsdk.platform();
var subscription = subscriptions.createSubscription();

/* Authenticate a user using a personal JWT token */
platform.login({ jwt: "RC_USER_JWT" })

platform.on(platform.events.loginSuccess, function(e){
    subscribe_for_instant_messages_notification()
});

platform.on(platform.events.loginError, function(e){
    console.log("Unable to authenticate to platform. Check credentials.", e.message)
    process.exit(1)
});

/*
  Subscribe for the user instant message event notification
*/
async function subscribe_for_instant_messages_notification(){
  var eventFilters = [ '/restapi/v1.0/account/~/extension/~/message-store/instant?type=SMS' ]
  subscription.setEventFilters(eventFilters)
  .register()
  .then(function(subscriptionResponse) {
      console.log("Ready to receive SMS message via WebSocket.")
  })
  .catch(function(e) {
    console.error(e.message);
  })
}

/*
*  Receive inbound messages from WebSocket subscription event notification
*/
subscription.on(subscription.events.notification, function(msg) {
    send_reply(msg.body)
});

/*
 Send a reply message to a client number
*/
async function send_reply(body){
  var text = 'Hi'
  if (body.from.name)
    text += ` ${body.from.name}.`

  text += "\nThank you for your message. I’m currently on vacation and will be available after August 15th."
  let bodyParams = {
           from: {phoneNumber: body.to[0].phoneNumber},
           to: [ {phoneNumber: body.from.phoneNumber}],
           text: text
         }

  try{
    let endpoint = "/restapi/v1.0/account/~/extension/~/sms"
    await refresh_token()
    var resp = await platform.post(endpoint, bodyParams)
  }catch(e){
    console.log(`Unable to send a reply message to ${bodyParams.to[0].phoneNumber}. Error message:`, e.message)
  }
}

async function refresh_token(){
  if (await platform.loggedIn() == false){
    console.log("Both tokens expired => Relogin using the user JWT.")
    await platform.login( { jwt: "RC_USER_JWT" })
  }else{
    console.log("Token valid")
  }
}

$ curl -sS https://getcomposer.org/installer | php
$ php composer.phar require ringcentral/ringcentral-php

<?php
require('vendor/autoload.php');

use RingCentral\SDK\WebSocket\WebSocket;
use RingCentral\SDK\WebSocket\Subscription;
use RingCentral\SDK\WebSocket\Events\NotificationEvent;

// Instantiate the SDK and get the platform instance
$rcsdk = new RingCentral\SDK\SDK( "RC_APP_CLIENT_ID", "RC_APP_CLIENT_SECRET", "https://platform.ringcentral.com" );
$platform = $rcsdk->platform();

/* Authenticate a user using a personal JWT token */
try {
  $platform->login(["jwt" => "RC_USER_JWT"]);
}catch (\RingCentral\SDK\Http\ApiException $e) {
  exit("Unable to authenticate to platform. Check credentials. " . $e->message . PHP_EOL);
}
subscribe_for_instant_messages_notification();

/*
  Subscribe for the user instant message event notification
*/
function subscribe_for_instant_messages_notification(){
  global $rcsdk;
  $websocket = $rcsdk->initWebSocket();
  $websocket->connect();
  $subscription = $rcsdk->createSubscription();
  $subscription->addEvents(array('/restapi/v1.0/account/~/extension/~/message-store/instant?type=SMS'));

  /*
    Receive inbound messages from WebSocket subscription event notification
  */
  $subscription->addListener(Subscription::EVENT_NOTIFICATION, function (NotificationEvent $event) {
      send_reply($event->payload()['body']);
  });

  $subscription->register();
}

/*
*  Send a reply message to a client number
*/
function send_reply($body){
  global $platform;
  try {
    $textMessage = "Hi";
    if (isset($body['from']['name']))
        $textMessage .= " " . $body['from']['name'];
    $textMessage .= "\nThank you for your message. I’m currently on vacation and will be available after August 15th.";
    $bodyParams = array(
      'from' => array( 'phoneNumber' => $body['to'][0]['phoneNumber'] ),
      'to'   => array( array('phoneNumber' => $body['from']['phoneNumber'])),
      'text' => $textMessage
    );

    $endpoint = "/restapi/v1.0/account/~/extension/~/mms";
    refresh_token();
    $resp = $platform->post($endpoint, $bodyParams);
  }catch (\RingCentral\SDK\Http\ApiException $e) {
    // Getting error messages using PHP native interface
    print 'Expected HTTP Error: ' . $e->message . PHP_EOL;
  }
}

function refresh_token(){
  global $platform;
  if (!$platform->loggedIn()){
    print "Both tokens expired => Relogin using the user JWT" . PHP_EOL;
    $platform->login( [ "jwt" => "RC_USER_JWT" ] );
  }else{
    print "Token valid" . PHP_EOL;
  }
}
?>

$ pip install ringcentral

from ringcentral import SDK
import asyncio
import os
from ringcentral.websocket.events import WebSocketEvents

# Send a reply message to a client number
def send_reply(body):
    try:
        textMessage = "Hi"
        if 'name' in body['from']:
            textMessage += " " + body['from']['name']
        textMessage += "\nThank you for your message. I’m currently on vacation and will be available after August 15th."
        bodyParams = {
             'from' : { 'phoneNumber': body['to'][0]['phoneNumber'] },
             'to'   : [ {'phoneNumber': body['from']['phoneNumber']} ],
             'text' : textMessage
        }
        endpoint = "/restapi/v1.0/account/~/extension/~/sms"
        refresh_token()
        resp = platform.post(endpoint, bodyParams)
        print("Replied.")
    except Exception as e:
        print (e)

def refresh_token():
    if platform.logged_in() == False:
        print("Both tokens expired => Relogin.")
        platform.login(jwt= "RC_USER_JWT")
    else:
        print("Token valid.")

#
# Receive inbound messages from WebSocket subscription event notification
#
def on_notification(message):
    send_reply(message[1]['body'])

def on_sub_created(sub):
    print("\n Subscription created:\n")
    print(sub.get_subscription_info())
    print("\n Please go and change your user status \n")

def on_ws_created(web_socket_client):
    print("\nNew WebSocket connection created:")

# Subscribe for the user instant message event notification
async def subscribe_for_instant_messages_notification():
    try:
        web_socket_client = rcsdk.create_web_socket_client()
        web_socket_client.on(WebSocketEvents.connectionCreated, on_ws_created)
        web_socket_client.on(WebSocketEvents.subscriptionCreated, on_sub_created)
        web_socket_client.on(WebSocketEvents.receiveSubscriptionNotification, on_notification)
        await asyncio.gather(
            web_socket_client.create_new_connection(),
            web_socket_client.create_subscription(["/restapi/v1.0/account/~/extension/~/message-store/instant?type=SMS"])
        )
    except KeyboardInterrupt:
        print("Stopped by User")

# Authenticate a user using a personal JWT token
def login():
    print ("running in a loop")
    platform.login(jwt= "RC_USER_JWT")
    asyncio.run(subscribe_for_instant_messages_notification())

# Instantiate the SDK and get the platform instance
rcsdk = SDK("RC_APP_CLIENT_ID", "RC_APP_CLIENT_SECRET", "https://platform.ringcentral.com")
platform = rcsdk.platform()

login()

$ gem install ringcentral-sdk dotenv

require 'ringcentral'
require 'subscription'

#
#  Subscribe for the user instant message event notification
#
def subscribe_for_instant_messages_notification()
  events = [
    '/restapi/v1.0/account/~/extension/~/message-store/instant?type=SMS'
  ]
  subscription = WS.new($platform, events, lambda { |message|
    send_reply(message['body'])
  })
  subscription.subscribe()
  puts "Waiting for incoming SMS message ..."
  while 1
      sleep(5)
  end
end

#
# Send a reply message to a client number
#
def send_reply(body)
  begin
    textMessage = "Hi"
    if body['from'].key?('name')
      text_message += " " + body['from']['name']
    end
    textMessage += "\nThank you for your message. I’m currently on vacation and will be available after August 15th."
    bodyParams = {
            from: {phoneNumber: body['to'][0]['phoneNumber'] },
            to: [ {phoneNumber: body['from']['phoneNumber']} ],
            text: textMessage
    }

    endpoint =  "/restapi/v1.0/account/~/extension/~/sms"
    refresh_token()
    resp = $platform.post(endpoint, payload: bodyParams)
  rescue StandardError => e
    puts (e)
  end
end

def refresh_token()
    if $platform.refresh() == nil
        puts "Both tokens expired => Relogin."
        $platform.authorize(jwt: "RC_USER_JWT")
    else
        puts "Token valid."
    end
end

# Authenticate a user using a personal JWT token
def login()
  begin
    $platform.authorize(jwt: "RC_USER_JWT")
    subscribe_for_instant_messages_notification()
  rescue StandardError => e
    puts ("Unable to authenticate to platform. Check credentials." + e.to_s)
  end
end

# Instantiate the SDK and get the platform instance
$platform = RingCentral.new( "RC_APP_CLIENT_ID", "RC_APP_CLIENT_SECRET", "https://platform.ringcentral.com" )

login()

/*
*  Receive inbound messages from WebSocket subscription event notification
*/
subscription.on(subscription.events.notification, async function(msg) {
  // send_reply(msg.body)
  download_mms_attachments(msg.body.attachments)
});

/*
  Download an MMS message attachments
*/
const fs = require('fs')
async function download_mms_attachments(attachments){
  await refresh_token()
  for (var attachment of attachments){
    if (attachment.type == "MmsAttachment"){
      let contentType = attachment.contentType.split("/")
      let fileName = `${attachment.id}.${contentType[1]}`
      let res = await platform.get(attachment.uri)
      await res.body.pipe(fs.createWriteStream(fileName))
    }
  }
}

<?php
/*
  Subscribe for the user instant message event notification
*/
function subscribe_for_instant_messages_notification(){
  global $rcsdk;
  $websocket = $rcsdk->initWebSocket();
  $websocket->connect();
  $subscription = $rcsdk->createSubscription();
  $subscription->addEvents(array('/restapi/v1.0/account/~/extension/~/message-store/instant?type=SMS'));

  /*
    Receive inbound messages from WebSocket subscription event notification
  */
  $subscription->addListener(Subscription::EVENT_NOTIFICATION, function (NotificationEvent $event) {
      // send_reply($event->payload()['body']);
      $attachments = $event->payload()['body']['attachments'];
      download_mms_attachments($attachments);

  });
  $subscription->register();
}

/*
  Download an MMS message attachments
*/
function download_mms_attachments($attachments){
  global $platform;
  refresh_token();
  foreach($attachments as $attachment){
    $fileName = $attachment['id'];
    if ($attachment['type'] == "MmsAttachment"){
      $fileNameExt = preg_split("/[\/]/", $attachment['contentType'], -1);
      $fileName .= "." . $fileNameExt[1];
      try {
        $res = $platform->get($attachment['uri']);
        file_put_contents($fileName, $res->raw());
      }catch (ApiException $e) {
        $message = $e->getMessage();
        print 'Expected HTTP Error: ' . $message . PHP_EOL;
      }
    }
  }
}
?>

#
# Receive inbound messages from WebSocket subscription event notification
#
def on_notification(message):
    # send_reply(message[1]['body'])
    download_mms_attachments(message[1]['body']['attachments'])

#
# Download an MMS message attachments
#
def download_mms_attachments(attachments):
    refresh_token()
    for attachment in attachments:
        fileName = str(attachment['id'])
        if attachment['type'] == "MmsAttachment":
            fileNameExt = attachment['contentType'].split("/")
            fileName = ("%s.%s" % (fileName, fileNameExt[1]))
            try:
                res = platform.get(attachment['uri'])
                with open(fileName, 'wb') as file:
                    file.write(res.body())
                    file.close()
            except ApiException as e:
                print (e.getMessage())

#
#  Subscribe for the user instant message event notification
#
def subscribe_for_instant_messages_notification()
  events = [
    '/restapi/v1.0/account/~/extension/~/message-store/instant?type=SMS'
  ]
  #
  # Receive inbound messages from WebSocket subscription event notification
  #
  subscription = WS.new($platform, events, lambda { |message|
    # send_reply(message['body'])
    download_mms_attachments(message['body']['attachments'])
  })
  subscription.subscribe()
  puts "Waiting for incoming SMS/MMS messages ..."
  while 1
      sleep(5)
  end
end

#
# Download an MMS message attachments
#
def download_mms_attachments(attachments)
  refresh_token()
  for attachment in attachments
    if attachment["type"] == "MmsAttachment"
      file_name_ext = attachment["contentType"].split("/")
      file_name = "%s.%s" % [attachment["id"], file_name_ext[1]]
      begin
        res = $platform.get(attachment["uri"])
        File.open(file_name, "wb") { |file| file.write(res.body) }
      rescue IOError => e
        puts e.message
      end
    end
  end
end