src/Services/Communication/SmsProviderTools.php line 42

Open in your IDE?
  1. <?php
  2. //----------------------------------------------------------------------
  3. // src/Services/Communication/SmsProviderTools.php
  4. //----------------------------------------------------------------------
  5. namespace App\Services\Communication;
  7. use Doctrine\Persistence\ManagerRegistry;
  8. use Symfony\Component\Routing\RouterInterface;
  9. use Twilio\Rest\Client as TwilioClient;
  10. use Twilio\Exceptions\TwilioException;
  12. use App\Entity\SocietyGroup;
  13. use App\Entity\Communication\Sms\Sms;
  14. use App\Entity\Communication\Sms\SmsPhoneNumber;
  15. use App\Entity\Communication\Sms\SmsStatus;
  16. use App\Entity\Communication\SmsProviders\SmsProvider;
  17. use App\Entity\Communication\SmsProviders\SmsMode;
  18. use App\Entity\Communication\SmsProviders\SmsModeStatus;
  19. use App\Entity\Communication\SmsProviders\SmsTwilio;
  20. use App\Entity\Communication\SmsProviders\SmsTwilioStatus;
  21. use App\Entity\Config\Config;
  22. use App\Services\LogTools;
  23. use App\Services\Platform\ExternalMessageTools;
  24. use App\Services\Security\PasswordTools;
  26. /**
  27.  * For now all this code works under the assumption that only one SmsProvider is active.
  28.  *
  29.  * Naming conventions :
  30.  *         $smsProvider can be an object of type
  31.  *            SmsProvider::SmsMode
  32.  *            SmsProvider::SmsTwilio
  33.  *        $sms is an object of type Sms::Sms
  34.  *
  35.  * Error logging should be done with both errorlog and smsLogDebug
  36.  *         $msg = "my amazing and unexpected error";
  37.  *         $this->logTools->errorlog($msg);
  38.  *         $this->logTools->smsLogDebug($msg, $activeSmsProvider);
  39.  */
  40. class SmsProviderTools
  41. {
  42.     public function __construct(ManagerRegistry $doctrine, LogTools $logTools, PasswordTools $passwordTools, RouterInterface $router, ExternalMessageTools $externalMessageTools, string $smsModeAPIKey)
  43.     {
  44.         $this->em = $doctrine->getManager();
  45.         $this->logTools = $logTools;
  46.         $this->passwordTools = $passwordTools;
  47.         $this->externalMessageTools = $externalMessageTools;
  48.         $this->router = $router;
  49.         $this->smsModeAPIKey = $smsModeAPIKey;
  51.         $this->debug = true;
  52.     }
  54.     /**
  55.      * Is SmsMode the currently active SmsProvider ?
  56.      *
  57.      * @return boolean
  58.      */
  59.     public function isActiveSmsMode()
  60.     {
  61.         // Get the active SmsProvider
  62.         $activeSmsProvider = $this->em->getRepository(SmsProvider::class)->findOneBy(array(
  63.             'isActive'        =>    1,
  64.         ));
  66.         // Get the active SmsProvider
  67.         if ($activeSmsProvider === null)
  68.         {
  69.             return false;
  70.         }
  71.         return $activeSmsProvider->isSmsMode();
  72.     }
  74.     /**
  75.      * Is Twilio the currently active SmsProvider ?
  76.      *
  77.      * @return boolean
  78.      */
  79.     public function isActiveSmsTwilio()
  80.     {
  81.         // Get the active SmsProvider
  82.         $activeSmsProvider = $this->em->getRepository(SmsProvider::class)->findOneBy(array(
  83.             'isActive'        =>    1,
  84.         ));
  86.         // Get the active SmsProvider
  87.         if ($activeSmsProvider === null)
  88.         {
  89.             return false;
  90.         }
  91.         return $activeSmsProvider->isSmsTwilio();
  92.     }
  94.     /**
  95.      * Get the currently active SmsProvider
  96.      * Note : Only one SmsProvider should be active
  97.      *
  98.      * @return null|SmsProvider
  99.      */
  100.     public function getActiveSmsProvider()
  101.     {
  102.         // Get the active SmsProvider
  103.         $activeSmsProvider = $this->em->getRepository(SmsProvider::class)->findOneBy(array(
  104.             'isActive'        =>    1,
  105.         ));
  106.         return $activeSmsProvider;
  107.     }
  109.     /**
  110.      * Returns the default SmsStatus depending on the active SmsProvider
  111.      * Note : Only one SmsProvider should be active
  112.      *
  113.      * @return null|SmsStatus
  114.      */
  115.     public function getDefaultSmsStatus()
  116.     {
  117.         // Get the active SmsProvider
  118.         $activeSmsProvider = $this->em->getRepository(SmsProvider::class)->findOneBy(array(
  119.             'isActive'        =>    1,
  120.         ));
  122.         // Get the active SmsProvider
  123.         $provider = $activeSmsProvider;
  124.         if ($provider === null)
  125.         {
  126.             $msg = "No active SmsProvider";
  127.             $this->logTools->errorlog($msg);
  128.             $this->logTools->smsLogDebug($msg);
  129.             return null;
  130.         }
  132.         $this->logTools->sms_debug($this->debug, "[SmsProviderTools :: getDefaultSmsStatus] Active provider is ".$provider->displayForLog());
  134.         // Get the DefaultStatus for the active SmsProvider
  135.         $providerStatus = null;
  136.         switch ($provider->getName())
  137.         {
  138.             case SmsProvider::CODE_TWILIOSMS:
  139.                 $providerStatus = $this->em->getRepository(SmsTwilioStatus::class)->findOneBy(array(
  140.                     'defaultValue'        =>    1,
  141.                 ));
  142.             break;
  144.             case SmsProvider::CODE_SMSMODE:
  145.                 $providerStatus = $this->em->getRepository(SmsModeStatus::class)->findOneBy(array(
  146.                     'defaultValue'        =>    1,
  147.                 ));
  148.             break;
  149.         }
  151.         if ($providerStatus === null)
  152.         {
  153.             $msg = "No default status for the currently active SmsProvider";
  154.             $this->logTools->errorlog($msg);
  155.             $this->logTools->smsLogDebug($msg, $activeSmsProvider);
  156.             return null;
  157.         }
  159.         // Based on the code of the SmsProvider's status, get the corresponding SmsStatus
  160.         $code = $providerStatus->getCode();
  161.         $status = $this->em->getRepository(SmsStatus::class)->findOneByCode($code);
  163.         if ($status === null)
  164.         {
  165.             $msg = "No SmsStatus found for code ".$code;
  166.             $this->logTools->errorlog($msg);
  167.             $this->logTools->smsLogDebug($msg, $activeSmsProvider);
  168.             return null;
  169.         }
  171.         $this->logTools->sms_debug($this->debug, "[SmsProviderTools :: getDefaultSmsStatus] SmsProvider.DefaultStatus : ".$providerStatus->displayForLog());
  172.         $this->logTools->sms_debug($this->debug, "[SmsProviderTools :: getDefaultSmsStatus] SmsStatus : ".$status->displayForLog());
  174.         return $status;
  175.     }
  177.     /**
  178.      * Creates an object of type SmsTwilio or SmsMode
  179.      * depending on the active SmsProvider
  180.      * Note : Only one SmsProvider should be active
  181.      *
  182.      * @see \App\Entity\Communication\SmsProviders\SmsProvider for the documentation of the SMSProvider
  183.      *
  184.      * @uses \App\Services\Communication\SmsProviderTools::craftSmsTwilioProvider() to craft the SmsProvider depending on the active SmsProvider
  185.      * @uses \App\Services\Communication\SmsProviderTools::craftSmsModeProvider() to craft the SmsProvider depending on the active SmsProvider
  186.      *
  187.      * @param  Sms $sms
  188.      * @return null|(SmsTwilio|SmsMode)
  189.      */
  190.     public function craftSmsProvider(Sms $sms)
  191.     {
  192.         // Get the active SmsProvider
  193.         $activeSmsProvider = $this->em->getRepository(SmsProvider::class)->findOneBy(array(
  194.             'isActive'        =>    1,
  195.         ));
  197.         // Get the active SmsProvider
  198.         $provider = $activeSmsProvider;
  199.         if ($provider === null)
  200.         {
  201.             $msg = "No active SmsProvider";
  202.             $this->logTools->errorlog($msg);
  203.             $this->logTools->smsLogDebug($msg);
  204.             return null;
  205.         }
  207.         $this->logTools->sms_debug($this->debug, "[SmsProviderTools :: craftSmsProvider] Active provider is ".$provider->displayForLog());
  209.         // Get the DefaultStatus for the active SmsProvider
  210.         $smsProvider = null;
  211.         switch ($provider->getName())
  212.         {
  213.             case SmsProvider::CODE_TWILIOSMS:
  214.                 $smsProvider = $this->craftSmsTwilioProvider($sms);
  215.             break;
  217.             case SmsProvider::CODE_SMSMODE:
  218.                 $smsProvider = $this->craftSmsModeProvider($sms);
  219.             break;
  220.         }
  222.         return $smsProvider;
  223.     }
  225.     /**
  226.      * Creates an object of type SmsTwilio
  227.      *
  228.      * @param  Sms $sms
  229.      * @return null|SmsTwilio
  230.      */
  231.     private function craftSmsTwilioProvider(Sms $sms)
  232.     {
  233.         $smsProvider = new SmsTwilio();
  235.         // Generate CODE for url callback
  236.         $code = $this->passwordTools->generateUniqId();
  237.         $smsProvider->setCode($code);
  239.         $smsProvider->setClient($sms->getClient());
  240.         $smsProvider->setHumanResource($sms->getHumanResource());
  241.         $smsProvider->setAuthor($sms->getAuthor());
  242.         $smsProvider->setEmitter($sms->getEmitter());
  243.         $smsProvider->setRecipient($sms->getRecipient());
  244.         $smsProvider->setSociety($sms->getSociety());
  245.         $smsProvider->setSocietyGroup($sms->getSocietyGroup());
  247.         $smsProvider->setSubject($sms->getSubject());
  248.         $smsProvider->setBody($sms->getBody());
  250.         $status = $this->em->getRepository(SmsTwilioStatus::class)->findOneByCode($sms->getStatus()->getCode());
  251.         $smsProvider->setStatus($status);
  253.         // Link the two objects
  254.         $smsProvider->setSms($sms);
  256.         $this->em->persist($smsProvider);
  258.         $this->logTools->sms_debug($this->debug, "[SmsProviderTools :: craftSmsTwilioProvider] New SmsTwilio object created");
  260.         return $smsProvider;
  261.     }
  263.     /**
  264.      * Creates an object of type SmsMode
  265.      *
  266.      * @param  Sms $sms
  267.      * @return null|SmsTwilio
  268.      */
  269.     private function craftSmsModeProvider(Sms $sms)
  270.     {
  271.         $smsProvider = new SmsMode();
  273.         $smsProvider->setClient($sms->getClient());
  274.         $smsProvider->setHumanResource($sms->getHumanResource());
  275.         $smsProvider->setAuthor($sms->getAuthor());
  276.         $smsProvider->setEmitter($sms->getEmitter());
  277.         $smsProvider->setRecipient($sms->getRecipient());
  278.         $smsProvider->setSociety($sms->getSociety());
  279.         $smsProvider->setSocietyGroup($sms->getSocietyGroup());
  281.         $smsProvider->setSubject($sms->getSubject());
  282.         $smsProvider->setBody($sms->getBody());
  284.         $status = $this->em->getRepository(SmsModeStatus::class)->findOneByCode($sms->getStatus()->getCode());
  285.         $smsProvider->setStatus($status);
  287.         // Link the two objects
  288.         $smsProvider->setSms($sms);
  290.         $this->em->persist($smsProvider);
  292.         $this->logTools->sms_debug($this->debug, "[SmsProviderTools :: craftSmsModeProvider] New SmsMode object created");
  294.         return $smsProvider;
  295.     }
  297.     /**
  298.      * Sends a sms using the active SmsProvider
  299.      * Note : Only one SmsProvider should be active
  300.      *
  301.      * @uses \App\Services\Communication\SmsProviderTools::sendSmsTwilio() depending on the active SmsProvider
  302.      * @uses \App\Services\Communication\SmsProviderTools::sendSmsMode() depending on the active SmsProvider
  303.      *
  304.      * @param  SmsTwilio|SmsMode $smsProvider
  305.      * @param  string $callbackUrl
  306.      * @return true|false
  307.      */
  308.     public function sendSms($smsProvider)
  309.     {
  310.         if ($smsProvider instanceof SmsTwilio)
  311.         {
  312.             return $this->sendSmsTwilio($smsProvider);
  313.         }
  314.         if ($smsProvider instanceof SmsMode)
  315.         {
  316.             return $this->sendSmsMode($smsProvider);
  317.         }
  318.         return null;
  319.     }
  321.     /**
  322.      * Sends a sms using SmsTwilio
  323.      *
  324.      *
  325.      * @param  SmsTwilio $smsProvider
  326.      * @param  string $callbackUrl
  327.      * @return true|false
  328.      */
  329.     private function sendSmsTwilio($smsProvider)
  330.     {
  331.         // Get the active SmsProvider
  332.         $activeSmsProvider = $this->em->getRepository(SmsProvider::class)->findOneBy(array(
  333.             'isActive'        =>    1,
  334.         ));
  336.         $configRepository = $this->em->getRepository(Config::class);
  338.         $twilioId    = $configRepository->findOneByName(Config::TWILIO_SMS_ACCOUNT_ID);
  339.         $twilioToken = $configRepository->findOneByName(Config::TWILIO_SMS_AUTH_TOKEN);
  340.         $code = $smsProvider->getCode();
  341.         $body = $smsProvider->getBody();
  342.         $to   = $smsProvider->getRecipient();
  343.         $from = $smsProvider->getEmitter();
  345.         if (in_array(null, [$twilioId, $twilioToken, $code, $body, $to, $from]))
  346.         {
  347.             return false;
  348.         }
  350.         $urlConfig = $configRepository->findOneByName(Config::URL);
  351.         if ($urlConfig === null)
  352.         {
  353.             $msg = "Config::URL not found";
  354.             $this->logTools->errorlog($msg);
  355.             $this->logTools->smsLogDebug($msg, $activeSmsProvider);
  356.             return false;
  357.         }
  359.         $callbackUrl = $urlConfig->getValue() . $this->router->generate('icod_twilio_sms_callback', array('id' => $code));
  361.         $twilioClient = new TwilioClient($twilioId->getValue(), $twilioToken->getValue());
  362.         try
  363.         {
  364.             $message = $twilioClient->messages->create($to,    array(
  365.                 'from'                 => $from,
  366.                 'body'                 => $body,
  367.                 'statusCallback'     => $callbackUrl,
  368.             ));
  369.         }
  370.         catch (TwilioException $e)
  371.         {
  372.             $msg = $e->getMessage();
  373.             $this->logTools->errorlog($msg);
  374.             $this->logTools->smsLogDebug($msg, $activeSmsProvider);
  376.             return false;
  377.         }
  379.         $twilioSid = $message->sid;
  380.         $numberSegment = $message->numSegments;
  382.         if ($twilioSid !== null)
  383.         {
  384.             $smsProvider->setTwilioSid($twilioSid);
  385.         }
  387.         if ($numberSegment !== null)
  388.         {
  389.             $smsProvider->setTwilioNumberSegment($numberSegment);
  390.             $smsProvider->getSms()->setNumberSegment($numberSegment);
  391.         }
  393.         $this->logTools->sms_debug($this->debug, "[SmsProviderTools :: sendSmsTwilio] SmsTwilio sent ".$smsProvider->displayForLog());
  395.         return true;
  396.     }
  398.     /**
  399.      * Sends a sms using SmsMode
  400.      *
  401.      * @param  SmsMode $smsProvider
  402.      * @param  string $callbackUrl
  403.      * @return true|false
  404.      */
  405.     private function sendSmsMode($smsProvider, $sentDate = null)
  406.     {
  407.         // Get the active SmsProvider
  408.         $activeSmsProvider = $this->em->getRepository(SmsProvider::class)->findOneBy(array(
  409.             'isActive'        =>    1,
  410.         ));
  412.         // Get required params
  413.         $body = $smsProvider->getBody();
  414.         $to = $smsProvider->getRecipient();
  415.         $from = $smsProvider->getEmitter();
  416.         $societyGroup = $smsProvider->getSocietyGroup();
  418.         if (in_array(null, [$body, $to, $from, $societyGroup]))
  419.         {
  420.             return false;
  421.         }
  423.         $configRepository = $this->em->getRepository(Config::class);
  425.         // Get the SmsMode Api URL
  426.         $url = $configRepository->findOneByName(Config::SMS_MODE_URL);
  427.         if ($url === null)
  428.         {
  429.             $msg = "Config::SMS_MODE_URL not found";
  430.             $this->logTools->errorlog($msg);
  431.             $this->logTools->smsLogDebug($msg, $activeSmsProvider);
  432.             return false;
  433.         }
  434.         $url = $url->getValue();
  436.         // Get the Platform URL, used to craft callback url
  437.         $urlConfig = $configRepository->findOneByName(Config::URL);
  438.         if ($urlConfig === null)
  439.         {
  440.             $msg = "Config::URL not found";
  441.             $this->logTools->errorlog($msg);
  442.             $this->logTools->smsLogDebug($msg, $activeSmsProvider);
  443.             return false;
  444.         }
  445.         $urlConfig = $urlConfig->getValue();
  446.         // Craft callback urls
  447.         $callbackUrl = $urlConfig . $this->router->generate('icod_smsmode_sms_callback');
  448.         $callbackUrlResponse = $urlConfig . $this->router->generate('icod_smsmode_sms_response');
  450.         // Get the senderDisplay for the given SocietyGroup
  451.         $senderDisplay = $this->getSmsModeSenderDisplay($societyGroup);
  453.         // Detect Encoding SMSMode
  454.         $encoding = $this->detectEncodingSmsMode($body);
  456.         // Curl json bod
  457.         $curlPostBody =    array(
  458.                 "recipient" => array("to" => $to), // e.164 format
  459.                 //"from" => "36034", // https://ui.smsmode.com/settings/senders default sender is used if not specified here
  460.                 "from" => $senderDisplay, // we can specify what we want here
  461.                 "body" => array(
  462.                     "text" => $body,
  463.                     "encoding" => $encoding // Encoding of the message GSM7 | UNICODE - Detected with detectEncodingSmsMode algo
  464.                 ),
  465.                 // "refClient" => "ref client : " . uniqid(),
  467.                 'callbackUrlStatus'    =>    $callbackUrl,
  468.                 'callbackUrlMo'    =>    $callbackUrlResponse,
  469.             );
  471.         // Encode the body array into Json to bes included in curl call
  472.         $curlPostBody = json_encode($curlPostBody);
  474.         // If no sent date provided, use now +30 secs. This gap can be used to unsend the SMS ?
  475.         // If it's not needed, just remove sentDate from $curlPostBody, the sms will be sent asap
  476.         if ($sentDate === null)
  477.         {
  478.             $sentDate = new \DateTime('NOW');
  479.             $sentDate->modify('+30 seconds');
  480.         }
  481.         // format provided sent date in ISO8601 without timezone
  482.         $sentDate = $sentDate->format('Y-m-d\TH:i:s');
  484.         // Disable for now
  485.         // $curlPostBody["sentDate"] = $sentDate;
  487.         $ch = curl_init();
  489.         curl_setopt($ch, CURLOPT_URL, $url);
  490.         curl_setopt($ch, CURLOPT_POSTFIELDS, $curlPostBody);
  491.         curl_setopt($ch, CURLOPT_HTTPHEADER, array(
  492.             "X-Api-Key: " . $this->smsModeAPIKey,
  493.             "Accept: application/json",
  494.             "content-Type: application/json"
  495.         ));
  496.         curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
  497.         curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  498.         $curlResult = curl_exec($ch);
  499.         if (curl_errno($ch))
  500.         {
  501.             $msg = "curl_exec.error ".curl_error($ch);
  502.             $this->logTools->errorlog($msg);
  503.             $this->logTools->smsLogDebug($msg, $activeSmsProvider);
  504.             return false;
  505.         }
  507.         $result = json_decode($curlResult);
  509.         if (!$result)
  510.         {
  511.             $msg = "JSON decode failed";
  512.             $this->logTools->errorlog($msg);
  513.             $this->logTools->smsLogDebug($msg, $activeSmsProvider);
  514.             return false;
  515.         }
  517.         // Task plan.io #4013
  518.         // If Success, smsMode return 201 else 4xx/5xx
  519.         // Doc : https://dev.smsmode.com/sms/v1/message
  520.         $codeReturned = curl_getinfo($ch, CURLINFO_HTTP_CODE);
  521.         if ($codeReturned != 201)
  522.         {
  523.             $errorMessage = $result?->message . " - " . $result?->detail;
  524.             $this->logTools->errorlog($errorMessage);
  525.             $this->logTools->smsLogDebug($errorMessage, $activeSmsProvider);
  526.             return false;
  527.         }
  529.         $messageId = $result?->messageId;
  530.         $acceptedAt = $result?->acceptedAt;
  531.         $sentTo = $result?->recipient?->to;
  532.         $from = $result?->from;
  533.         $encoding = $result?->body?->encoding;
  534.         $messagePartCount = $result?->body?->messagePartCount;
  535.         $statusValue = $result?->status?->value;
  536.         $statusDeliveryDate= $result?->status?->deliveryDate;
  537.         $rawJson = $curlResult;
  539.         $smsProvider->setRawData($curlResult);
  540.         if (!empty($messageId))
  541.         {
  542.             $smsProvider->setMessageId($messageId);
  543.         }
  544.         if (!empty($messagePartCount))
  545.         {
  546.             $smsProvider->setMessagePartCount($messagePartCount);
  547.             $smsProvider->getSms()->setNumberSegment($messagePartCount);
  548.         }
  550.         $this->logTools->sms_debug($this->debug, "[SmsProviderTools :: sendSmsMode] SmsMode sent ".$smsProvider->displayForLog());
  552.         return true;
  553.     }
  555.     /**
  556.      * @param  SocietyGroup $societyGroup
  557.      * @return string
  558.      */
  559.     public function getSmsModeSenderDisplay(SocietyGroup $societyGroup)
  560.     {
  561.         $defaultSenderDisplay = SmsMode::DEFAULT_SHORTCODE;
  562.         $senderDisplay = null;
  564.         $smsPhoneNumber = $this->em->getRepository(SmsPhoneNumber::class)->findOneBy(array(
  565.             'societyGroup'        =>    $societyGroup,
  566.         ));
  567.         if ($smsPhoneNumber !== null)
  568.         {
  569.             $senderDisplay = $smsPhoneNumber->getSenderDisplay();
  570.             if (!empty($senderDisplay))
  571.             {
  572.                 return $senderDisplay;
  573.             }
  574.         }
  575.         return $defaultSenderDisplay;
  576.     }
  578.     public function detectEncodingSmsMode(string $body)
  579.     {
  580.         $gsm7 = array(
  581.             "!", '"', "#", "$", "%", "&", "'", "(", ")", ")", ")", "*", "+", ",", "-",
  582.             ".", "/", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", ":", ";", "<",
  583.             "=", ">", "?", "@", "\r", "\n", " ", "A", "B", "C", "D", "E", "F", "G", "H",
  584.             "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
  585.             "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r",
  586.             "s", "t", "u", "v", "w", "x", "y", "z", "¡", "£", "¤", "Â¥", "§", "¿", "Ä", "Ã…", "Æ", "Ç",
  587.             "É", "Ñ", "Ö", "Ø", "Ãœ", "ß", "à", "ä", "Ã¥", "æ", "è", "é", "ì", "ñ", "ò", "ö", "ø", "ù",
  588.             "ü", "Γ", "Θ", "Λ", "Ξ", "Π", "Σ", "Φ", "Ψ", "Ω", "∆"
  589.         );
  590.         $gsm7Extended = array("€", "{", "|", "}", "~", "[", "]", "^", "\f");
  592.         $encoding = "GSM7";
  594.         foreach(mb_str_split($body) as $char)
  595.         {
  596.             if(!in_array($char, $gsm7) && !in_array($char, $gsm7Extended))
  597.             {
  598.                 $encoding = "UNICODE";
  599.                 break;
  600.             }
  601.         }
  603.         return $encoding;
  604.     }
  606.     /**
  607.      * Creates a SmsTwilioStatus|SmsModeStatus for a given value
  608.      * depending on the active SmsProvider
  609.      * Note : Only one SmsProvider should be active
  610.      *
  611.      * @uses \App\Services\Communication\SmsProviderTools::createSmsTwilioStatus() depending on the active SmsProvider
  612.      * @uses \App\Services\Communication\SmsProviderTools::createSmsModeStatus() depending on the active SmsProvider
  613.      *
  614.      * @param  SmsTwilio|SmsMode $smsProvider
  615.      * @param  string $value
  616.      * @return true|false
  617.      */
  618.     public function createSmsStatus($smsProvider, $value)
  619.     {
  620.         $smsProviderStatus = null;
  622.         if ($smsProvider instanceof SmsTwilio)
  623.         {
  624.             $smsProviderStatus = $this->createSmsTwilioStatus($value);
  625.         }
  626.         if ($smsProvider instanceof SmsMode)
  627.         {
  628.             $smsProviderStatus = $this->createSmsModeStatus($value);
  629.         }
  631.         if ($smsProviderStatus === null)
  632.         {
  633.             return null;
  634.         }
  636.         $status = new SmsStatus();
  637.         $status->setValue($value);
  638.         $status->setCode($smsProviderStatus->getCode());
  639.         $this->em->persist($status);
  641.         return array(
  642.             'smsStatus'                => $status,
  643.             'smsProviderStatus'        => $smsProviderStatus,
  644.         );
  645.     }
  647.     /**
  648.      * Creates a SmsTwilioStatus for a given value
  649.      * Can be called from outside of the service
  650.      *
  651.      * @param  string $value
  652.      * @return null|SmsTwilioStatus
  653.      */
  654.     private function createSmsTwilioStatus($value)
  655.     {
  656.         $lastCode = $this->em
  657.             ->getRepository(SmsTwilioStatus::class)
  658.             ->findOneBy(
  659.                 array(),
  660.                 array('code' => 'DESC')
  661.             );
  663.         $code = 1;
  665.         if ($lastCode !== null)
  666.         {
  667.             $code = $lastCode->getCode() + 1;
  668.         }
  670.         $status = new SmsTwilioStatus();
  671.         $status->setStatusTwilio($value);
  672.         $status->setValue($value);
  673.         $status->setCode($code);
  674.         $this->em->persist($status);
  676.         return $status;
  677.     }
  679.     /**
  680.      * Can be called from outside of the service
  681.      * Creates a SmsModeStatus for a given value
  682.      *
  683.      * @param  string $value
  684.      * @return null|SmsModeStatus
  685.      */
  686.     private function createSmsModeStatus($value)
  687.     {
  688.         $lastCode = $this->em
  689.             ->getRepository(SmsModeStatus::class)
  690.             ->findOneBy(
  691.                 array(),
  692.                 array('code' => 'DESC')
  693.             );
  695.         $code = 1;
  697.         if ($lastCode !== null)
  698.         {
  699.             $code = $lastCode->getCode() + 1;
  700.         }
  702.         $status = new SmsModeStatus();
  703.         $status->setStatusSmsMode($value);
  704.         $status->setValue($value);
  705.         $status->setCode($code);
  706.         $this->em->persist($status);
  708.         return $status;
  709.     }
  711.     /**
  712.      * Tries to find a SmsTwilioStatus|SmsModeStatus with the given value (statusValue)
  713.      * depending on the active SmsProvider.
  714.      * If the status is not found, one is created for the given value.
  715.      * In both cases, the corresponding SmsStatus is also returned.
  716.      * Note : Only one SmsProvider should be active
  717.      *
  718.      * @uses \App\Services\Communication\SmsProviderTools::handleSmsTwilioStatus() depending on the active SmsProvider
  719.      * @uses \App\Services\Communication\SmsProviderTools::handleSmsModeStatus() depending on the active SmsProvider
  720.      *
  721.      * @param  Sms $sms
  722.      * @param  string $value
  723.      * @return null|array
  724.      */
  725.     public function handleSmsStatus(Sms $sms, $statusValue)
  726.     {
  727.         $smsProvider = $sms->getProvider();
  728.         if ($smsProvider === null)
  729.         {
  730.             return null;
  731.         }
  733.         if ($smsProvider->isSmsTwilio())
  734.         {
  735.             return $this->handleSmsTwilioStatus($smsProvider, $statusValue);
  736.         }
  737.         if ($smsProvider->isSmsMode())
  738.         {
  739.             return $this->handleSmsModeStatus($smsProvider, $statusValue);
  740.         }
  742.         // if ($smsProvider instanceof SmsTwilio)
  743.         // {
  744.         //     return $this->handleSmsTwilioStatus($smsProvider, $statusValue);
  745.         // }
  746.         // if ($smsProvider instanceof SmsMode)
  747.         // {
  748.         //     return $this->handleSmsModeStatus($smsProvider, $statusValue);
  749.         // }
  750.         return null;
  751.     }
  753.     /**
  754.      * Tries to find a SmsTwilioStatus with the given value (statusValue).
  755.      * If the status is not found, one is created for the given value.
  756.      * In both cases, the corresponding SmsStatus is also returned.
  757.      *
  758.      * Can be called from outside of the service
  759.      *
  760.      * @param  SmsProvider $smsProvider
  761.      * @param  string $value
  762.      * @return null|array
  763.      */
  764.     public function handleSmsTwilioStatus(SmsProvider $smsProvider, $statusValue)
  765.     {
  766.         // Get the active SmsProvider
  767.         $activeSmsProvider = $this->em->getRepository(SmsProvider::class)->findOneBy(array(
  768.             'isActive'        =>    1,
  769.         ));
  771.         $smsProviderStatus = $this->em
  772.             ->getRepository(SmsTwilioStatus::class)
  773.             ->findOneByStatusTwilio($statusValue);
  775.         if ($smsProviderStatus === null)
  776.         {
  777.             // Create unknown status
  778.             $statusData = $this->createSmsStatus($smsProvider, $statusValue);
  779.             if ($statusData === null)
  780.             {
  781.                 $msg = "SmsTwilioStatus not found and creation of a new custom status failed";
  782.                 $this->logTools->errorlog($msg);
  783.                 $this->logTools->smsLogDebug($msg, $activeSmsProvider);
  784.                 return null;
  785.             }
  787.             $smsStatus = $statusData['smsStatus'];
  788.             $smsProviderStatus = $statusData['smsProviderStatus'];
  789.         }
  790.         else
  791.         {
  792.             $code = $smsProviderStatus->getCode();
  793.             $smsStatus = $this->em->getRepository(SmsStatus::class)->findOneByCode($code);
  794.             if ($smsStatus === null)
  795.             {
  796.                 $msg = "SmsStatus not found for code $code";
  797.                 $this->logTools->errorlog($msg);
  798.                 $this->logTools->smsLogDebug($msg, $activeSmsProvider);
  799.                 return null;
  800.             }
  801.         }
  803.         return array(
  804.             'smsStatus'                =>    $smsStatus,
  805.             'smsProviderStatus'        =>    $smsProviderStatus,
  806.         );
  807.     }
  809.     /**
  810.      * Tries to find a SmsModeStatus with the given value (statusValue).
  811.      * If the status is not found, one is created for the given value.
  812.      * In both cases, the corresponding SmsStatus is also returned.
  813.      *
  814.      * Can be called from outside of the service
  815.      *
  816.      * @param  string $value
  817.      * @return null|array
  818.      */
  819.     public function handleSmsModeStatus(SmsProvider $smsProvider, $statusValue)
  820.     {
  821.         // Get the active SmsProvider
  822.         $activeSmsProvider = $this->em->getRepository(SmsProvider::class)->findOneBy(array(
  823.             'isActive'        =>    1,
  824.         ));
  826.         $smsProviderStatus = $this->em
  827.             ->getRepository(SmsModeStatus::class)
  828.             ->findOneByStatusSmsMode($statusValue);
  830.         if ($smsProviderStatus === null)
  831.         {
  832.             // Create unknown status
  833.             $statusData = $this->createSmsStatus($smsProvider, $statusValue);
  834.             if ($statusData === null)
  835.             {
  836.                 $msg = "SmsModeStatus not found and creation of a new custom status failed";
  837.                 $this->logTools->errorlog($msg);
  838.                 $this->logTools->smsLogDebug($msg, $activeSmsProvider);
  839.                 return null;
  840.             }
  842.             $smsStatus = $statusData['smsStatus'];
  843.             $smsProviderStatus = $statusData['smsProviderStatus'];
  844.         }
  845.         else
  846.         {
  847.             $code = $smsProviderStatus->getCode();
  848.             $smsStatus = $this->em->getRepository(SmsStatus::class)->findOneByCode($code);
  849.             if ($smsStatus === null)
  850.             {
  851.                 $msg = "SmsStatus not found for code $code";
  852.                 $this->logTools->errorlog($msg);
  853.                 $this->logTools->smsLogDebug($msg, $activeSmsProvider);
  854.                 return null;
  855.             }
  856.         }
  858.         return array(
  859.             'smsStatus'                =>    $smsStatus,
  860.             'smsProviderStatus'        =>    $smsProviderStatus,
  861.         );
  862.     }
  864.     /**
  865.      * Creates Sms, SmsTwilio, ExternalMessage for the given data.
  866.      * Objects are properly linked.
  867.      * In case of success returns an array containing the three objects.
  868.      *
  869.      * Called by SmsTwilioController :: smsResponse
  870.      * when someone answers to the Twilio sms they received
  871.      *
  872.      * @uses \App\Services\Platform\ExternalMessageTools::createExternalMessageForSmsChild()
  873.      *
  874.      * @param  SmsTwilio $parentSmsProvider
  875.      * @param  string $value
  876.      * @return null|array
  877.      */
  878.     public function craftObjectsFromTwilioData(SmsTwilio $parentSmsProvider, $twilioData)
  879.     {
  880.         // Get the active SmsProvider
  881.         $activeSmsProvider = $this->em->getRepository(SmsProvider::class)->findOneBy(array(
  882.             'isActive'        =>    1,
  883.         ));
  885.         $smsProviderTwilio = $this->em->getRepository(SmsProvider::class)->findOneByName(SmsProvider::CODE_TWILIOSMS);
  886.         if ($smsProviderTwilio === null)
  887.         {
  888.             $msg = "SmsProvider not found for name ".SmsProvider::CODE_TWILIOSMS;
  889.             $this->logTools->errorlog($msg);
  890.             $this->logTools->smsLogDebug($msg, $activeSmsProvider);
  891.             return null;
  892.         }
  893.         // Handle Status for both Sms and TwilioSms
  894.         $statusValue = $twilioData["SmsStatus"];
  895.         $statusData = $this->handleSmsTwilioStatus($smsProviderTwilio, $statusValue);
  897.         if ($statusData === null)
  898.         {
  899.             $msg = "SmsTwilioStatus not found and creation of a new custom status failed";
  900.             $this->logTools->errorlog($msg);
  901.             $this->logTools->smsLogDebug($msg, $activeSmsProvider);
  902.             return null;
  903.         }
  905.         $smsStatus = $statusData['smsStatus'];
  906.         $smsProviderStatus = $statusData['smsProviderStatus'];
  908.         // Get the SmsParent
  909.         $parentSms = $parentSmsProvider->getSms();
  910.         if ($parentSms === null)
  911.         {
  912.             $msg = "ParentSms not found for parentSmsProvider ".$parentSmsProvider->displayForLog();
  913.             $this->logTools->errorlog($msg);
  914.             $this->logTools->smsLogDebug($msg, $activeSmsProvider);
  915.             return null;
  916.         }
  918.         // At this point nothing can go wrong any more, start creating data
  920.         //----------------------------------------------------------------------
  921.         // PART ONE : Create the SmsTwilio
  922.         $smsProvider = new SmsTwilio();
  923.         $smsProvider->setAuthor($parentSmsProvider->getAuthor());
  924.         $smsProvider->setClient($parentSmsProvider->getClient());
  925.         $smsProvider->setSocietyGroup($parentSmsProvider->getSocietyGroup());
  926.         $smsProvider->setSociety($parentSmsProvider->getSociety());
  927.         $smsProvider->setTwilioTo($twilioData["To"]);
  928.         $smsProvider->setEmitter($twilioData["From"]);
  929.         $smsProvider->setRecipient($twilioData["To"]);
  930.         $smsProvider->setSubject($parentSmsProvider->getSubject());
  931.         $smsProvider->setBody($twilioData["Body"]);
  932.         $smsProvider->setTwilioSid($twilioData["SmsMessageSid"]);
  933.         $smsProvider->setTwilioNumberSegment($twilioData["NumSegments"]);
  934.         $smsProvider->setCallbackDate(new \DateTime());
  935.         $smsProvider->setTwilioRaw(json_encode($twilioData));
  937.         $smsProvider->setStatus($smsProviderStatus);
  939.         $uniqueCode = $this->passwordTools->generateUniqId();
  940.         $smsProvider->setCode($uniqueCode);
  942.         //----------------------------------------------------------------------
  943.         // PART TWO : Create the Sms
  944.         $sms = new Sms();
  945.         $sms->setCreationDate($smsProvider->getCreationDate());
  946.         $sms->setRecipient($smsProvider->getRecipient());
  947.         $sms->setEmitter($smsProvider->getEmitter());
  948.         $sms->setSubject($smsProvider->getSubject());
  949.         $sms->setBody($smsProvider->getBody());
  950.         $sms->setError($smsProvider->getError());
  951.         $sms->setPrice($smsProvider->getPrice());
  952.         $sms->setNumberSegment($smsProvider->getTwilioNumberSegment());
  953.         $sms->setAuthor($smsProvider->getAuthor());
  954.         $sms->setClient($smsProvider->getClient());
  955.         $sms->setHumanResource($smsProvider->getHumanResource());
  956.         $sms->setSociety($smsProvider->getSociety());
  957.         $sms->setSocietyGroup($smsProvider->getSocietyGroup());
  959.         $sms->setStatus($smsStatus);
  961.         $sms->setMission($parentSms->getMission());
  963.         // smsProviderTwilio = SmsProvider :: class -> SmsProvider::CODE_TWILIOSMS
  964.         $sms->setProvider($smsProviderTwilio);
  966.         //----------------------------------------------------------------------
  967.         // PART THREE : Link objects (part.one)
  968.         // This is needed to create the ExternalMessage
  970.         // Sms : Link the parent and child Sms
  971.         $sms->setParent($parentSms);
  972.         // SmsProvider : Link the parent and child
  973.         $smsProvider->setParent($parentSmsProvider);
  975.         // Make the link between the Sms and TwilioSms
  976.         $smsProvider->setSms($sms);
  978.         //----------------------------------------------------------------------
  979.         // PART FOUR : Create the ExternalMessage
  980.         $externalMessage = $this->externalMessageTools->createExternalMessageForSmsChild($sms);
  981.         if ($externalMessage === null)
  982.         {
  983.             // Error is logged in ExternalMessageTools
  984.             return null;
  985.         }
  986.         // At this point the ExternalMessage and the Sms are already linked (done in ExternalMessageTools)
  987.         // $externalMessage->setSms($sms);
  989.         //----------------------------------------------------------------------
  990.         // PART FIVE : Persist data
  991.         $this->em->persist($sms);
  992.         $this->em->persist($smsProvider);
  994.         return array(
  995.             'sms'                =>    $sms,
  996.             'smsProvider'        =>    $smsProvider,
  997.             'externalMessage'    =>    $externalMessage,
  998.         );
  999.     }
  1000. }