Contact SMSLink
Autentificare
Pentru a putea crea campanii de SMS Marketing, 2-Way SMS, a accesa Mail to SMS, SMS Gateway, SMS Alerts sau SMS Connectors trebuie sa va autentificati.
Nume de utilizator sau e-mail
Parola
Creati un cont de utilizator
Ati uitat parola?
Program de parteneriat
Reprezentati o companie care activeaza in domeniile marketing, publicitate, public relations sau sunteti consultant in domeniile acestea? Beneficiati de avantajele acestui program de parteneriat pentru a putea propune solutia SMSLink clientilor dvs. (inclusiv white-label). Aflati mai multe
Solutii SMS personalizate
Aveti nevoie de o solutie pentru SMS marketing, campanii SMS, notificari SMS sau mobile advertising personalizata? Echipa noastra tehnica si comerciala va sta la dispozitie pentru a identifica specificatiile solutiei tehnice optime pentru atingerea tuturor obiectivelor propuse. Contactati-ne

Prin pasiune pentru tehnologie si clienti multumiti, suntem singurul furnizor de servicii SMS din Romania prezent in clasamentul Deloitte Technology Fast 50.

Despre SMSLink

Aflati mai multe

Pentru a putea testa live exemplele de integrare SMS Gateway este necesar sa va creati un cont de utilizator in platforma SMSLink iar apoi in contul dvs. de utilizator sa definiti o conexiune pentru serviciul SMS Gateway.

File Icon main.php
<?php

/**
 *
 *   SMS Gateway (BULK) (Version 1) integration with SMSLink.ro 
 *   
 *     using SMS Gateway (BULK) Version 1 Endpoint
 *
 *     Supports HTTP and HTTPS protocols
 *     
 *   (New) SMS Gateway (BULK) Version 3 Endpoint is available, see other examples for new features. 
 *
 *   System Requirements:
 *
 *     PHP 5 with
 *     
 *         PHP cURL
 *         
 *         Optional, for transmission compression the following compression libraries are needed:
 *         
 *             for Zlib Gzip compression PHP is required to be compiled --with-zlib[=DIR] [and/or]
 *             for bzip2 compression PHP is required to be compiled --with-bz2[=DIR] [and/or]
 *             for LZF compression PHP is required to be compiled --with-lzf[=DIR]
 *
 *   Usage:
 *
 *     See Usage Examples for the SMSLinkSMSGatewayBulkPackage() class starting on line 391
 *
 *     Get your SMSLink / SMS Gateway Connection ID and Password from
 *         https://www.smslink.ro/get-api-key/
 *
 *   @version    2.0
 *   @see        https://www.smslink.ro/sms-gateway-documentatie-sms-gateway.html
 *
 */

class SMSLinkSMSGatewayBulkPackage
{    
    private 
$connection_id null;
    private 
$password      null;
        
    private 
$doHTTPS       true;        
    private 
$testMode      false;
    
    protected 
$endpointHTTP  "http://www.smslink.ro/sms/gateway/communicate/bulk.php";
    protected 
$endpointHTTPS "https://secure.smslink.ro/sms/gateway/communicate/bulk.php";
            
    private 
$temporaryDirectory "/tmp";           
        
    public 
$remoteMessageIDs = array();
    public 
$errorMessage     "";
    public 
$transactionTime  0;
    
    private 
$packageContents = array();
    private 
$packageStatus 0;
    
    private 
$packageFile = array(
            
"contentPlain"      => "",
            
"contentCompressed" => ""
        
);
    
    private 
$packageValidation = array(
            
"hashMD5" => array(
                
"contentPlain"      => "",
                
"contentCompressed" => ""
            
)
        );
    
    protected 
$clientVersion 2.0;
    
    protected 
$compressionMethods = array(
            
=> array("CompressionID" => 0"Compression" => "No Compression"),
            
=> array("CompressionID" => 1"Compression" => "Compression using Zlib Gzip"),
            
=> array("CompressionID" => 2"Compression" => "Compression using bzip2"),
            
=> array("CompressionID" => 3"Compression" => "Compression using LZF"),
        );
    
    private 
$compressionMethod 1;
    
    
/**
     *   Initialize SMSLink - SMS Gateway
     *
     *   Initializing SMS Gateway will require the parameters $connection_id and $password. $connection_id and $password can be generated at
     *   https://www.smslink.ro/sms/gateway/setup.php after authenticated with your account credentials.
     *
     *   @param string    $connection_id     SMSLink - SMS Gateway - Connection ID
     *   @param string    $password          SMSLink - SMS Gateway - Password
     *   @param bool      $testMode          SMSLink - SMS Gateway - Test Mode (true or false)
     *
     *   @return void
     */
    
public function __construct($connection_id$password$testMode false)
    {
        if (!
is_null($connection_id))
            
$this->connection_id $connection_id;
    
        if (!
is_null($password))
            
$this->password $password;
         
        if ((
$testMode == true) or ($testMode == false))
            
$this->testMode $testMode;
        
        if ((
is_null($this->connection_id)) or (is_null($this->password)))
            exit(
"SMS Gateway initialization failed, credentials not provided. Please see documentation.");
    
    }
    
    public function 
__destruct()
    {
        
$this->connection_id null;
        
$this->password null;
    
        
$this->doHTTPS true;        
    }

    
/**
     *   Sets the compression method to be used during sending
     *
     *   @param int    $compressionMethod    the following values are accepted:
     *   
     *                                          0 for No Compression (default)
     *                                          1 for Zlib Gzip (requires PHP to be compiled --with-zlib[=DIR])
     *                                          2 for bzip2     (requires PHP to be compiled --with-bz2[=DIR])
     *                                          3 for LZF       (requires PHP to be compiled --with-lzf[=DIR])
     *
     *   @return bool     true if method was set or false otherwise
     */
    
public function setCompression($compressionMethod)
    {
        if (
$this->packageStatus == 0)
        {
            if (
array_key_exists($compressionMethod$this->compressionMethods))
                
$this->compressionMethod $compressionMethod;
            
            return 
true;               
        }
        
        return 
false;        
    }
    
    private function 
applyCompression($contentPlain)
    {
        
$contentCompressed "";

        switch (
$this->compressionMethod
        {
            case 
0:
                
$contentCompressed $contentPlain;
                break;
            case 
1:
                
$contentCompressed gzcompress($contentPlain9);
                break;
            case 
2:
                
$contentCompressed bzcompress($contentPlain9);
                break;
            case 
3:
                
$contentCompressed lzf_compress($contentPlain);
                break;
        }
        
        return 
$contentCompressed;        
    }    

    private function 
microtimeFloat()
    {
        list(
$usec$sec) = explode(" "microtime());
        return ((float)
$usec + (float)$sec);
    }
    
    
/**
     *   Sets the protocol that will be used by SMS Gateway (HTTPS or HTTP).
     *
     *   @param string    $methodName     POST or GET
     *
     *   @return bool     true if method was set or false otherwise
     */
    
public function setProtocol($protocolName "HTTPS")
    {
        
$protocolName strtoupper($protocolName);
    
        if (
$protocolName == "HTTPS"$this->doHTTPS true;
            elseif (
$protocolName == "HTTP"$this->doHTTPS false;
            else return 
false;
    
        return 
true;
    }
    
    
/**
     *   Returns the protocol that is used by SMS Gateway (HTTPS or HTTP)
     *
     *   @return string     GET or POST possible values
     */
    
public function getProtocol()
    {
        return (
$this->doHTTPS) ? "HTTPS" "HTTP";
    }
    
    private function 
structureCharactersEncode($messageText)
    {
        
$messageText str_replace("\n""%0A"$messageText);
        
$messageText str_replace(";",  "%3B"$messageText);
        
        return 
$messageText;
    }
    
    private function 
cleanCharacters($messageText)
    {
        
$messageText str_replace("\t"""$messageText); // Tab
        
$messageText str_replace("\r"""$messageText); // Carriage Return
        
        
return $messageText;
    }
    
    
/**
     *   Inserts a SMS to SMS Bulk Package
     *
     *   @param int       $localMessageId           Local Message ID from Your System
     *   
     *   @param string    $receiverNumber           Receiver mobile phone number. Phone numbers should be formatted as a Romanian national mobile phone number (07xyzzzzzz).
     *
     *   @param string    $senderId                 (Optional) Sender alphanumeric string:
     *
     *                                                 numeric    - sending will be done with a shortcode (ex. 18xy, 17xy)
     *                                                 SMSLink.ro - sending will be done with SMSLink.ro (use this for tests only)
     *
     *                                                 Any other preapproved alphanumeric sender assigned to your account:
     *
     *                                                     Your alphanumeric sender list:        
     *                                                             http://www.smslink.ro/sms/sender-list.php
     *
     *                                                     Your alphanumeric sender application: 
     *                                                             http://www.smslink.ro/sms/sender-id.php
     *
     *                                                 Please Note:
     *
     *                                                 SMSLink.ro sender should be used only for testing and is not recommended to be used in production. Instead, you
     *                                                 should use numeric sender or your alphanumeric sender, if you have an alphanumeric sender activated with us.
     *
     *                                                 If you set an alphanumeric sender for a mobile number that is in a network where the alphanumeric sender has not
     *                                                 been activated, the system will override that setting with numeric sender.
     *
     *   @param string    $messageText              Message of the SMS, up to 160 alphanumeric characters.
     *
     *   @param int       $timestampProgrammed    (Optional) Should be 0 (zero) for immediate sending or other UNIX timestamp in the future for future sending
     *
     *   @return bool     true on success or false on failure     
     */    
    
public function insertMessage($localMessageId$receiverNumber$senderId$messageText$timestampProgrammed 0)
    {
        if (!
is_numeric($localMessageId))
            return 
false;
            
        
$receiverNumber str_replace("+""00"$receiverNumber);       // Converts + to 00
        
$receiverNumber preg_replace("/[^0-9]/"""$receiverNumber); // Remove all non-numeric characters
        
        
if (!is_numeric($receiverNumber))
            return 
false;
            
        
$messageText trim($messageText);                               // Strip whitespace from the beginning and end of the message
        
$messageText str_replace("\r\n""\n"$messageText);          // Converts Carriage Return + Line Feed to Line Feed        
        
$messageText $this->structureCharactersEncode($messageText);   // Encode structure characters
        
$messageText $this->cleanCharacters($messageText);             // Clean unsuported characters                
        
        
$this->packageContents[] = array(
                
"localMessageId"      => $localMessageId,
                
"receiverNumber"      => $receiverNumber,
                
"senderId"            => $senderId,
                
"messageText"         => $messageText,
                
"timestampProgrammed" => $timestampProgrammed
            
);
            
        return 
true;            
    }

    
/**
     *   Removes a SMS from SMS Bulk Package
     *
     *   @param int       $localMessageId           Local Message ID from Your System
     *   
     *   @return void     
     */
    
public function removeMessage($localMessageId)
    {
        foreach (
$this->packageContents as $messageKey => $messageData)
            if (
$messageData["localMessageId"] == $localMessageId)
                unset(
$this->packageContents[$messageKey]);                
    }
    
    
/**
     *   Returns the Size of the SMS Bulk Package
     *   
     *   @return int
     */
    
public function packageSize()
    {
        return 
sizeof($this->packageContents);        
    }
    
    
/**
     *   Sends the SMS Bulk Package to SMSLink
     *
     *   @return bool     true on success or false on failure
     */
    
public function sendPackage()
    {
        
$timestampStart $this->microtimeFloat();
        
        
$this->remoteMessageIDs = array();
        
$this->errorMessage "";
        
        if ((
$this->packageStatus == 0) and ($this->packageSize() > 0))
        {
            
$temporaryFile = array();
            foreach (
$this->packageContents as $messageKey => $messageData)
                
$temporaryFile[] = implode(";"$messageData);

            
$this->packageFile["contentPlain"] = implode("\r\n"$temporaryFile);
            
$this->packageValidation["hashMD5"]["contentPlain"] = md5($this->packageFile["contentPlain"]);
            
            
$this->packageFile["contentCompressed"] = $this->applyCompression($this->packageFile["contentPlain"]);
            
$this->packageValidation["hashMD5"]["contentCompressed"] = md5($this->packageFile["contentCompressed"]);
            
            
$temporaryFilename tempnam($this->temporaryDirectory"sms-package-");
            
            if (
$temporaryFilename != false)
            {
                
file_put_contents($temporaryFilename$this->packageFile["contentCompressed"]);
                
                
$requestData = array(
                        
"connection_id"  => $this->connection_id,
                        
"password"       => $this->password,
                        
"test"           => ($this->testMode == true) ? 0,
                        
"Compression"    => $this->compressionMethod,
                        
"MD5Plain"       => $this->packageValidation["hashMD5"]["contentPlain"],
                        
"MD5Compressed"  => $this->packageValidation["hashMD5"]["contentCompressed"],
                        
"SizePlain"      => strlen($this->packageFile["contentPlain"]),
                        
"SizeCompressed" => strlen($this->packageFile["contentCompressed"]),
                        
"Timestamp"      => date("U"),
                        
"Buffering"      => 1,
                        
"Version"        => $this->clientVersion,                        
                        
"Receivers"      => $this->packageSize(),
                        
"Package"        => "@".$temporaryFilename
                    
);
                    
                
$ch curl_init((($this->doHTTPS == true) ? $this->endpointHTTPS $this->endpointHTTP)."?timestamp=".date("U"));

                
curl_setopt($chCURLOPT_POST1);

                if ((
version_compare(PHP_VERSION'5.5') >= 0)) 
                {
                    
$requestData["Package"] = new CURLFile($temporaryFilename);
                    
curl_setopt($chCURLOPT_SAFE_UPLOADtrue);
                }

                
curl_setopt($chCURLOPT_POSTFIELDS$requestData);
                
curl_setopt($chCURLOPT_FOLLOWLOCATION1);
                
curl_setopt($chCURLOPT_HEADER0);
                
curl_setopt($chCURLOPT_RETURNTRANSFER1);
                
                
curl_setopt($chCURLOPT_CONNECTTIMEOUT0);
                
curl_setopt($chCURLOPT_TIMEOUT0);
                                
                if (
$this->doHTTPS == true)
                {
                    
curl_setopt($chCURLOPT_SSL_VERIFYPEERfalse);
                    
curl_setopt($chCURLOPT_SSL_VERIFYHOSTfalse);
                }

                
$requestResponse curl_exec($ch);
                
                
$connectionErrorCode    curl_errno($ch);
                
$connectionErrorMessage curl_error($ch);
                
$requestStatusCode      curl_getinfo($chCURLINFO_HTTP_CODE);
                
                if (
$connectionErrorCode == 0)
                {
                    if ((
$requestStatusCode >= 200) and ($requestStatusCode <= 299))
                    {
                        
$requestResponse explode(";"$requestResponse);                 
                
                        if ((
is_array($requestResponse)) and (sizeof($requestResponse) >= 3))
                        {
                            if (
$requestResponse[0] == "MESSAGE")
                            {                                                                            
                                
$messagesAssoc explode(","$requestResponse[3]);
                                
                                for(
$i 0$i sizeof($messagesAssoc); $i++)
                                {
                                    
$temporaryMessageData explode(":"$messagesAssoc[$i]);
                                    
                                    
$this->remoteMessageIDs[$temporaryMessageData[0]] = array(
                                            
"localMessageId"  => $temporaryMessageData[0],
                                            
"remoteMessageId" => $temporaryMessageData[1],
                                            
"messageStatus"   => $temporaryMessageData[2]
                                        );
                                }
                                
                                
$this->packageStatus 1;
                                
                                
$timestampEnd $this->microtimeFloat();
                                
$this->transactionTime round($timestampEnd $timestampStart2);
                                
                                return 
true;                    
                            }
                            else 
                            {
                                
$this->errorMessage implode(";"$requestResponse);                        
                            }
                        }
                        else
                        {
                            
$this->errorMessage "ERROR;0;Unexpected response format";
                        }                        
                    }
                    else
                    {
                        
$this->errorMessage "ERROR;0;Unexpected HTTP code ".$requestStatusCode;
                    }
                }
                else
                {
                    
$this->errorMessage "ERROR;0;".$connectionErrorMessage;
                }
                
                
curl_close($ch);
            }            
        }
        
        return 
false;        
    }    
}

/**
 *
 *
 *     Usage Examples for the SMSLinkSMSGatewayBulkPackage() class
 *
 *
 *
 */

/*
 *
 *
 *     Initialize SMS Gateway Bulk Package
 *
 *       Get your SMSLink / SMS Gateway Connection ID and Password from
 *       https://www.smslink.ro/get-api-key/
 *
 *
 *
 */
$BulkSMSPackage = new SMSLinkSMSGatewayBulkPackage("MyConnectionID""MyConnectionPassword");

/*
 * 
 *    Insert Messages to SMS Package
 *    
 */
$BulkSMSPackage->insertMessage(1"07xyzzzzzz""numeric""Test 1");
$BulkSMSPackage->insertMessage(2"07xyzzzzzz""numeric""Test 2");
$BulkSMSPackage->insertMessage(3"07xyzzzzzz""numeric""Test 3");
$BulkSMSPackage->insertMessage(4"07xyzzzzzz""numeric""Test 4");
$BulkSMSPackage->insertMessage(5"07xyzzzzzz""numeric""Test 5");

/*
 * 
 *    Send SMS Package to SMSLink
 *    
 */
$BulkSMSPackage->sendPackage();

/*
 * 
 *    Process Result
 *    
 */
$statusCounters = array();

if (
sizeof($BulkSMSPackage->remoteMessageIDs) > 0)
{
    foreach (
$BulkSMSPackage->remoteMessageIDs as $key => $value)
    {
        switch (
$value["messageStatus"])
        {
            
/**
             * 
             * 
             *     Message Status:     1 
             *     Status Description: Sender Failed
             *     
             *     
             */            
            
case 1:
                
$timestamp_send = -1;
                
                
/* 
                
                    .. do something .. 
                    for example check the sender because is incorrect
                    
                */
                
                
echo "Error for Local Message ID: ".$value["localMessageId"]." (Sender Failed).<br />";
                
                
$statusCounters["failedSenderCounter"]++;
                
                break;
            
/**
             * 
             * 
             *     Message Status:     2 
             *     Status Description: Number Failed
             *     
             *     
             */                                   
            
case 2:
                
$timestamp_send = -2;
                
                
/* 
                
                    .. do something .. 
                    for example check the number because is incorrect    
                    
                */
                
                
echo "Error for Local Message ID: ".$value["localMessageId"]." (Incorrect Number).<br />";
                
                
$statusCounters["failedNumberCounter"]++;
                
                break;
            
/**
             * 
             * 
             *     Message Status:     3
             *     Status Description: Success
             *     
             *     
             */            
            
case 3:
                
$timestamp_send date("U");
                
/* 
                
                    .. do something .. 

                    Save in database the Remote Message ID, sent in variabile: $value["RemoteMessageID"].
                    Delivery  reports will  identify  your SMS  using our Message ID. Data type  for the 
                    variabile should be considered to be hundred milions (example: 220000000)                    
                    
                */
                
                
echo "Succes for Local Message ID: ".
                     
$value["localMessageId"].
                     
", Remote Message ID: ".
                     
$value["remoteMessageId"].
                     
"<br />";
                
                
$statusCounters["successCounter"]++;
                
                break;
            
/**
             * 
             * 
             *     Message Status:     4 
             *     Status Description: Internal Error or Number Blacklisted
             *     
             *     
             */                            
            
case 4:
                
$timestamp_send = -4;
                
                
/* 
                
                    .. do something .. 
                    for example try again later

                    Internal Error may occur in the following circumstances:

                    (1) Number is Blacklisted (please check the Blacklist associated to your account), or
                    (2) An error occured at SMSLink (our technical support team is automatically notified)
                    
                */
                
                
echo "Error for Local Message ID: ".$value["localMessageId"]." (Internal Error or Number Blacklisted).<br />";
                
                
$statusCounters["failedInternalCounter"]++;
                
                break;
            
/**
             * 
             * 
             *     Message Status:     5 
             *     Status Description: Insufficient Credit
             *     
             *     
             */            
            
case 5:
                
$timestamp_send = -5;
                
                
/* 
                
                    .. do something .. 
                    for example top-up the account
                    
                */
            
                
echo "Error for Local Message ID: ".$value["localMessageId"]." (Insufficient Credit).<br />";
            
                
$statusCounters["failedInsufficientCredit"]++;
            
                break;
        }
        
        
$statusCounters["totalCounter"]++;
        
    }
        
}
else
{
    echo 
"Error Transmitting Package to SMSLink: ".$BulkSMSPackage->errorMessage."<br />";
    
}

?>
Acest site foloseşte cookies. Continuarea navigării pe acest site reprezintă acordul dumneavoastră pentru folosirea cookie-urilor. Aflaţi mai multe sau Inchideţi notificarea