⚠️ NOTE IMPORTANTE : Vulnerabilité OpenSSH CVE-2024-6387

Saviez-vous qu'il existe une version Communicator Web ?

Connecteur SMS

Temps estimé :9 minutes

L’une des nouveautés majeures de la version 7.2 est l’introduction de l’API SMS Connector, qui est une interface flexible et standardisée utilisée pour envoyer et recevoir des messages SMS et MMS sur PBXware à l’aide de liaisons SMS personnalisées.

Cette fonctionnalité permet à nos clients de développer des applications middleware et de connecter le service SMS de PBXware aux fournisseurs SMS même s’ils ne sont actuellement pas pris en charge dans PBXware.

Avec une application middleware opérationnelle, la configuration ultérieure du PBXware est simple.

Pour créer une ligne réseau personnalisée, connectez-vous à votre interface graphique PBXware et accédez à :

  • Édition Multi-Tenant:

Master Tenant > SMS > Trunks et cliquez sur Ajouter Trunk SMS.

  • Édition CC/Business :

SMS > Trunks et cliquez sur Ajouter Trunk SMS

Entrez le nom de votre nouvelle ligne SMS (c’est-à-dire le fournisseur de SMS personnalisé)

Dans le champ Fournisseur , dans la liste déroulante, sélectionnez « Personnalisé » .

Le champ URL du Webhook doit être renseigné avec l’adresse à laquelle les messages SMS/MMS envoyés via gloCOM seront envoyés.

Avec un fournisseur personnalisé sélectionné, un nouveau champ, Auth Token, apparaîtra, vous permettant de saisir le jeton utilisé pour l’authentification avec l’application distante.

Le champ Description vous permet de fournir des informations pertinentes sur cette ligne réseau qui pourraient être utiles à vous ou à d’autres administrateurs PBXware.

Une fois que tous les champs sont correctement renseignés, cliquez sur Enregistrer pour conserver les modifications et créer votre nouvelle ligne réseau personnalisée.

En supposant que l’application middleware à laquelle vous vous connectez fonctionne comme prévu, à partir de ce moment, les lignes réseau SMS personnalisées seront utilisées comme n’importe quelle autre ligne réseau SMS spécifique au fournisseur disponible sur PBXware.

Voici les champs qui vous seront présentés après avoir sélectionné Personnalisé dans le champ Fournisseur :

  • Activer

Cliquez sur ce bouton bascule pour activer ou désactiver cette liaison SMS

  • Nom

Affiche le nom d’un Trunk

  • Fournisseur

Affiche le fournisseur sélectionné pour cette liaison. (c’est-à-dire personnalisé)

  • URL du webhook

L’adresse de l’application middleware utilisée pour l’interface avec le fournisseur de lignes réseau personnalisées à laquelle tous les messages SMS/MMS seront envoyés.

  • Jeton d’authentification

Un jeton utilisé pour l’authentification auprès de l’application middleware. Saisissez le jeton existant ou générez un nouveau jeton en appuyant sur l’icône à l’extrême droite du champ.

Fonctionnement

Envoi de messages

Le service SMS de PBXware enverra des messages SMS à l’URL du Webhook définie sous forme de requête POST.

				
					POST {webhook_url}
Content-Type: application/json
Authorization: Bearer {auth_token}
{
    "from": "string",           // Sender's phone number
    "to": "string",             // Recipient's phone number
    "text": "string",           // Message content
    "media_urls": ["string"]    // List of URLs for multimedia attachments (MMS)
}
				
			

La passerelle SMS en écoute sur le Webhook peut alors récupérer les informations du corps JSON et envoyer une requête à n’importe quel fournisseur SMS.

La passerelle SMS doit renvoyer une réponse sous forme d’objet JSON au format suivant :

				
					// case when sending the SMS was successful
{
    "status": "success",
    "message": ""
}
// case when sending the SMS was unsuccessful
{
    "status": "error",
    "message": "an error occured while sending the MMS"
    // an error message explaining why sending failed
}
				
			

Réception de messages

Le service SMS de PBXware reçoit des messages SMS sous forme de requête POST au format suivant :

				
					POST /smsservice/connector
Content-Type: application/json
Authorization: Bearer {auth_token}
{
    "from": "string",           // Sender's phone number
    "to": "string",             // Recipient's phone number
    "text": "string",           // Message content
    "media_urls": ["string"]    // List of URLs for multimedia attachments (MMS)
}

				
			

Statuts de réponse :

  • 200 OK : SMS reçu avec succès.
  • 401 Non autorisé : l’en-tête d’autorisation était manquant ou le jeton d’authentification n’est pas valide.
  • 500 : Erreur interne du serveur : plus d’informations sur l’erreur doivent être fournies dans la réponse.

Exemples

Réception de messages du service SMS de PBXware

				
					from flask import Flask, request, jsonify
app = Flask(__name__)
def send_message_to_provider(message_data):
    # The implementation of this function should be replaced with the actual
    # implementation of sending the message_data to another provider
    # For example, printing the received message data
    print("Message received:", message_data)
    return {"status": "success", "message": "Message sent successfully"}
@app.route('/messages', methods=['POST'])
def messages():
    try:
        # Ensure the request has a JSON content type
        if request.headers['Content-Type'] != 'application/json':
            return jsonify({"status": "error", "message": "Invalid content type"}), 400
        # Parse the JSON data from the request body
        message_data = request.get_json()
        # Call the function to send the message to the provider
        result = send_message_to_provider(message_data)
        return jsonify(result)
    except Exception as e:
        # Handle any exceptions that might occur during processing
        return jsonify({"status": "error", "message": str(e)}), 500
if __name__ == '__main__':
    # Run the server on localhost:5000
    app.run(debug=True)
				
			

Envoi de messages au service SMS de PBXware

				
					from flask import Flask, request, jsonify
import requests
app = Flask(__name__)
def parse_provider_request():
    try:
        # Ensure the request has a JSON content type
        if request.headers['Content-Type'] != 'application/json':
            raise ValueError("Invalid content type")
        # Parse the JSON data from the provider's request body
        provider_message_data = request.get_json()
        # Create a new JSON in the specified format
        formatted_message = {
            "from": provider_message_data.get("sender_number", ""),
            "to": provider_message_data.get("recipient_number", ""),
            "text": provider_message_data.get("message_content", ""),
            "media_urls": provider_message_data.get("media_urls", [])
        }
        return formatted_message
    except Exception as e:
        raise ValueError(f"Error parsing provider request: {str(e)}")
@app.route('/messages', methods=['POST'])
def messages():
    try:
        # Parse the provider's request using the function
        formatted_message = parse_provider_request()
        # Set up the headers for the outgoing request to my.pbxware.com/smsservice/connector
        headers = {
            'Authorization': 'Bearer YOUR_AUTH_TOKEN',  # Replace with your actual Auth Token
            'Content-Type': 'application/json'
        }
        # Send the message to the my.pbxware.com/smsservice/connector endpoint
        response = requests.post('https://my.pbxware.com/smsservice/connector', json=formatted_message, headers=headers)
        # Check if the request was successful (HTTP status code 2xx)
        if response.ok:
            return jsonify({"status": "success", "message": "Message sent successfully"})
        else:
            return jsonify({"status": "error", "message": f"Failed to send message. Error: {response.text}"}), response.status_code
    except ValueError as ve:
        # Handle parsing errors
        return jsonify({"status": "error", "message": str(ve)}), 400
    except Exception as e:
        # Handle any other exceptions that might occur during processing
        return jsonify({"status": "error", "message": str(e)}), 500
if __name__ == '__main__':
    # Run the server on localhost:5001
    app.run(debug=True, port=5001)
				
			

Passerelle entre deux services SMS PBXware

				
					# This Python script serves as an SMS proxy/gateway designed to facilitate communication
# between two PBXWare instances. The application acts as an intermediary for sending and
# receiving SMS messages, forwarding them from one PBXWare instance to another.
#
# Purpose:
# - Act as an SMS bridge between PBXWare instances, allowing seamless communication.
# - Handle incoming POST requests to the '/messages' endpoint, validating Bearer
#   Authorization with the provided token, printing the received JSON payload, and
#   forwarding the message to the specified PBXWare instance.
# - Return a JSON response with status and message fields based on the success or failure
#   of the forwarding operation, utilizing the response from the receiving PBXWare instance.
#
# Command-Line Arguments:
# --listen: Specifies the host and port for the HTTP server to listen on.
#           Example: --listen 127.0.0.1:5000
#
# --forward-to: Specifies the URL where incoming SMS messages will be forwarded.
#               Example: --forward-to https://my.pbxware.com/smsservice/connector
#
# --auth-token: Specifies the token for Bearer Authorization, ensuring secure communication.
#               Example: --auth-token my_secret_token
#
# Example Usage:
# python sms_proxy.py --listen 127.0.0.1:5000 --forward-to https://my.pbxware.com/smsservice/connector --auth-token my_secret_token
#
# Note: This script serves as an illustrative example and may need modification to suit
# specific requirements or environments.
import argparse
import json
from flask import Flask, request, abort, jsonify
import requests
app = Flask(__name__)
def parse_args():
    parser = argparse.ArgumentParser(description="HTTP Server with Forwarding")
    parser.add_argument("--listen", required=True, help="Host and port for HTTP server")
    parser.add_argument("--forward-to", required=True, help="URL where requests will be forwarded to")
    parser.add_argument("--auth-token", required=True, help="Token for Bearer Authorization")
    return parser.parse_args()
def validate_auth_token(request):
    auth_header = request.headers.get('Authorization')
    if not auth_header or auth_header != f'Bearer {args.auth_token}':
        abort(401, 'Unauthorized')
def forward_request(url, data, auth_token):
    headers = {'Content-Type': 'application/json', 'Authorization': f'Bearer {auth_token}'}
    response = requests.post(url, data=json.dumps(data), headers=headers)
    return response
@app.route('/messages', methods=['POST'])
def receive_message():
    try:
        validate_auth_token(request)
        data = request.json
        print("Received Message:")
        print(json.dumps(data, indent=2))
        forward_response = forward_request(args.forward_to, data, args.auth_token)
        if forward_response.status_code == 200:
            return jsonify({"status": "success", "message": ""}), 200
        else:
            return jsonify({"status": "error", "message": f"Forwarding failed with status code {forward_response.status_code}"}), 200
    except Exception as e:
        return jsonify({"status": "error", "message": str(e)}), 500
if __name__ == '__main__':
    args = parse_args()
    host, port = args.listen.split(':')
    app.run(host=host, port=int(port))
				
			
Partager

Connecteur SMS

Ou copiez le lien ci-dessous

CONTENU