Como enviar múltiplos SMS a partir de Scala

A maneira mais simples de enviar múltiplos SMS a partir de Scala é utilizar a API HTTP/Rest de SMS integrada do Ozeki SMS Gateway. Quando você utiliza esta API, você enviará mensagens SMS realizando uma requisição HTTP Post para o gateway de SMS. A requisição HTTP Post conterá uma mensagem formatada em JSON. O gateway de SMS enviará este SMS para o telefone do destinatário e retornará uma resposta HTTP 200 OK para a sua requisição.

O exemplo de código Scala para SMS abaixo demonstra como você pode enviar SMS utilizando a API HTTP Rest de SMS do Ozeki SMS Gateway usando a biblioteca Ozeki.Libs.Rest em Scala. Esta biblioteca é fornecida gratuitamente, e você pode utilizá-la e modificá-la em qualquer um dos seus projetos.

import Ozeki.Libs.Rest.{ Configuration, Message, MessageApi }


object main  {
  def main(args: Array[String]): Unit = {
    
    val configuration = Configuration(
      Username = "http_user",
      Password = "qwe123",
      ApiUrl = "http://127.0.0.1:9509/api"
    )

    val msg1 = Message(
      ToAddress = "+36201111111",
      Text = "Hello world 1"
    )

    val msg2 = Message(
      ToAddress = "+36202222222",
      Text = "Hello world 2"
    )

    val msg3 = Message(
      ToAddress = "+36203333333",
      Text = "Hello world 3"
    )

    val api = MessageApi(configuration)

    val result = api.Send(List[Message]( msg1, msg2, msg3 ))

    println(result)
  }
}
	

Como usar o exemplo de SMS em Scala:

Este exemplo de SMS em Scala pode ser utilizado em qualquer aplicação Scala. Para utilizá-lo, você deve baixar a biblioteca Ozeki.Libs.Rest. Após o download da biblioteca, você precisa adicionar uma referência a ela no seu código-fonte Scala. Isso permitirá que você utilize as classes fornecidas pela biblioteca Ozeki.Libs.Rest. Você pode usar a classe Message para criar o SMS. Você pode usar a classe MessageApi para enviar o SMS para o gateway de SMS. O gateway de SMS encaminhará sua mensagem para a rede móvel através de uma conexão wireless ou pela Internet.

O código-fonte explicado neste artigo pode ser baixado, utilizado e modificado gratuitamente.
Download: SendMultipleSms.scala.zip (90.6Kb)

No SendMultipleSms.scala.zip você encontrará o arquivo SendMultipleSms.scala, que contém o código de exemplo para mostrar como enviar um SMS. Este código de exemplo está listado abaixo.

Para enviar SMS a partir de Scala:

1. Instale um usuário de API HTTP
2. Ative "Log communication events" na aba Advanced
3. Configure o Visual Studio
4. Baixe e extraia o arquivo SendMultipleSms.scala.zip
5. Abra o projeto SendMultipleSms.scala com o IntelliJ IDE
6. Inicie o aplicativo Ozeki SMS Gateway
7. Execute o código Scala SendMultipleSms.scala no IntelliJ IDE
8. Verifique os logs para confirmar se o SMS foi enviado

Para poder enviar SMS a partir de Scala, primeiro você precisa instalar o Ozeki SMS Gateway. O gateway de SMS pode ser instalado no mesmo computador onde você desenvolve seu código Scala em qualquer editor de texto, como o Bloco de Notas do Windows. Após a instalação, o próximo passo é conectar o Ozeki SMS Gateway à rede móvel. Você pode enviar um SMS de teste a partir da interface gráfica do Ozeki para verificar se a sua conexão com a rede móvel está funcionando. O passo final para preparar o ambiente é criar um usuário de API HTTP para SMS. Crie um usuário com o nome "http_user" e senha "qwe123" para que o exemplo funcione sem modificações.

Após a configuração do ambiente, você pode executar o seu código Scala.

Para enviar SMS a partir de Scala, o seu código Scala terá que realizar uma requisição HTTP para o gateway de SMS. A URL da API é mostrada abaixo. Observe que o endereço IP (127.0.0.1) deve ser substituído pelo endereço IP do seu gateway de SMS. Se o Ozeki SMS Gateway estiver instalado no mesmo computador onde a aplicação Scala está sendo executada, pode ser 127.0.0.1. Se estiver instalado em um computador diferente, deve ser o endereço IP desse computador.

http://127.0.0.1:9509/api?action=rest
	

Para autenticar o cliente de SMS em Scala, você precisa enviar o nome de usuário e senha em uma string codificada em base64 para o servidor em uma requisição HTTP. O formato utilizado é: base64(nome de usuário+":"+senha). Em Scala, você pode usar o seguinte código para fazer esta codificação:

val usernamePassword = "%s:%s".format(Username, Password).getBytes()
val usernamePasswordEncoded = Base64.getEncoder.encodeToString(usernamePassword)
"Basic %s".format(usernamePasswordEncoded)
	

Por exemplo, se você codificar o nome de usuário 'http_user' e a senha 'qwe123', você obterá a seguinte string codificada em base64: aHR0cF91c2VyOnF3ZTEyMw==. Para enviar

Cabeçalho da requisição HTTP para enviar SMS a partir de Scala

Para enviar as mensagens SMS, você precisa incluir as seguintes linhas como cabeçalhos na requisição HTTP. Observe que incluímos um tipo de conteúdo e um cabeçalho de Autorização.

Content-Type: application/json
Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==
	

Para submeter o SMS, sua aplicação Scala enviará uma requisição HTTP semelhante à mostrada abaixo. Observe que esta requisição contém uma parte de cabeçalho HTTP e uma parte de corpo HTTP. O corpo HTTP é uma string de dados codificada em JSON. Ela contém os números dos destinatários e os textos das mensagens que enviamos.

POST /api?action=sendmsg HTTP/1.1
HTTP2-Settings: AAEAAEAAAAIAAAABAAMAAABkAAQBAAAAAAUAAEAA
Connection: Upgrade, HTTP2-Settings
Upgrade: h2c
Content-Length: 956
Content-Type: application/json
Accept: application/json
Authorization: Basic aHR0cF91c2VyOnF3ZTEyMw==
Host: 127.0.0.1:9509
User-Agent: Java-http-client/16.0.1

{
	"messages": [
		{
			"submit_report_requested":true,
			"view_report_requested":true,
			"valid_until":"2021-07-22T09:50:02",
			"time_to_send":"+1000000000-01-01T00:00:00",
			"message_id":"2052d6e3-111b-4d1b-8b63-548414c4cee8",
			"to_address":"+36201111111",
			"text":"Hello world 1",
			"create_date":"2021-07-15T09:50:02",
			"delivery_report_requested":true
		},
		{
			"submit_report_requested":true,
			"view_report_requested":true,
			"valid_until":"2021-07-22T09:50:02",
			"time_to_send":"+1000000000-01-01T00:00:00",
			"message_id":"3cb70960-3687-49e5-a602-9cbf7f9818cc",
			"to_address":"+36202222222",
			"text":"Hello world 2",
			"create_date":"2021-07-15T09:50:02",
			"delivery_report_requested":true
		},
		{
			"submit_report_requested":true,
			"view_report_requested":true,
			"valid_until":"2021-07-22T09:50:02",
			"time_to_send":"+1000000000-01-01T00:00:00",
			"message_id":"9b5c9ea6-f619-4ebb-93cc-2499ebcbc6a9",
			"to_address":"+36203333333",
			"text":"Hello world 3",
			"create_date":"2021-07-15T09:50:02",
			"delivery_report_requested":true
		}
	]
}
	

Assim que o gateway de SMS receber esta requisição, ele gerará uma resposta HTTP. A resposta HTTP conterá um código de status, para indicar se a requisição de envio de SMS foi bem-sucedida ou não. Ela também retornará uma estrutura codificada em JSON para fornecer detalhes úteis sobre o envio da mensagem.

HTTP/1.1 200 OK
User-Agent: OZEKI 10.3.123 (www.myozeki.com)
Content-Type: application/json; charset=utf8
Last-Modified: Thu, 15 Jul 2021 09:37:03 GMT
Server: 10/10.3.123
Transfer-Encoding: chunked

{
	"http_code": 200,
	"response_code": "SUCCESS",
	"response_msg": "Messages queued for delivery.",
	"data": {
	  "total_count": 3,
	  "success_count": 3,
	  "failed_count": 0,
	  "messages": [
	    {
	      "message_id": "2052d6e3-111b-4d1b-8b63-548414c4cee8",
	      "from_station": "%",
	      "to_address": "+36201111111",
	      "to_station": "%",
	      "text": "Hello world 1",
	      "create_date": "2021-07-15 09:50:02",
	      "valid_until": "2021-07-22 09:50:02",
	      "time_to_send": "2021-07-15 09:50:02",
	      "submit_report_requested": true,
	      "delivery_report_requested": true,
	      "view_report_requested": false,
	      "tags": [
	        {
	          "name": "Type",
	          "value": "SMS:TEXT"
	        }
	      ],
	      "status": "SUCCESS"
	    },
	    {
	      "message_id": "3cb70960-3687-49e5-a602-9cbf7f9818cc",
	      "from_station": "%",
	      "to_address": "+36202222222",
	      "to_station": "%",
	      "text": "Hello world 2",
	      "create_date": "2021-07-15 09:50:02",
	      "valid_until": "2021-07-22 09:50:02",
	      "time_to_send": "2021-07-15 09:50:02",
	      "submit_report_requested": true,
	      "delivery_report_requested": true,
	      "view_report_requested": false,
	      "tags": [
	        {
	          "name": "Type",
	          "value": "SMS:TEXT"
	        }
	      ],
	      "status": "SUCCESS"
	    },
	    {
	      "message_id": "9b5c9ea6-f619-4ebb-93cc-2499ebcbc6a9",
	      "from_station": "%",
	      "to_address": "+36203333333",
	      "to_station": "%",
	      "text": "Hello world 3",
	      "create_date": "2021-07-15 09:50:02",
	      "valid_until": "2021-07-22 09:50:02",
	      "time_to_send": "2021-07-15 09:50:02",
	      "submit_report_requested": true,
	      "delivery_report_requested": true,
	      "view_report_requested": false,
	      "tags": [
	        {
	          "name": "Type",
	          "value": "SMS:TEXT"
	        }
	      ],
	      "status": "SUCCESS"
	    }
	  ]
	}
}
	

Este vídeo mostra como baixar o arquivo SendMultipleSms.scala.zip desta página. Se você assistir ao vídeo, notará que o conteúdo do SendMultipleSms.scala.zip é colocado na área de trabalho do Windows. Você também verá que executamos o prompt de comando para enviar o SMS.

O código de exemplo abaixo faz parte do SendMultipleSms.scala.

Como verificar se o SMS foi aceito pelo usuário HTTP

Depois de enviar o SMS, é uma boa ideia verificar o seu gateway de SMS, para ver o que foi recebido. Você pode verificar o log abrindo os detalhes do usuário HTTP a partir do console de gerenciamento do Ozeki SMS Gateway. O vídeo a seguir mostra o que você deve procurar.

Este guia teve como objetivo mostrar as etapas do envio de múltiplos SMS em Scala com a ajuda do Ozeki SMS Gateway. Ao ler este guia, pode-se ver que esse processo é bastante simples com o código fornecido e o Ozeki SMS Gateway. Entrar em contato com vários clientes em um curto período de tempo é muito importante e, com esta solução, você ou sua empresa podem trabalhar com alto desempenho. O Ozeki SMS Gateway funciona em qualquer país e pode enviar e receber SMS através de várias conexões móveis, portanto, o intercâmbio internacional de mensagens não deve causar nenhum tipo de problema.

Certifique-se de que a leitura não termina aqui, visite a página de tutoriais da Ozeki, onde você pode encontrar mais sobre tópicos como recebimento em Scala.

A única coisa a fazer agora é baixar o Ozeki SMS Gateway e começar a trabalhar!