Como agendar um SMS em Scala

A maneira mais simples de enviar um SMS agendado a partir de Scala é usar a API HTTP/Rest de SMS integrada do Ozeki SMS Gateway. Quando você usa essa API, 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á esse SMS para o telefone do destinatário e retornará uma resposta HTTP 200 OK para sua requisição.

como agendar um sms em scala
Figura 1 - Como agendar um SMS em Scala

Código Scala para enviar um SMS agendado para um celular

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

SendScheduledSms.scala 
import Ozeki.Libs.Rest.{Configuration, Message, MessageApi}
import java.time.LocalDateTime
import java.time.format.DateTimeFormatter


object main  {
  def main(args: Array[String]): Unit = {

    val DateFormat = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")

    val configuration = Configuration(
      Username = "http_user",
      Password = "qwe123",
      ApiUrl = "http://127.0.0.1:9509/api"
    )

    val msg = Message(
      ToAddress = "+36201111111",
      Text = "Olá mundo!",
      TimeToSend = LocalDateTime.parse("2021-07-14 16:30:00", DateFormat)

    )

    val api = MessageApi(configuration)

    val result = api.Send(msg)

    println(result)
  }
}

Código 1 - SendScheduledSms.scala

Como usar o exemplo de SMS em Scala:

Este exemplo de SMS em Scala pode ser usado em qualquer aplicação Scala. Para usá-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ê use 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 sem fio ou pela Internet.

Baixar SendScheduledSms.scala

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

O que há no arquivo SendScheduledSms.scala.zip?

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

Figura 2 - O que há dentro de SendScheduledSms.scala.zip

Como enviar SMS a partir de Scala (Passos simples)

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 SendScheduledSms.scala.zip
  5. Abra o projeto SendScheduledSms.scala com o IntelliJ IDE
  6. Inicie o aplicativo Ozeki SMS Gateway
  7. Execute o código Scala SendScheduledSms.scala no IntelliJ IDE
  8. Verifique os logs para ver se o SMS foi enviado
Instale o Ozeki SMS Gateway e crie um usuário de API HTTP

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 sua conexão com a rede móvel está funcionando. O passo final para preparar seu ambiente é criar um usuário de API HTTP de 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 seu código Scala.

URL da API HTTP para enviar SMS a partir de Scala

Para enviar SMS a partir de Scala, seu código Scala terá que fazer 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 de SMS em 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
Autenticação HTTP para enviar SMS a partir de Scala

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 usado é: base64(nome de usuário+":"+senha). Em Scala, você pode usar o seguinte código para fazer essa 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==

Requisição HTTP para enviar um SMS agendado a partir de Scala

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 o número do destinatário, a mensagem de texto e também o horário em que queremos enviar o SMS. 

POST /api?action=sendmsg HTTP/1.1
HTTP2-Settings: AAEAAEAAAAIAAAABAAMAAABkAAQBAAAAAAUAAEAA
Connection: Upgrade, HTTP2-Settings
Upgrade: h2c
Content-Length: 320
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": [
		{
			"message_id":"e2f650ee-90cc-43c5-885b-5ea4a0458381",
			"to_address":"+36201111111",
			"text":"Hello world!",
			"create_date":"2021-07-15T10:32:42",
			"valid_until":"2021-07-22T10:32:42",
			"time_to_send":"2021-07-15T11:00:00",
			"submit_report_requested": true,
			"view_report_requested": true,
			"delivery_report_requested": true
		}
	]
}

Resposta HTTP recebida pelo exemplo de SMS em Scala

Assim que o gateway SMS receber esta requisição, ele gerará uma resposta HTTP. A resposta HTTP conterá um código de status para indicar se a submissão do SMS foi bem-sucedida ou não. Ela também retornará uma estrutura codificada em JSON para fornecer detalhes úteis sobre a submissão 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 10:26:26 GMT
Server: 10/10.3.123
Transfer-Encoding: chunked

{
	"http_code": 200,
	"response_code": "SUCCESS",
	"response_msg": "Messages queued for delivery.",
	"data": {
	  "total_count": 1,
	  "success_count": 1,
	  "failed_count": 0,
	  "messages": [
	    {
	      "message_id": "e2f650ee-90cc-43c5-885b-5ea4a0458381",
	      "from_station": "%",
	      "to_address": "+36201111111",
	      "to_station": "%",
	      "text": "Hello world!",
	      "create_date": "2021-07-15 10:32:42",
	      "valid_until": "2021-07-22 10:32:42",
	      "time_to_send": "2021-07-15 11:00:00",
	      "submit_report_requested": true,
	      "delivery_report_requested": true,
	      "view_report_requested": false,
	      "tags": [
	        {
	          "name": "Type",
	          "value": "SMS:TEXT"
	        }
	      ],
	      "status": "SUCCESS"
	    }
	  ]
	}
}

Como enviar SMS a partir de Scala usando a API de SMS em Scala (Tutorial em vídeo)

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

Vídeo 1 - Como enviar SMS a partir de Scala usando a API de SMS em Scala (Tutorial em vídeo)

Exemplo de SMS em Scala: SendScheduledSms.scala

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

código de exemplo para enviar um sms agendado usando scala
Figura 3 - Arquivo SendScheduledSms.scala

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

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

Vídeo 2 - Como verificar se o SMS foi aceito pelo usuário HTTP (Tutorial em vídeo)

Resumo

A principal função deste artigo foi explicar as etapas do agendamento de SMS em Scala com a ajuda do Ozeki SMS Gateway. Se tudo foi lido com atenção, o agendamento de SMS deve ser muito fácil. O timing perfeito para o compartilhamento de informações é importante se você deseja trabalhar com alto desempenho, pois dessa forma você pode evitar os horários de pico dos clientes, para que eles não ignorem suas mensagens. O Ozeki SMS Gateway permite gerenciar os custos de SMS e manter o controle do tráfego de SMS.

Certifique-se de continuar a leitura na página de tutoriais da Ozeki, onde mais informações podem ser encontradas sobre tópicos como exclusão de SMS em Scala.

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

More information