Configure su cuenta para la verificación por SMS
un. Cree una cuenta de MessageCentral: Inscríbase en una central de mensajes cuenta para empezar. Recibirás un identificador de cliente, que utilizarás en tu solicitud.
b. Para instalar Ruby, puedes seguir estos pasos:
Descargar Ruby:
Visita la página oficial de descargas de Ruby: https://www.ruby-lang.org/en/downloads/
Descarga la versión más reciente de Ruby para tu sistema operativo (Windows, macOS o Linux).
Instala Ruby:
Windows: haga doble clic en el instalador descargado y siga las instrucciones que aparecen en pantalla.
macOS: abre el paquete descargado y sigue las instrucciones de instalación.
Linux: usa tu administrador de paquetes para instalar Ruby. Por ejemplo, en Ubuntu, puedes usar
sudo apt-get update
sudo apt-get install ruby-full
Verifique la instalación:
Abra una línea de comandos (en Windows) o una terminal (en macOS/Linux).
Ejecute el siguiente comando para verificar la instalación:
ruby --versionEsto debería imprimir la versión de Ruby instalada. Si está instalada correctamente, deberías ver algo como:
ruby 3.1.0p0 (2021-12-25 revision abcdef1234567890)Una vez instalado Ruby, puede empezar a usarlo para desarrollar aplicaciones Ruby.
Para configurar la variable de entorno PATH para Ruby, puedes seguir estos pasos:
Ventanas:
Haga clic con el botón derecho en «Este PC» o «Mi PC» y seleccione «Propiedades».
Haga clic en «Configuración avanzada del sistema» y luego en «Variables de entorno».
En la sección «Variables del sistema», seleccione la variable «Ruta» y haga clic en «Editar».
Agregue la ruta al directorio ejecutable de Ruby (por ejemplo, C:\Ruby27\bin) si aún no está presente.
Haga clic en «Aceptar» para guardar los cambios.
MacOS/Linux:
Abre una terminal.
Abre o crea el archivo.bash_profile en tu directorio principal.
nano ~/.bash_profileAñada la siguiente línea y sustituya /path/to/ruby por la ruta real a su directorio ejecutable de Ruby:
export PATH=$PATH:/path/to/rubyGuarde el archivo y salga del editor de texto.
Obtenga el archivo .bash_profile para aplicar los cambios:
Después de seguir estos pasos, el ejecutable de Ruby debería estar accesible desde cualquier parte de tu sesión de terminal.
Pasos de integración
Este proceso implica los siguientes tres pasos importantes:
- Detalles de Message Central
- Agregar detalles de Message Central en el código
- Enviar una opción de prueba para su verificación
a. Detalles de la central de mensajes
Después de crear una cuenta en Message Central, necesitará los siguientes detalles
- ID de cliente: puedes obtener el ID de cliente en Message Central Home Console
- Credenciales de inicio de sesión: necesitará un correo electrónico y tendrá que crear una contraseña
b. Agregar detalles de MessageCentral en el código
Para agregar detalles de MessageCentral en el código, busque la definición de la variable con el nombre «customerID», «correo electrónico» y «contraseña»:
customer_id = "C-45539F39A4*****"
email = "abhishek*****k68@gmail.com"
password = "*****"
base_url = "https://cpaas.messagecentral.com"
auth_token = nil
verification_id = nil
verification_status = nilAhora, debe crear un archivo Ruby llamado program.rb y agregar el código Ruby proporcionado a este archivo.
require 'json'
require 'net/http'
customer_id = "C-45539F39A449437"
email = "abhishekkaushik68@gmail.com"
password = "Wesee@123"
base_url = "https://cpaas.messagecentral.com"
auth_token = nil
verification_id = nil
verification_status = nil
def parse_json(json_string, key)
begin
json = JSON.parse(json_string)
return json[key]
rescue JSON::ParserError => e
puts e
return nil
end
end
def generate_auth_token(customer_id, email, password, base_url)
begin
base64_string = Base64.strict_encode64(password)
url = "#{base_url}/auth/v1/authentication/token?country=IN&customerId=#{customer_id}&email=#{email}&key=#{base64_string}&scope=NEW"
uri = URI(url)
response = Net::HTTP.get_response(uri)
if response.code == '200'
auth_token = parse_json(response.body, 'token')
return auth_token
else
puts "Error generating auth token. Response code: #{response.code}"
return nil
end
rescue StandardError => e
puts e
return nil
end
end
def send_otp(country_code, mobile_number, base_url, auth_token)
begin
url = "#{base_url}/verification/v3/send?countryCode=#{country_code}&customerId=#{customer_id}&flowType=SMS&mobileNumber=#{mobile_number}"
uri = URI(url)
request = Net::HTTP::Post.new(uri)
request['Accept'] = '*/*'
request['authToken'] = auth_token
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
http.request(request)
end
if response.code == '200'
verification_id = parse_json(parse_json(response.body, 'data'), 'verificationId')
return verification_id
else
puts "Error sending OTP. Response code: #{response.code}"
return nil
end
rescue StandardError => e
puts e
return nil
end
end
def validate_otp(otp_code, country_code, mobile_number, verification_id, base_url, auth_token)
begin
url = "#{base_url}/verification/v3/validateOtp?countryCode=#{country_code}&mobileNumber=#{mobile_number}&verificationId=#{verification_id}&customerId=#{customer_id}&code=#{otp_code}"
uri = URI(url)
request = Net::HTTP::Get.new(uri)
request['Accept'] = '*/*'
request['authToken'] = auth_token
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
http.request(request)
end
if response.code == '200'
verification_status = parse_json(response.body, 'verificationStatus')
return verification_status
else
puts "Error validating OTP. Response code: #{response.code}"
return nil
end
rescue StandardError => e
puts e
return nil
end
end
def run_server(customer_id, email, password, base_url)
server = TCPServer.new('localhost', 3000)
puts "Server running at http://localhost:3000/"
loop do
Thread.start(server.accept) do |client|
request = client.gets
method, path = request.split(' ')
path_segments = path.split('/')
if method == 'POST' && path.start_with?('/sendotp/')
country_code = path_segments[-2]
mobile_number = path_segments[-1]
auth_token = generate_auth_token(customer_id, email, password, base_url)
verification_id = send_otp(country_code, mobile_number, base_url, auth_token)
response_body = verification_id ? 'Otp sent! Successfully' : 'Bad Request'
client.puts "HTTP/1.1 200 OK"
client.puts "Content-Type: text/plain"
client.puts
client.puts response_body
elsif method == 'GET' && path.start_with?('/validateOtp/')
country_code = path_segments[-3]
mobile_number = path_segments[-2]
otp_code = path_segments[-1]
auth_token = generate_auth_token(customer_id, email, password, base_url)
verification_status = validate_otp(otp_code, country_code, mobile_number, verification_id, base_url, auth_token)
response_body = verification_status == 'VERIFICATION_COMPLETED' ? 'Otp verification Done!' : 'Bad Request'
client.puts "HTTP/1.1 200 OK"
client.puts "Content-Type: text/plain"
client.puts
client.puts response_body
else
client.puts "HTTP/1.1 404 Not Found"
client.puts "Content-Type: text/plain"
client.puts
client.puts "Not Found"
end
client.close
end
end
end
run_server(customer_id, email, password, base_url)c. Enviar un SMS de prueba de Otp para su verificación
Si necesita probar el servicio sin código, puede ir a verificación por SMS gratuita página en el sitio web de Message Central.
Para garantizar que la integración se realice correctamente, envíe un SMS OTP de prueba de la siguiente manera:
- Para ejecutar el código de Ruby, debe ejecutarlo con el intérprete de Ruby. Así es como puedes hacerlo:
Guarda tu código Ruby en un archivo llamado program.rb.
Abre una terminal o una línea de comandos.
Navegue hasta el directorio donde está guardado el program.rb.
Ejecuta el archivo Ruby con el comando ruby:programa ruby.rb
Esto ejecutará su programa Ruby y mostrará cualquier resultado que produzca. - Abra Postman y configure el método de solicitud como POST y
URL como http://localhost:3000/sendotp/<countryCode>/<phone_number>
Aquí está el puerto 3000, es predeterminado y está definido en código, se puede cambiar.
Por ejemplo, para la URL de un número de teléfono indio: http://localhost:3000/sendotp/91/123****123- Imagen 1: Sending Otp
- Imagen 1: Sending Otp
- Ahora tienes una OTP en tu bandeja de entrada de sms. Pruebe su propia API de validación de OTP para validar OTP.
Abra Postman y configure el método de solicitud como GET y
URL como http://localhost:3000/validateOtp/<countryCode>/<phone_number>/<otp>
Aquí está el puerto 3000, es predeterminado y está definido en código, se puede cambiar.
Por ejemplo, para la URL del número de teléfono indio: http://localhost:3000/validateOtp/91/123****123/ ****
- Imagen 2: Verificación de Otp
- Imagen 2: Verificación de Otp
