Saltar al contenido principal

Con las API de SMS de Sendapp
puedes automatizar las notificaciones por SMS
con cualquier plataforma

Diseñado para pequeñas y medianas empresas,
para revolucionar la comunicación con los clientes.

Prueba gratis

Script de ejemplo de WebHook

Cree un script con el siguiente contenido y proporcione su URL como WebHook.

definir("Clave API", "Xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");

tratar {
    Si (Está establecido($_SERVER["HTTP_X_SG_SIGNATURE"])) {
        $hash = base64_encode(hash_hmac('Sha256', $_POST["Mensajes"], Clave API, falso));
        Si ($hash === $_SERVER["HTTP_X_SG_SIGNATURE"]) {
            $messages = json_decode($_POST["Mensajes"], falso);

            /**
             * Por ejemplo :-
             * $messages = [
             * 0 => [
             * "ID" => "1",
             * "number" => "+911234567890",
             * "message" => "Este es un mensaje de prueba",
             * "deviceID" => "1",
             * "simSlot" => "0",
             * "userID" => "1",
             * "status" => "Received",
             * "sentDate" => "2018-10-20T00:00:00+02:00",
             * "deliveredDate" => "2018-10-20T00:00:00+02:00".
             * "groupID" => null
             * ]
             * ]
             *
             * "senDate" representa la fecha y hora en que el mensaje fue recibido en el dispositivo.
             * "deliveredDate" representa la fecha y hora en que el mensaje fue recibido por el servidor.
             */

            para cada ($messages como $message) {
                Si(Strtolower($message["Mensaje"]) === "Hola") {
                    // Responde al mensaje usando la API o ejecuta algunos comandos. Las posibilidades son ilimitadas.
                }
            }
        } más {
            http_response_code(401);
            registro de errores("¡La firma no coincide!");
        }
    } más {
        http_response_code(400);
        registro de errores("Firma no encontrada!");
    }
} captura (Excepción $e) {
    registro de errores($e->getMessage());
}

Integración PHP

Incluya el siguiente código en su archivo PHP para comenzar a enviar mensajes.

definir("SERVIDOR", "Https://sms.sendapp.live");
definir("Clave API", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");

definir("USE_SPECIFIED", 0);
definir("USE_ALL_DEVICES", 1);
definir("USE_ALL_SIMS", 2);

/**
 * @param string $number El número de móvil al que desea enviar el mensaje.
 * @param string $message El mensaje que desea enviar..
 * @param int|string $device El ID del dispositivo que desea utilizar para enviar este mensaje.
 * @param int $schedule Establece la fecha y hora en la que quieres enviar este mensaje.
 *
 * @return array Devuelve El array que contiene información sobre el mensaje.
 * @throws Exception Si hay un error al enviar el mensaje.
 */
función sendSingleMessage(1TP2 Número, $message, $device = 0, $schedule = nulo)
{
    $url = SERVIDOR . "/Services/send.php";
    $postData = formación('Número' => 1TP2 Número, 'Mensaje' => $message, 'Horarios' => $schedule, 'Llave' => Clave API, 'Dispositivos' => $device);
    regreso Enviar petición($url, $postData)["Mensajes"][0];
}

/**
 * @param array $messages Matriz que contiene números y mensajes.
 * @param int $option Establézcalo a USE_SPECIFIED si desea utilizar los dispositivos y SIMs especificados en el argumento devices.
 * Establezca USE_ALL_DEVICES si desea utilizar todos los dispositivos disponibles y su SIM por defecto para enviar mensajes.
 * Establézcalo a USE_ALL_SIMS si desea utilizar todos los dispositivos disponibles y todas sus SIMs para enviar mensajes.
 * @param array $devices El array de IDs de los dispositivos que quieres usar para enviar estos mensajes.
 * @param int $schedule Establece la fecha y hora en la que quieres enviar estos mensajes.
 * @param bool $useRandomDevice Establézcalo a true si desea enviar mensajes utilizando sólo un dispositivo al azar de los dispositivos seleccionados.
 *
 * @return array Devuelve El array que contiene los mensajes.
 * Por ejemplo :-
 * [
 * 0 => [
 * "ID" => "1",
 * "number" => "+911234567890",
 * "mensaje" => "Este es un mensaje de prueba",
 * "deviceID" => "1",
 * "simSlot" => "0",
 * "userID" => "1",
 * "status" => "Pending",
 * "sentDate" => "2018-10-20T00:00:00+02:00",
 * "deliveredDate" => null
 * "groupID" => ")V5LxqyBMEbQrl9*J$5bb4c03e8a07b7.62193871"
 * ]
 * ]
 * @throws Exception Si hay un error al enviar mensajes.
 */
función Enviar mensajes($messages, $option = USE_SPECIFIED, $devices = [], $schedule = nulo, $useRandomDevice = falso)
{
    $url = SERVIDOR . "/Services/send.php";
    $postData = [
        'Mensajes' => json_encode($messages),
        'Horarios' => $schedule,
        'Llave' => Clave API,
        'Dispositivos' => json_encode($devices),
        'Opción' => $option,
        'UseRandomDevice' => $useRandomDevice
    ];
    regreso Enviar petición($url, $postData)["Mensajes"];
}

/**
 * @param int $listID El ID de la lista de contactos a la que desea enviar este mensaje.
 * @param string $message El mensaje que desea enviar.
 * @param int $option Establézcalo como USE_SPECIFIED si desea utilizar los dispositivos y SIM especificados en el argumento devices.
 * Establezca USE_ALL_DEVICES si desea utilizar todos los dispositivos disponibles y sus SIM predeterminadas para enviar mensajes.
 * Establézcalo a USE_ALL_SIMS si desea utilizar todos los dispositivos disponibles y todas sus SIMs para enviar mensajes.
 * @param array $devices La matriz de ID de dispositivos que quieres usar para enviar el mensaje.
 * @param int $schedule Indica la hora en la que quieres enviar el mensaje.
 *
 * @return array Devuelve El array que contiene los mensajes.
 * @throws Exception Si hay un error al enviar los mensajes.
 */
función sendMessageToContactsList($listID, $message, $option = USE_SPECIFIED, $devices = [], $schedule = nulo)
{
    $url = SERVIDOR . "/Services/send.php";
    $postData = [
        'Listid' => $listID,
        'Mensaje' => $message,
        'Horarios' => $schedule,
        'Llave' => Clave API,
        'Dispositivos' => json_encode($devices),
        'Opción' => $option
    ];
    regreso Enviar petición($url, $postData)["Mensajes"];
}

/**
 * @param int $id El ID del mensaje que desea recuperar.
 *
 * @return array El array que contiene un mensaje.
 * @throws Exception Si hay un error al obtener un mensaje.
 */
función getMessageByID($id) {
    $url = SERVIDOR . "/Services/read-messages.php";
    $postData = [
        'Llave' => Clave API,
        'Carné de identidad' => $id
    ];
    regreso Enviar petición($url, $postData)["Mensajes"][0];
}

/**
 * @param string $groupID El ID de grupo de los mensajes que desea recuperar.
 *
 * @return array El array que contiene los mensajes.
 * @throws Exception Si hay un error al obtener los mensajes.
 */
función getMessagesByGroupID($groupID) {
    $url = SERVIDOR . "/Services/read-messages.php";
    $postData = [
        'Llave' => Clave API,
        'Identificación del grupo' => $groupID
    ];
    regreso Enviar petición($url, $postData)["Mensajes"];
}

/**
 * @param string $status El estado de los mensajes que desea recuperar.
 * @param int $startTimestamp Búsqueda de mensajes enviados o recibidos después de esta hora.
 * @param int $endTimestamp Búsqueda de mensajes enviados o recibidos antes de esta hora.
 *
 * @return array El array que contiene los mensajes.
 * @throws Exception Si hay un error al obtener los mensajes.
 */
función getMessagesByStatus($status, $startTimestamp, $endTimestamp)
{
    $url = SERVIDOR . "/Services/read-messages.php";
    $postData = [
        'Llave' => Clave API,
        'estado' => $status,
        'StartTimestamp' => $startTimestamp,
        'EndTimestamp' => $endTimestamp
    ];
    regreso Enviar petición($url, $postData)["Mensajes"];
}

/**
 * @param int $listID El ID de la lista de contactos donde desea añadir este contacto.
 * @param string $number Número de móvil del contacto.
 * @param string $name Nombre del contacto.
 * @param bool $resubscribe Ponlo a true si quieres volver a suscribir este contacto si ya existe.
 *
 * @return array El array que contiene el contacto recién añadido.
 * @throws Exception Si hay un error al añadir un nuevo contacto.
 */
función agregar contacto($listID, 1TP2 Número, $name = nulo, 1TP2 Suscribirse = falso)
{
    $url = SERVIDOR . "/Services/manage-contacts.php";
    $postData = [
        'Llave' => Clave API,
        'Listid' => $listID,
        'Número' => 1TP2 Número,
        'Nombre' => $name,
        'Volver a suscribirse' => 1TP2 Suscribirse
    ];
    regreso Enviar petición($url, $postData)["Contacto"];
}

/**
 * @param int $listID El ID de la lista de contactos de la que desea dar de baja este contacto.
 * @param string $number El número de móvil del contacto.
 *
 * @return array El array que contiene el contacto dado de baja.
 * @throws Exception Si se produce un error al establecer la suscripción en false.
 */
función cancelar suscripciónContacto($listID, 1TP2 Número)
{
    $url = SERVIDOR . "/Services/manage-contacts.php";
    $postData = [
        'Llave' => Clave API,
        'Listid' => $listID,
        'Número' => 1TP2 Número,
        'Cancelar suscripción' => falso
    ];
    regreso Enviar petición($url, $postData)["Contacto"];
}

/**
 * @return string La cantidad de créditos de mensajes que quedan.
 * @throws Exception Si hay un error al obtener los créditos de mensajes.
 */
función getBalance()
{
    $url = SERVIDOR . "/Services/send.php";
    $postData = [
        'Llave' => Clave API,
    ];
    $credits = Enviar petición($url, $postData)["Créditos"];
    regreso es nulo($credits) ? "Ilimitado" : $credits;
}

función Enviar petición($url, $postData)
{
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_POST, falso);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, falso);
    curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($postData));
    1TP2 Respuesta = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    Si (curl_errno($ch)) {
        lanzar nuevo Excepción(curl_error($ch));
    }
    curl_close($ch);
    Si ($httpCode == 200) {
        $json = json_decode(1TP2 Respuesta, falso);
        Si ($json == falso) {
            Si (vacío(1TP2 Respuesta)) {
                lanzar nuevo Excepción("Faltan datos en la solicitud. Proporcione toda la información necesaria para enviar mensajes".);
            } más {
                lanzar nuevo Excepción(1TP2 Respuesta);
            }
        } más {
            Si ($json["Éxito"]) {
                regreso $json["fecha"];
            } más {
                lanzar nuevo Excepción($json["Error"]["Mensaje"]);
            }
        }
    } más {
        lanzar nuevo Excepción("Código de error HTTP: {$httpCode}");
    }
}

Enviar mensaje individual

tratar {
    // Envía un mensaje usando el dispositivo principal.
    $msg = sendSingleMessage("+911234567890", "Esta es una prueba de mensaje único".);

    // Enviar un mensaje usando la ID del dispositivo 1.
    $msg = sendSingleMessage("+911234567890", "Esta es una prueba de mensaje único"., 1);
	
    // Envía un mensaje usando la SIM en la ranura 1 de la ID del dispositivo 1 (Representado como "1 | 0").
    // La ranura SIM es un índice, por lo que el índice de la primera SIM es 0 y el índice de la segunda SIM es 1.
    // En este ejemplo, 1 representa la ID del dispositivo y 0 representa el índice de la ranura SIM.
    $msg = sendSingleMessage("+911234567890", "Esta es una prueba de mensaje único"., "1|0");

    // Enviar mensaje programado utilizando el dispositivo primario.
    $msg = sendSingleMessage("+911234567890", "Esta es una prueba de la función de programación"., nulo, strtotime("+2 minutos"));
    print_r($msg);

    eco "Se envió un mensaje correctamente".;
} captura (Excepción $e) {
    echo $e->getMessage();
}

Enviar mensajes masivos

$messages = formación();

para ($i = 1; $i <= 12; $i++) {
    array_push($messages,
        [
            "Número" => "+911234567890",
            "Mensaje" => "Esta es una prueba # {$i} de la versión PHP. Prueba de la funcionalidad de mensajes masivos".
        ]);
}

tratar {
    // Enviar mensajes usando el dispositivo primario.
    Enviar mensajes($messages);

    // Enviar mensajes usando la SIM predeterminada de todos los dispositivos disponibles. Los mensajes se dividirán entre todos los dispositivos.
    Enviar mensajes($messages, USE_ALL_DEVICES);
	
    // Enviar mensajes usando todas las SIM de todos los dispositivos disponibles. Los mensajes se dividirán entre todas las SIM.
    Enviar mensajes($messages, USE_ALL_SIMS);

    // Enviar mensajes utilizando solo dispositivos especificados. Los mensajes se dividirán entre dispositivos o SIM que haya especificado.
    // Si envía 12 mensajes con este código, se enviarán 4 mensajes por ID de dispositivo 1, otros 4 por SIM en la ranura 1 de 
    // ID del dispositivo 2 (representado como "2 | 0") y 4 restantes por SIM en la ranura 2 de la ID del dispositivo 2 (representado como "2 | 1").
    Enviar mensajes($messages, USE_SPECIFIED, [1, "2|0", "2|1"]);
    
    // Enviar mensajes en horario utilizando el dispositivo principal.
    Enviar mensajes($messages, nulo, nulo, strtotime("+2 minutos"));
    
    // Enviar un mensaje a los contactos en la lista de contactos con ID de 1.
    sendMessageToContactsList(1, "Prueba", USE_SPECIFIED, 1);
    
    // Enviar un mensaje según lo programado a los contactos en la lista de contactos con ID de 1.
    $msgs = sendMessageToContactsList(1, "Prueba", nulo, nulo, strtotime("+2 minutos"));
    
    print_r($msgs);

    eco "Se enviaron mensajes masivos correctamente".;
} captura (Excepción $e) {
    echo $e->getMessage();
}

Obtenga créditos de mensajes restantes

tratar {
    $credits = getBalance();
    eco "Créditos restantes del mensaje: {$credits}";
} captura (Excepción $e) {
    echo $e->getMessage();
}

Recibe mensajes y su estado actual

tratar {
    // Recibe un mensaje usando la ID.
    $msg = getMessageByID(1);
    print_r($msg);

    // Recibe mensajes usando la ID de grupo.
    $msgs = getMessagesByGroupID(') * V5LxqyBMEbQrl9 J$5bb4c03e8a07b7.62193871');
    print_r($msgs);
    
    // Recibe mensajes recibidos en las últimas 24 horas.
    $msgs = getMessagesByStatus("Recibido", hora() - 86400);
    print_r($msgs);
} captura (Excepción $e) {
    echo $e->getMessage();
}

Gestionar contactos

tratar {
    // Agregue un nuevo contacto a la lista de contactos 1 o vuelva a suscribir el contacto si ya existe.
    $contact = agregar contacto(1, "+911234567890", "Prueba", falso);
    print_r($contact);
    
    // Anular la suscripción de un contacto utilizando el número de móvil.
    $contact = cancelar suscripciónContacto(1, "+911234567890");
    print_r($contact);
} captura (Excepción $e) {
    echo $e->getMessage();
}

Integración C#

utilizando Sistema;
utilizando Sistema.Colecciones.Genérico;
utilizando Sistema.yo;
utilizando Sistema.Red;
utilizando Sistema.Texto;
utilizando Sistema.Web;
utilizando Gateway_Sample_Application.Propiedades;
utilizando Newtonsoft.jSON;
utilizando Newtonsoft.jSON.Linq;

espacio de nombres SMS
{
    estático clase API
    {
        privado estático solo lectura cuerda Servidor = "Https://sms.sendapp.live"
        privado estático solo lectura cuerda Llave = "6e1bdb4ed91f3b83071dd5a520c9d226ea19245e";

        público enumeración Opción
        {
            USE_SPECIFIED = 0,
            USE_ALL_DEVICES = 1,
            USE_ALL_SIMS = 2
        }

        /// 
        /// Enviar un solo mensaje a un número móvil específico.
        /// 
        ///  El número de móvil al que desea enviar el mensaje. 
        ///  El mensaje que quieres enviar. 
        ///  La identificación de un dispositivo que desea usar para enviar este mensaje. 
        ///  Ajústelo a la marca de tiempo cuando desee enviar este mensaje. 
        ///  Si hay un error al enviar un mensaje. 
        ///  El diccionario que contiene información sobre el mensaje. 
        público estático Diccionario<cuerda, objeto> SendSingleMessage(cuerda número, cuerda mensaje, cuerda dispositivo = "0", largo? calendario = nulo)
        {
            var valores = nuevo Diccionario<cuerda, objeto>
            {
                { "Número", número},
                { "Mensaje", mensaje},
                { "Calendario", calendario },
                { "Llave", Llave },
                { "Dispositivos", dispositivo }
            };

            regreso getMessages(Obtener una respuesta($"{Servidor} /services/send.php", valores)["Mensajes"])[0];
        }

        /// 
        /// Enviar múltiples mensajes a diferentes números móviles.
        /// 
        ///  La matriz que contiene números y mensajes. 
        ///  Establezca esto en USE_SPECIFIED si desea usar dispositivos y SIMs especificados en el argumento de dispositivos.
        /// Establezca esto en USE_ALL_DEVICES si desea usar todos los dispositivos disponibles y su SIM predeterminada para enviar mensajes.
        /// Establezca esto en USE_ALL_SIMS si desea utilizar todos los dispositivos disponibles y todas sus SIM para enviar mensajes. 
        ///  El conjunto de ID de dispositivos que desea usar para enviar estos mensajes. 
        ///  Ajústelo a la marca de tiempo cuando desee enviar este mensaje. 
        ///  Establézcalo en verdadero si desea enviar mensajes utilizando solo un dispositivo aleatorio de los dispositivos seleccionados. 
        ///  Si hay un error al enviar mensajes. 
        ///  La matriz que contiene mensajes. 
        público estático Diccionario<cuerda, objeto> [] Enviar mensajes(lista<Diccionario<cuerda, cuerda>> mensajes, Opción opciones = Opción.USE_SPECIFIED, cuerda[] dispositivos = nulo, largo? calendario = nulo, bool useRandomDevice = falso)
        {
            var valores = nuevo Diccionario<cuerda, objeto>
            {
                { "Mensajes", JsonConvert.SerializeObject(mensajes)},
                { "Calendario", calendario },
                { "Llave", Llave },
                { "Dispositivos", dispositivos },
                { "Opción", (En t) opciones },
                { "UseRandomDevice", useRandomDevice }
            };

            regreso getMessages(Obtener una respuesta($"{Servidor} /services/send.php", valores)["Mensajes"]);
        }

        /// 
        /// Enviar un mensaje a los contactos en la lista de contactos especificada.
        /// 
        ///  El ID de la lista de contactos donde desea enviar este mensaje. 
        ///  El mensaje que quieres enviar. 
        ///  Establezca esto en USE_SPECIFIED si desea usar dispositivos y SIMs especificados en el argumento de dispositivos.
        /// Establezca esto en USE_ALL_DEVICES si desea usar todos los dispositivos disponibles y su SIM predeterminada para enviar mensajes.
        /// Establezca esto en USE_ALL_SIMS si desea utilizar todos los dispositivos disponibles y todas sus SIM para enviar mensajes. 
        ///  El conjunto de ID de dispositivos que desea usar para enviar estos mensajes. 
        ///  Ajústelo a la marca de tiempo cuando desee enviar este mensaje. 
        ///  Si hay un error al enviar mensajes. 
        ///  La matriz que contiene mensajes. 
        público estático Diccionario<cuerda, objeto> [] SendMessageToContactsList(En t listid, cuerda mensaje, Opción opciones = Opción.USE_SPECIFIED, cuerda[] dispositivos = nulo, largo? calendario = nulo)
        {
            var valores = nuevo Diccionario<cuerda, objeto>
            {
                { "Listid", listid},
                { "Mensaje", mensaje},
                { "Calendario", calendario },
                { "Llave", Llave },
                { "Dispositivos", dispositivos },
                { "Opción", (En t) opciones }
            };

            regreso getMessages(Obtener una respuesta($"{Servidor} /services/send.php", valores)["Mensajes"]);
        }

        /// 
        /// Recibe un mensaje usando la ID.
        /// 
        ///  La identificación de un mensaje que desea recuperar. 
        ///  Si hay un error al recibir un mensaje. 
        ///  El diccionario que contiene información sobre el mensaje. 
        público estático Diccionario<cuerda, objeto> GetMessageByID(En t carné de identidad)
        {
            var valores = nuevo Diccionario<cuerda, objeto>
            {
                { "Llave", Llave },
                { "Carné de identidad", carné de identidad }
            };

            regreso getMessages(Obtener una respuesta($"{Servidor} /services/read-messages.php", valores)["Mensajes"])[0];
        }

        /// 
        /// Recibe mensajes usando la ID de grupo.
        /// 
        ///  El ID de grupo de los mensajes que desea recuperar. 
        ///  Si hay un error al recibir mensajes. 
        ///  La matriz que contiene mensajes. 
        público estático Diccionario<cuerda, objeto> [] GetMessagesByGroupID(cuerda Identificación del grupo)
        {
            var valores = nuevo Diccionario<cuerda, objeto>
            {
                { "Llave", Llave },
                { "Identificación del grupo", Identificación del grupo }
            };

            regreso getMessages(Obtener una respuesta($"{Servidor} /services/read-messages.php", valores)["Mensajes"]);
        }

        /// 
        /// Recibe mensajes usando el estado.
        /// 
        ///  El estado de los mensajes que desea recuperar. 
        ///  Busque mensajes enviados o recibidos después de este tiempo. 
        ///  Busque mensajes enviados o recibidos antes de este momento. 
        ///  Si hay un error al recibir mensajes. 
        ///  La matriz que contiene mensajes. 
        público estático Diccionario<cuerda, objeto> [] GetMessagesByStatus(cuerda estado, largo? startTimestamp = nulo, largo? endTimestamp = nulo)
        {
            var valores = nuevo Diccionario<cuerda, objeto>
            {
                { "Llave", Llave },
                { "estado", estado },
                { "StartTimestamp", startTimestamp },
                { "EndTimestamp", endTimestamp }
            };

            regreso getMessages(Obtener una respuesta($"{Servidor} /services/read-messages.php", valores)["Mensajes"]);
        }
        
        /// 
        /// Agregar un nuevo contacto a la lista de contactos.
        /// 
        ///  El ID de la lista de contactos donde desea agregar este contacto. 
        ///  El número de móvil del contacto. 
        ///  El nombre del contacto. 
        ///  Póngalo en verdadero si desea volver a suscribir este contacto si ya existe. 
        ///  Un diccionario que contiene detalles sobre un contacto recién agregado. 
        público estático Diccionario<cuerda, objeto> Agregar contacto(En t listid, cuerda número, cuerda nombre = nulo, bool volver a suscribirse = falso)
        {
            var valores = nuevo Diccionario<cuerda, objeto>
            {
                {"Llave", Llave},
                {"Listid", listid},
                {"Número", número},
                {"Nombre", nombre},
                {"Volver a suscribirse", volver a suscribirse ? '1' : '0'},
            };
            bolsa de trabajo bolsa de trabajo = (bolsa de trabajo) Obtener una respuesta($"{Servidor} /services/manage-contacts.php", valores)["Contacto"];
            regreso bolsa de trabajo.Al objeto<Diccionario<cuerda, objeto>> ();
        }
        
        /// 
        /// Anular la suscripción de un contacto de la lista de contactos.
        /// 
        ///  El ID de la lista de contactos de la que desea cancelar la suscripción de este contacto. 
        ///  El número de móvil del contacto. 
        ///  Un diccionario que contiene detalles sobre el contacto no suscrito. 
        público estático Diccionario<cuerda, objeto> Cancelar suscripciónContacto(En t listid, cuerda número)
        {
            var valores = nuevo Diccionario<cuerda, objeto>
            {
                {"Llave", Llave},
                {"Listid", listid},
                {"Número", número},
                {"Cancelar suscripción", '1'}
            };
            bolsa de trabajo bolsa de trabajo = (bolsa de trabajo)Obtener una respuesta($"{Servidor} /services/manage-contacts.php", valores)["Contacto"];
            regreso bolsa de trabajo.Al objeto<Diccionario<cuerda, objeto>> ();
        }
        
        /// 
        /// Obtenga los créditos restantes del mensaje.
        /// 
        ///  Si hay un error al obtener los créditos del mensaje. 
        ///  La cantidad de créditos de mensaje restantes. 
        público estático cuerda GetBalance()
        {
            var valores = nuevo Diccionario<cuerda, objeto>
            {
                {"Llave", Llave}
            };
            JToken créditos = Obtener una respuesta($"{Servidor} /services/send.php", valores)["Créditos"];
            Si (créditos.Tipo != JTokenType.Nulo)
            {
                regreso créditos.Encadenar();
            }
            regreso "Ilimitado";
        }

        privado estático Diccionario<cuerda, objeto> [] getMessages(JToken mensajesJToken)
        {
            JArray jArray = (JArray)mensajesJToken;
            var mensajes = nuevo Diccionario<cuerda, objeto> [jArray.Contar];
            para (var índice = 0; índice < jArray.Contar; índice++)
            {
                mensajes[índice] = jArray[índice].Al objeto<Diccionario<cuerda, objeto>> ();
            }
            regreso mensajes;
        }

        privado estático JToken Obtener una respuesta(cuerda url, Diccionario<cuerda, objeto> postData)
        {
            var solicitud = (HttpWebRequest)WebRequest.Crear(url);
            var cadena de datos = CreateDataString(postData);
            var fecha = Codificación.UTF8.GetBytes(cadena de datos);

            solicitud.Método = "ENVIAR";
            solicitud.Tipo de contenido = "Aplicación / x-www-form-urlencoded";
            solicitud.Largancia de contenido = fecha.Longitud;
            ServicePointManager.Expect100Continue = falso;
            ServicePointManager.Protocolo de seguridad = SecurityProtocolType.Tls12;
            utilizando (var corriente = solicitud.GetRequestStream())
            {
                corriente.Escribir(fecha, 0, fecha.Longitud);
            }

            var respuesta = (HttpWebResponse)solicitud.Obtener una respuesta();

            Si (respuesta.Código de estado == HttpStatusCode.bueno)
            {
                utilizando (StreamReader StreamReader = nuevo StreamReader(respuesta.GetResponseStream()))
                {
                    var jsonResponse = StreamReader.ReadToEnd();
                    tratar
                    {
                        bolsa de trabajo bolsa de trabajo = bolsa de trabajo.Analizar gramaticalmente(jsonResponse);
                        Si ((bool)bolsa de trabajo["Éxito"])
                        {
                            regreso bolsa de trabajo["fecha"];
                        }
                        lanzar nuevo Excepción(bolsa de trabajo["Error"]["Mensaje"].Encadenar());
                    }
                    captura (JsonReaderException)
                    {
                        Si (cuerda.IsNullOrEmpty(jsonResponse))
                        {
                            lanzar nuevo InvalidDataException("Faltan datos en la solicitud. Proporcione toda la información necesaria para enviar mensajes".);
                        }
                        lanzar nuevo Excepción(jsonResponse);
                    }
                }
            }

            lanzar nuevo WebException($"Error HTTP: {(int) response.StatusCode} {response.StatusCode}");
        }

        privado estático cuerda CreateDataString(Diccionario<cuerda, objeto> fecha)
        {
            StringBuilder cadena de datos = nuevo StringBuilder();
            bool primero = falso;
            para cada (var obj en fecha)
            {
                Si (obj.Valor != nulo)
                {
                    Si (primero)
                    {
                        primero = falso;
                    }
                    más
                    {
                        cadena de datos.Adjuntar("&");
                    }
                    cadena de datos.Adjuntar(HttpUtility.UrlEncode(obj.Llave));
                    cadena de datos.Adjuntar("=");
                    cadena de datos.Adjuntar(obj.Valor es cuerda[]
                        ? HttpUtility.UrlEncode(JsonConvert.SerializeObject(obj.Valor))
                        : HttpUtility.UrlEncode(obj.Valor.Encadenar()));
                }
            }
            regreso cadena de datos.Encadenar();
        }
    }
}

Enviar mensaje individual

tratar
{
    // Envía un mensaje usando el dispositivo principal.
    SMS.API.SendSingleMessage("+911234567890", "Esta es una prueba de mensaje único".);

    // Enviar un mensaje usando la ID del dispositivo 1.
    Diccionario<cuerda, objeto> mensaje = SMS.API.SendSingleMessage("+911234567890", "Esta es una prueba de mensaje único"., "1");
	
    // Envía un mensaje usando la SIM en la ranura 1 de la ID del dispositivo 1 (Representado como "1 | 0").
    // La ranura SIM es un índice, por lo que el índice de la primera SIM es 0 y el índice de la segunda SIM es 1.
    // En este ejemplo, 1 representa la ID del dispositivo y 0 representa el índice de la ranura SIM.
    Diccionario<cuerda, objeto> mensaje = SMS.API.SendSingleMessage("+911234567890", "Esta es una prueba de mensaje único"., "1|0");

    // Enviar mensaje programado utilizando el dispositivo primario.
    largo marca de tiempo = (largo) Fecha y hora.UtcNow.Añadir minutos(2).Sustraer(nuevo Fecha y hora(1970, 1, 1)).segundos totales;
    Diccionario<cuerda, objeto> mensaje = SendSingleMessage(textBoxNumber.Texto, textBoxMessage.Texto, nulo, marca de tiempo);
    
    Caja de mensaje.mostrar("Se envió un mensaje correctamente".);
}
captura (Excepción excepción)
{
    Caja de mensaje.mostrar(excepción.Mensaje, "! Error", MessageBoxButtons.bueno, MessageBoxIcon.error);
}

Enviar mensajes masivos

lista<Diccionario<cuerda, cuerda>> mensajes = nuevo lista<Diccionario<cuerda, cuerda>> ();
para (En t el = 1; el <= 12; el++)
{
    var mensaje = nuevo Diccionario<cuerda, cuerda>
    {
        { "Número", "+911234567890" },
        { "Mensaje", "Esta es una prueba # {$i} de la versión C#. Prueba de la funcionalidad de mensajes masivos". }
    };
    mensajes.Añadir(mensaje);
}

tratar
{
    // Enviar mensajes usando el dispositivo primario.
    SMS.API.Enviar mensajes(mensajes);

    // Enviar mensajes usando la SIM predeterminada de todos los dispositivos disponibles. Los mensajes se dividirán entre todos los dispositivos.
    SMS.API.Enviar mensajes(mensajes, SMS.API.Opción.USE_ALL_DEVICES);
	
    // Enviar mensajes usando todas las SIM de todos los dispositivos disponibles. Los mensajes se dividirán entre todas las SIM.
    SMS.API.Enviar mensajes(mensajes, SMS.API.Opción.USE_ALL_SIMS);

    // Enviar mensajes utilizando solo dispositivos especificados. Los mensajes se dividirán entre dispositivos o SIM que haya especificado.
    // Si envía 12 mensajes con este código, se enviarán 4 mensajes por ID de dispositivo 1, otros 4 por SIM en la ranura 1 de 
    // ID del dispositivo 2 (representado como "2 | 0") y 4 restantes por SIM en la ranura 2 de la ID del dispositivo 2 (representado como "2 | 1").
    SMS.API.Enviar mensajes(mensajes, SMS.API.Opción.USE_SPECIFIED, nuevo [] {"1", "2|0", "2|1"});
    
    // Enviar mensajes en horario utilizando el dispositivo principal.
    largo marca de tiempo = (largo) Fecha y hora.UtcNow.Añadir minutos(2).Sustraer(nuevo Fecha y hora(1970, 1, 1)).segundos totales;
    Diccionario<cuerda, objeto> [] mensajes = SMS.API.Enviar mensajes(mensajes, Opción.USE_SPECIFIED, nulo, marca de tiempo);
    
    // Enviar un mensaje a los contactos en la lista de contactos con ID de 1.
    Diccionario<cuerda, objeto> [] mensajes = SMS.API.SendMessageToContactsList(1, "Prueba", SMS.API.Opción.USE_SPECIFIED, nuevo [] {"1"});

    // Enviar un mensaje según lo programado a los contactos en la lista de contactos con ID de 1.
    Diccionario<cuerda, objeto> [] mensajes = SMS.API.SendMessageToContactsList(1, "Prueba #1", Opción.USE_SPECIFIED, nulo, marca de tiempo);
    
    Caja de mensaje.mostrar("Éxito");
}
captura (Excepción excepción)
{
    Caja de mensaje.mostrar(excepción.Mensaje, "! Error", MessageBoxButtons.bueno, MessageBoxIcon.error);
}

Obtenga créditos de mensajes restantes

tratar
{
    cuerda créditos = SMS.API.GetBalance();
    Caja de mensaje.mostrar($"Créditos restantes del mensaje: {créditos}");
}
captura (Excepción excepción)
{
    Caja de mensaje.mostrar(excepción.Mensaje, "! Error", MessageBoxButtons.bueno, MessageBoxIcon.error);
}

Recibe mensajes y su estado actual

tratar 
{
    // Recibe un mensaje usando la ID.
    Diccionario<cuerda, objeto> mensaje = SMS.API.GetMessageByID(1);

    // Recibe mensajes usando la ID de grupo.
    Diccionario<cuerda, objeto> [] mensajes = SMS.API.GetMessagesByGroupID(") * V5LxqyBMEbQrl9 J$5bb4c03e8a07b7.62193871");
    
    // Recibe mensajes recibidos en las últimas 24 horas.
    largo marca de tiempo = (largo) Fecha y hora.UtcNow.AddHours(-24).Sustraer(nuevo Fecha y hora(1970, 1, 1)).segundos totales;
    GetMessagesByStatus("Recibido", marca de tiempo);
}
captura (Excepción excepción)
{
    Caja de mensaje.mostrar(excepción.Mensaje, "! Error", MessageBoxButtons.bueno, MessageBoxIcon.error);
}

Gestionar contactos

tratar {
    // Agregue un nuevo contacto a la lista de contactos 1 o vuelva a suscribir el contacto si ya existe.
    Diccionario<cuerda, objeto> contacto = SMS.API.Agregar contacto(1, "+911234567890", "Prueba C#", falso);
    
    // Anular la suscripción de un contacto utilizando el número de móvil.
    Diccionario<cuerda, objeto> contacto = Cancelar suscripciónContacto(1, "+911234567890");
}
captura (Excepción excepción)
{
    Caja de mensaje.mostrar(excepción.Mensaje, "! Error", MessageBoxButtons.bueno, MessageBoxIcon.error);
}