src/Controller/WS/ReadFilesDataController.php line 7317

Open in your IDE?
  1. <?php
  3. namespace App\Controller\WS;
  5. use App\Websocket\PusherManager;
  6. use Symfony\Component\Process\Process;
  7. use Symfony\Component\HttpFoundation\Request;
  8. use Symfony\Component\HttpFoundation\Response;
  9. use Symfony\Component\Console\Input\ArrayInput;
  10. use Symfony\Component\HttpFoundation\JsonResponse;
  11. use Symfony\Component\Console\Output\BufferedOutput;
  12. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  13. use App\Util\WS\Util;
  14. use App\Util\NewUtil;
  15. use App\Util\Util as Utilx;
  16. use App\Util\UUIDGeneratorUtil;
  17. use App\Util\WS\ForcedAsynchronousCommandsUtil;
  18. use stdClass;
  19. use App\Structure\Usuario;
  20. use App\Structure\RegistActions;
  21. use App\Entity\User;
  22. use App\Entity\PushSent;
  23. use App\Entity\GiftCard;
  24. use App\Entity\MasterSync;
  25. use App\Entity\WebService;
  26. use App\Entity\ReadFilesData;
  27. use App\Entity\AccountLicense;
  28. use App\Entity\ReadFilesDataWeb;
  29. use App\Entity\SyncReportedError;
  30. use App\Entity\LogAndroidEmailSent;
  31. use App\Entity\GiftCardTransaction;
  32. use App\Entity\ThirdPartyAPIRecords;
  33. use App\Entity\AndroidErrorsHistory;
  34. use App\Entity\SyncAllCallStatus;
  35. use App\Entity\ErrorAndroidEmailSent;
  36. use App\Entity\NotificationInLicensorBell;
  37. use App\Transformer\SyncWebTransformer;
  38. use App\Transformer\DemoForLoginTransformer;
  39. use App\Transformer\SublicensesListTransformer;
  40. use App\Transformer\LicensorGenericTransformer;
  41. use App\Transformer\UpdateAndroidCommandTransformer;
  42. use App\Transformer\UploadSyncJsonNotifyTransformer;
  43. use App\Transformer\UpdateMobileInsertJsonTransformer;
  44. use App\Transformer\RespondedNotificationPushTransformer;
  45. use App\Controller\Application\Service\ArmorService;
  46. use App\Controller\Application\Service\Log\Log;
  47. use App\Controller\Application\Service\Util\Encryptor;
  48. use Symfony\Bundle\FrameworkBundle\Console\Application;
  49. use DateTime;
  50. use App\SynchronizationUtil\SyncWebUtil;
  51. use Exception;
  52. use App\Command\Websocket\SyncAllWebsocketVersionCommand;
  53. use App\Consumer\WS\SyncFullCallConsumer;
  54. use App\Entity\ActionHistory;
  55. use App\Util\UtilSync;
  57. /**
  58.  * Description of ReadFilesDataController
  59.  * @author
  60.  */
  61. class ReadFilesDataController extends ApiController {
  63.     /**
  64.      * Esta funcion permite validar el acceso a la aplicacion web de level
  65.      * validando codigo de usuario y contraseña y generando el apiKey
  66.      * necesario para toda la aplicacion movil
  67.      * @author Aealan Z <lrobledo@kijho.com> 08/10/15
  68.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  69.      * @return Response Json con la informacion de respuesta
  70.      */
  71.     public function loginMobil(Request $request) {
  72.         
  74.         if ($request->getMethod() !== WebService::REQUEST_METHOD_POST) {
  75.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  76.         }
  78.         if (!(0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE) || 0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT))) {
  79.             return $this->errorWrongArgs('Wrong Content.', WebService::CODE_WRONG_ARGUMENTS);
  80.         }
  82.         $path = Util::getValidActiveLogByBaseName($this->realContainer, 'InitialAndroidLoginWS', 'InitialAndroidLoginWS0.txt');
  83.         $this->createFileJson($path, "\r" . 'Login Mobile: ' . $request->getContent() . "\r");
  85.         try {
  87.             $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  88.             $data = json_decode($arrayEncryptResult['data'], true);
  90.             if (!isset($data['alLicenseUsername']) || !isset($data['password']) || !isset($data['username']) || !isset($data['uid'])) {
  91.                 return $this->errorWrongArgs('Wrong Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  92.             }
  94.             $licenseUserName = ['alLicenseUsername' => $data['alLicenseUsername']];
  95.             $em = $this->getDoctrine()->getManager();
  97.             
  98.             $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findBy($licenseUserName);
  99.             $countResult = count($accountLicenseData);
  100.             
  101.             if ($countResult <= 0) {
  103.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  104.                                 ->respondWithError('Invalid nickname', WebService::CODE_COULD_NOT_AUTHENTICATE);
  105.             }
  107.             if ($accountLicenseData[0]->getAlAccountLicense()->getDeleted()) {
  108.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  109.                                 ->respondWithError('Inactive Account', WebService::CODE_ACCOUNT_SUSPENDED);
  110.             }
  112.             if ($accountLicenseData[0]->getAlLicenseStatus() == AccountLicense::LICENSE_STATUS_INACTIVE) {
  113.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  114.                                 ->respondWithError('Inactive License', WebService::CODE_ACCOUNT_SUSPENDED);
  115.             }
  117.             if ($accountLicenseData[0]->getAlLicenseStatus() == AccountLicense::LICENSE_STATUS_PENDING) {
  118.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  119.                                 ->respondWithError('Pending License', WebService::CODE_ACCOUNT_SUSPENDED);
  120.             }
  122.             $oldUID = $accountLicenseData[0]->getDeviceUid();
  123.             $oldLoguedDeviceKind = $accountLicenseData[0]->getLastloguedDeviceKind();
  125.             $alreadyUsingLastVersion = false;
  126.             $deviceUIDWasSetted = false;
  127.             $arrayGoodWayUpdate = [];
  128.             $arrayWrongWayUpdate = [];
  129.             $theVersionArrayForOldUsers = [];
  130.             $accountLicenseData[0]->setHasAndroid(true);
  131.             $country = $accountLicenseData[0]->getCity()->getCiState()->getStCountry()->getCoVal();
  132.             $isCallCenter = $accountLicenseData[0]->getIsCallCenter();
  134.             $language = Util::getLanguageCodeByCountryCode($country);
  136.             $theRespArray['language'] = $language;
  138.             $pathXD = $this->realContainer->getParameter('level_directory_logs') . 'ip_man.json';
  139.             $this->createFileJson($pathXD, $this->realContainer->get('request_stack')->getCurrentRequest()->getClientIp() . ' -> ' . $data['alLicenseUsername'] . ' |L| ');
  141.             if (isset($data['isLiteDevice'])) {
  142.                 $accountLicenseByUID = $em->getRepository('App\Entity\AccountLicense')->findBy(['deviceUid' => $data['uid']]);
  144.                 if (empty($accountLicenseByUID) && $accountLicenseData[0]->getLastloguedDeviceKind() == AccountLicense::DEVICE_LITE_TYPE) {
  145.                     $deviceUIDWasSetted = true;
  146.                     $accountLicenseData[0]->setHasAndroid(true);
  147.                     $accountLicenseData[0]->setDeviceUid($data['uid']);
  148.                 } else {
  149.     //                dump('Hola chingo!');
  150.                     $accountLicenseData[0]->setHasAndroid(true);
  151.                     if (!($accountLicenseData[0]->getDeviceUid() && $accountLicenseData[0]->getLastloguedDeviceKind() != AccountLicense::DEVICE_LITE_TYPE)) {
  152.     //                    dump('Jumm!');
  153.                         if (isset($accountLicenseByUID[0]) && isset($accountLicenseData[0]) && ($accountLicenseData[0]->getId() == $accountLicenseByUID[0]->getId()) && $accountLicenseByUID[0]->getLastloguedDeviceKind() == AccountLicense::DEVICE_LITE_TYPE) {
  154.     //                        dump('Jumm x2!');
  156.                             $accountLicenseByUID[0]->setDeviceUid(null);
  157.                             $accountLicenseByUID[0]->setWsResourceIdVerifiedAfterLogin(0);
  159.                             $em->persist($accountLicenseByUID[0]);
  160.                             $em->flush();
  162.                             $accountLicenseData[0]->setDeviceUid($data['uid']);
  163.                         } elseif (isset($accountLicenseByUID[0]) && (!$accountLicenseData[0]->getDeviceUid() || $accountLicenseData[0]->getDeviceUid() == '')) {
  164.                             $auxLicenseFoundCounter = 1;
  165.                             $auxLicenseUID = $accountLicenseByUID[0]->getDeviceUid() . '_aux_lite_' . $accountLicenseByUID[0]->getAlLicenseUsername() . '_' . $auxLicenseFoundCounter;
  166.                             $deviceSplitAux = explode("_aux_lite_", $auxLicenseUID);
  167.                             do {
  168.                                 $auxLicenseUID = $deviceSplitAux[0] . '_aux_lite_' . $accountLicenseByUID[0]->getAlLicenseUsername() . '_' . $auxLicenseFoundCounter;
  169.                                 $accountLicenseByUID = $em->getRepository('App\Entity\AccountLicense')->findBy(['deviceUid' => $auxLicenseUID]);
  170.                                 ++$auxLicenseFoundCounter;
  171.                             } while (isset($accountLicenseByUID[0]));
  173.                             $accountLicenseData[0]->setDeviceUid($auxLicenseUID);
  174.                             $accountLicenseData[0]->setHasAndroid(true);
  175.                         } else if (!isset($accountLicenseByUID[0]) && (!$accountLicenseData[0]->getDeviceUid() || $accountLicenseData[0]->getDeviceUid() == '')) {
  176.                             $accountLicenseData[0]->setDeviceUid($data['uid']);
  177.                             $accountLicenseData[0]->setHasAndroid(true);
  178.                         }
  180.                         $accountLicenseData[0]->setLastloguedDeviceKind(AccountLicense::DEVICE_LITE_TYPE);
  181.                     }
  182.                 }
  184.     //            dump('Casillo!?');
  185.     //            die;
  187.                 $em->persist($accountLicenseData[0]);
  188.                 $em->flush();
  189.             } else {
  190.     //            dump(isset($data['uid']), $data['uid']);
  191.     //            dump($accountLicenseData[0]->getDeviceUid() == '');
  192.     //            dump(null == $accountLicenseData[0]->getDeviceUid());
  193.     //            die;
  194.                 if (isset($data['uid']) && ($accountLicenseData[0]->getDeviceUid() == '' || null == $accountLicenseData[0]->getDeviceUid())) {
  195.                     $accountLicenseByUID = $em->getRepository('App\Entity\AccountLicense')->findBy(['deviceUid' => $data['uid']]);
  197.                     // dump($accountLicenseByUID);
  199.                     if (!empty($accountLicenseByUID)) {
  200.                         $alreadyWithTheSameUIDLicense = $accountLicenseByUID[0];
  201.                         if ($accountLicenseData[0]->getAlLicenseUsername() != $accountLicenseByUID[0]->getAlLicenseUsername() && $accountLicenseByUID[0]->getLastloguedDeviceKind() != AccountLicense::DEVICE_LITE_TYPE) {
  202.                             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  203.                                             ->respondWithError("Device UID '" . $data['uid'] . "' already registed with '" . $accountLicenseByUID[0] . "' license using a non lite app", WebService::CODE_COULD_NOT_AUTHENTICATE);
  204.                         } elseif ($accountLicenseData[0]->getAlLicenseUsername() != $accountLicenseByUID[0]->getAlLicenseUsername()) {
  206.                             $auxLicenseFoundCounter = 1;
  207.                             $auxLicenseUID = $accountLicenseByUID[0]->getDeviceUid() . '_aux_lite_' . $accountLicenseByUID[0]->getAlLicenseUsername() . '_' . $auxLicenseFoundCounter;
  208.                             $deviceSplitAux = explode("_aux_lite_", $auxLicenseUID);
  209.                             do {
  210.                                 $auxLicenseUID = $deviceSplitAux[0] . '_aux_lite_' . $accountLicenseByUID[0]->getAlLicenseUsername() . '_' . $auxLicenseFoundCounter;
  211.                                 $accountLicenseByUID = $em->getRepository('App\Entity\AccountLicense')->findBy(['deviceUid' => $auxLicenseUID]);
  212.                                 ++$auxLicenseFoundCounter;
  213.                             } while (isset($accountLicenseByUID[0]));
  215.                             $alreadyWithTheSameUIDLicense->setDeviceUid($auxLicenseUID);
  216.                             $alreadyWithTheSameUIDLicense->setHasAndroid(true);
  218.                             $em->persist($alreadyWithTheSameUIDLicense);
  219.                             $em->flush();
  221.                             $auxLevEm = Util::emLicenseConnection($this->realContainer, $em, $alreadyWithTheSameUIDLicense);
  223.                             $configuracionForAll = $auxLevEm->getRepository('App\Structure\Configuracion')->findAll();
  225.                             if (!empty($configuracionForAll)) {
  226.                                 $configuracion = $configuracionForAll[0];
  227.                             }
  229.                             if ($configuracion) {
  230.                                 $configuracion->setConfHasAndriod(true);
  231.                                 $configuracion->setConfDeviceUid($alreadyWithTheSameUIDLicense->getDeviceUid());
  232.                                 $this->createFileJson($path, "\r" . '1 SETEO DE LEVEL UUID CONFIG: ' . $alreadyWithTheSameUIDLicense->getDeviceUid() . ' HAS ANDROID : TRUE' . "\r");
  234.                                 $auxLevEm->persist($configuracion);
  235.                                 $auxLevEm->flush();
  237.                                 $auxLevEm->close();
  238.                             }
  239.                         }
  240.                     }
  242.                     $deviceUIDWasSetted = true;
  243.                     $accountLicenseData[0]->setHasAndroid(true);
  244.                     $accountLicenseData[0]->setDeviceUid($data['uid']);
  245.                 } else {
  246.                     if (isset($data['uid']) && $accountLicenseData[0]->getDeviceUid() != $data['uid'] && $accountLicenseData[0]->getLastloguedDeviceKind() != AccountLicense::DEVICE_LITE_TYPE) {
  247.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  248.                                         ->respondWithError("There is another server device with the UID '" . $accountLicenseData[0]->getDeviceUid() . "' registered with this license", WebService::CODE_INVALID_UID);
  249.                     } else {
  250.                         $accountLicenseByUID = $em->getRepository('App\Entity\AccountLicense')->findBy(['deviceUid' => $data['uid']]);
  252.                         if (!empty($accountLicenseByUID)) {
  253.                             if ($accountLicenseData[0]->getAlLicenseUsername() != $accountLicenseByUID[0]->getAlLicenseUsername() && ($accountLicenseData[0]->getLastloguedDeviceKind() != AccountLicense::DEVICE_LITE_TYPE || $accountLicenseByUID[0]->getLastloguedDeviceKind() != AccountLicense::DEVICE_LITE_TYPE)) {
  254.                                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  255.                                                 ->respondWithError("Device UID '" . $data['uid'] . "' already registed with '" . $accountLicenseByUID[0] . "' license", WebService::CODE_COULD_NOT_AUTHENTICATE);
  256.                             } else {
  257.                                 $accountLicenseByUID[0]->setDeviceUid(null);
  258.                                 $accountLicenseByUID[0]->setHasAndroid(null);
  259.                                 $accountLicenseByUID[0]->setWsResourceIdVerifiedAfterLogin(0);
  261.                                 $em->persist($accountLicenseByUID[0]);
  262.                                 $em->flush();
  263.                             }
  264.                         }
  266.                         $deviceUIDWasSetted = true;
  267.                         $accountLicenseData[0]->setHasAndroid(true);
  268.                         $accountLicenseData[0]->setDeviceUid($data['uid']);
  269.                     }
  270.                 }
  272.                 $accountLicenseData[0]->setLastloguedDeviceKind(AccountLicense::DEVICE_ANDROID_TYPE);
  273.             }
  275.             $liteUsername = '';
  276.             $responseArrOmt = [];
  277.             /**
  278.              * Allows to add the apikey to the user of lite level this exported in OMT
  279.              */
  280.             if ($accountLicenseData[0]->getHasLogedOMT() == true || $accountLicenseData[0]->getIsLevelLight() == true || (isset($data['isLiteDevice']) && $data['isLiteDevice']) ) {
  281.                 $this->createFileJson($path, 'Util::doOMTDashboardLoginToGetToken 1!' . "\r");
  282.                 
  283.                 $levelLiteUser = $accountLicenseData[0]->getLevelLightUser();
  284.                 // $apikey = Util::doOMTDashboardLoginToGetToken($this->realContainer, $levelLiteUser, $path, $accountLicenseData[0]->getLoginType());
  286.                 if (!empty($apikey)) {
  287.                     $levelLiteUser['apikey'] = $apikey;
  288.                     $responseArrOmt['userToOmt']['apikey'] = $apikey;
  289.                 }
  291.                 if (!empty($apikey)) {
  292.                     $levelLiteUser['apikey'] = $apikey;
  294.                     $accountLicenseData[0]->setLevelLightUser($levelLiteUser);
  295.                 }
  297.                 $liteUsername = $levelLiteUser['username'];
  299.                 $responseArrOmt['userToOmt']['username'] = $liteUsername;
  300.                 $responseArrOmt['userToOmt']['password'] = $levelLiteUser['realPass'];
  301.             }
  303.             if (isset($data['version'])) {
  304.                 $data['version'] = trim($data['version']);
  305.             }
  307.             if (isset($data['version']) && !isset($data['isLiteDevice'])) {
  308.                 if (strpos($data['version'], '-')) {
  309.                     $this->createFileJson($path, 'Is a testing version...?  ' . $data['version'] . "\r");
  310.                     $data['version'] = explode('-', $data['version'])[0];
  311.                 }
  313.                 if (!preg_match('/^(\d+\.)(\d+\.)(\d+)$/', $data['version'])) {
  314.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  315.                                     ->respondWithError('Invalid version format', WebService::CODE_COULD_NOT_AUTHENTICATE);
  316.                 }
  318.                 $accountLicenseData[0]->setAndroidVersionName($data['version']);
  319.                 $accountLicenseData[0]->setVersionUpdatedDate(Util::getCurrentDate());
  321.                 $theRespArray = Util::getLastVersionByDirNow($this->realContainer, false, $path);
  322.                 $theRespArray['bigbag'] = true;
  323.                 $theRespArray['language'] = $language;
  325.                 if (isset($theRespArray['updateAppError']) && $theRespArray['updateAppError']) {
  326.                     return $this->setStatusCode(WebService::HTTP_CODE_SERVICE_UNAVAILABLE)
  327.                                     ->respondWithError('Error finding last version', WebService::CODE_OBJECT_NOT_FOUND);
  328.                 }
  330.                 if (isset($theRespArray['newVersion'])) {
  331.                     $newVersionString = Util::validateNewerVersion($data['version'], $theRespArray['newVersion']);
  333.                     if ($newVersionString != $data['version']) {
  334.                         $theRespArray['success'] = WebService::CODE_SUCCESS;
  335.                         $theRespArray['country'] = $country;
  337.                         $theRespArray['iscallcenter'] = (int) $isCallCenter;
  339.                         $theUrlTrSt = new UpdateAndroidCommandTransformer($this->realContainer, $theRespArray);
  340.                         $xxArray = $theUrlTrSt->transform();
  342.                         $jsonContent = json_encode($xxArray);
  344.                         return $this->respondWithItem($jsonContent, $theUrlTrSt);
  345.                     } else {
  346.                         $arrayWrongWayUpdate['case'] = 'Android client is already updated!';
  347.                         $alreadyUsingLastVersion = true;
  348.                     }
  349.                 } else {
  350.                     $arrayWrongWayUpdate['case'] = 'Android client is already updated!';
  351.                     $alreadyUsingLastVersion = true;
  352.                 }
  353.             } elseif (!isset($data['isLiteDevice'])) {
  354.                 $userOldVersion = $accountLicenseData[0]->getAndroidVersionName();
  356.                 if (null != $userOldVersion && $userOldVersion != '') {
  357.                     $theVersionArrayForOldUsers = Util::getLastVersionByDirAvailableVersions($this->realContainer, $userOldVersion, true, $path);
  358.                 } else {
  359.                     $theVersionArrayForOldUsers = Util::getLastVersionByDirAvailableVersions($this->realContainer, '1.0.0', true, $path);
  360.                 }
  362.                 if (isset($theVersionArrayForOldUsers['updateAppIsNeeded']) && $theVersionArrayForOldUsers['updateAppIsNeeded'] === true) {
  363.                     $arrayGoodWayUpdate['apkurl'] = $theVersionArrayForOldUsers['updateRequestApk'];
  364.                     $arrayGoodWayUpdate['lastversion'] = $theVersionArrayForOldUsers['newVersion'];
  365.                 } else {
  366.                     $arrayGoodWayUpdate['apkurl'] = '';
  367.                     $arrayGoodWayUpdate['lastversion'] = '';
  368.                 }
  369.             }
  371.             $unsetDownUrl = false;
  373.             $em->persist($accountLicenseData[0]);
  374.             $em->flush();
  375.             
  376.             $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData[0]);
  377.             // Verifica si es un usuario de leveLite y si este pertenece a la licencia a la cual se esta accediendo  
  378.             if(isset($levelLiteUser) && isset($levelLiteUser["username"]) && isset($data['isLiteDevice']) ){
  379.                 if (strtolower($data['username']) === strtolower($levelLiteUser["username"]) && $data['isLiteDevice'] == '1'){
  380.                     // Limpia lista de usuarios levelLite
  381.                     // Revisar se estalla al borrar usuarios
  382.                     // $emLev->getRepository('App\Structure\Usuario')->cleanWrongUsers($levelLiteUser["username"]);   
  383.                 }
  384.             }
  386.             $configuracionForAll = $emLev->getRepository('App\Structure\Configuracion')->findAll();
  388.             if (!empty($configuracionForAll)) {
  389.                 $configuracion = $configuracionForAll[0]; 
  390.             }
  392.             if (($configuracion && $deviceUIDWasSetted) || !$configuracion->getConfDeviceUid() || $configuracion->getConfDeviceUid() == '' || $configuracion->getConfDeviceUid() == "") {
  393.                 $configuracion->setConfHasAndriod(true);
  394.                 $configuracion->setConfDeviceUid($data['uid']);
  395.                 $this->createFileJson($path, "\r" . '2 SETEO DE LEVEL UUID IN CONFIG: ' . $data['uid'] . ' HAS ANDROID : TRUE' . "\r");
  397.                 $emLev->persist($configuracion);
  398.                 $emLev->flush();
  400.                 $maxUIDPollingCounter = 0;
  401.                 do {
  402.                     ++$maxUIDPollingCounter;
  404.                     $configuracionForAll = $emLev->getRepository('App\Structure\Configuracion')->findAll();
  406.                     if (!empty($configuracionForAll)) {
  407.                         $configuracion = $configuracionForAll[0];
  408.                     } else {
  409.                         return $this->setStatusCode(WebService::HTTP_CODE_SERVICE_UNAVAILABLE)
  410.                                         ->respondWithError('Error finding configuration LEVEL database record', WebService::CODE_OBJECT_NOT_FOUND);
  411.                     }
  413.                     $configuracion->setConfHasAndriod(true);
  414.                     $configuracion->setConfDeviceUid($data['uid']);
  416.                     $emLev->persist($configuracion);
  417.                     $emLev->flush();
  419.                     $emLev->clear();
  420.                     sleep(1);
  422.                     $configuracionForAllCheck = $emLev->getRepository('App\Structure\Configuracion')->findBy(['confDeviceUid' => $data['uid']]);
  423.                 } while (!isset($configuracionForAllCheck[0]) && $maxUIDPollingCounter < 7);
  425.                 $this->createFileJson($path, "\r" . '2 SETEO DE LEVEL UUID IN CONFIG CHECKEADO Y FULL PARA: ' . $data['uid'] . ' HAS ANDROID : TRUE' . "\r");
  426.             }
  428.             $cliente = $emLev->getRepository('App\Structure\Usuario')->validateUser($data);
  430.             $emLev->clear();
  431.             $emLev->close();
  433.             // dump($data);
  434.             // dump($cliente);
  435.             // die;
  437.             if (!empty($cliente)) {
  438.                 if (isset($data['isLiteDevice']) && strtolower($data['username']) != $liteUsername) {
  439.                     $this->createFileJson($path, "Error: Invalid username for LEVELLite");
  440.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  441.                                     ->respondWithError('Invalid username for LEVELLite', WebService::CODE_UNAUTHORIZED);
  442.                 }
  444.                 if (strtolower($data['username']) != 'admin') {
  446.                     $isDirectoryReady = Util::createLicenseDirectory($this->realContainer, $accountLicenseData[0], $data['alLicenseUsername']);
  447.                     $theAccountLicenseDirector = $isDirectoryReady['directory'];
  449.                     if (!isset($isDirectoryReady['result']) || $isDirectoryReady['result'] == '__KO__') {
  450.                         $msnError = 'An error occurred while creating your directory in server ';
  451.                         $this->createFileJson($path, $msnError);
  452.                         return $this->setStatusCode(WebService::CODE_INTERNAL_ERROR)
  453.                                         ->respondWithError($msnError, WebService::CODE_INTERNAL_ERROR);
  454.                     }
  456.                     $em = $this->getDoctrine()->getManager();
  457.                     $licenseDB = $em->getRepository("App\Entity\LicenseDataBase")->findBy(['license' => $accountLicenseData[0]->getId()]);
  459.                     $splitedLogin = isset($data['splitedLogin']) ? $data['splitedLogin'] : 0;
  461.                     if (!empty($licenseDB)) {
  462.                         if (!isset($data['isLiteDevice'])) {
  463.                             $useMetadataCacheInLogin = false;
  464.                             if (isset($data['useMetadataCache'])) {
  465.                                 $useMetadataCacheInLogin = true;
  466.                             } 
  468.                             if (isset($data['splitedLogin'])) {
  469.                                 $this->createFileJson($path, "Notice: pre fileJsonFromSelectEntities with 'splitedLogin' -> " . $data['splitedLogin']);
  470.                                 $auxResponseArray = Util::fileJsonFromSelectEntities($this->realContainer, $em, $theAccountLicenseDirector, $licenseDB[0], null, true, false, true, $data['splitedLogin'], $useMetadataCacheInLogin);
  471.                             } else {
  472.                                 $this->createFileJson($path, "Notice: pre fileJsonFromSelectEntities ");
  473.                                 $auxResponseArray = Util::fileJsonFromSelectEntities($this->realContainer, $em, $theAccountLicenseDirector, $licenseDB[0], null, true, false, true, null, $useMetadataCacheInLogin);
  474.                             }
  476.                             $responseArr = $auxResponseArray[0];
  477.                             $responseArr['bigbag'] = true;
  478.                             $responseArr['language'] = $language;
  479.                             $newSetWebRecordToSync = $auxResponseArray[1]['entity'];
  481.                             if (isset($responseArrOmt) && isset($responseArrOmt['userToOmt'])) {
  482.                                 $responseArr['userToOmt'] = $responseArrOmt['userToOmt'];
  483.                             }
  485.                             $actualDate = Util::getCurrentDate();
  487.                             $accountLicenseData[0]->setLastLoginWasOk(false);
  488.                             $accountLicenseData[0]->setLastLoginDate($actualDate);
  490.                             $newNotificationSeed = new NotificationInLicensorBell();
  492.                             $newNotificationSeed->setDateCreated($actualDate);
  493.                             $newNotificationSeed->setIterativeNotification(true);
  494.                             $newNotificationSeed->setLicense($accountLicenseData[0]);
  495.                             $newNotificationSeed->setTypeRoleToNotify(NotificationInLicensorBell::ROLE_LICENSE_MANAGER);
  496.                             $newNotificationSeed->setContext(NotificationInLicensorBell::CONTEXT_NOTIFICATION_ANDROID_LOGIN);
  498.                             $em->persist($newNotificationSeed);
  500.                             $em->persist($accountLicenseData[0]);
  501.                             $em->flush();
  503.                             if ($newSetWebRecordToSync) {
  504.                                 Util::updateWebSyncUploadResponseFile($em, $newSetWebRecordToSync);
  505.                             } else {
  506.                                 $unsetDownUrl = true;
  507.                                 unset($data['splitedLogin']);
  508.                                 unset($responseArr['splitedLogin']);
  509.                                 Utilx::closeAllStuckedWebSync($em, $accountLicenseData[0]);
  510.                             }
  511.                         }
  512.                     } else {
  513.                         $this->createFileJson($path, "Error: No DB conection data found!");
  514.                         return $this->setStatusCode(WebService::HTTP_CODE_SERVICE_UNAVAILABLE)
  515.                                         ->respondWithError('No DB conection data found!', WebService::CODE_OBJECT_NOT_FOUND);
  516.                     }
  518.                     $userLite = $accountLicenseData[0]->getLevelLightUser();
  519.                     // dump($responseArr, strtolower($data['username']), $userLite["username"]);die;
  520.                     if (isset($responseArr['status']) && $responseArr['status']==200 && strtolower($data['username']) !== $userLite["username"]) {
  521.                         if ($accountLicenseData[0]->getHasLogedOMT() && !isset($data['isLiteDevice'])) {
  523.                             $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData[0]);
  525.                             // Util::createSyncRecordsToOmtByUpdate($emLev, $accountLicenseData[0]);
  526.                             $curlResponse = Util::makeOwnSyncWebCurl($this->realContainer, ['nickname' => $data['alLicenseUsername']], $path);
  528.                             $data['rwid'] = $curlResponse;
  530.                             ForcedAsynchronousCommandsUtil::consumeUpDownSyncCommand($this->realContainer, $data, true);
  532.                             $emLev->clear();
  533.                             $emLev->close();
  534.                         }
  536.                         $responseArr['urlBase'] = $this->realContainer->getParameter('level_directory_data_base_url') . $accountLicenseData[0]->getAlAccountLicense() . '/' . $data['alLicenseUsername'] . $responseArr['urlBase'];
  537.                         $responseArr['urlBase'] = str_replace(' ', '_', $responseArr['urlBase']);
  539.                         if (isset($arrayWrongWayUpdate['case'])) {
  540.                             $responseArr['case'] = $arrayWrongWayUpdate['case'];
  541.                         } else {
  542.                             $responseArr['case'] = '';
  543.                         }
  545.                         if (!$alreadyUsingLastVersion && !isset($data['isLiteDevice'])) {
  546.                             $theVersionArrayForOldUsers = Util::getLastVersionByDirNow($this->realContainer, true, $path);
  548.                             if (isset($theVersionArrayForOldUsers['updateAppIsNeeded']) && $theVersionArrayForOldUsers['updateAppIsNeeded'] === true) {
  549.                                 $responseArr['apkurl'] = $theVersionArrayForOldUsers['updateRequestApk'];
  550.                                 $responseArr['lastversion'] = $theVersionArrayForOldUsers['newVersion'];
  551.                             } else {
  552.                                 $responseArr['apkurl'] = '';
  553.                                 $responseArr['lastversion'] = '';
  554.                             }
  555.                         } else {
  556.                             $responseArr['apkurl'] = '';
  557.                             $responseArr['lastversion'] = '';
  558.                         }
  560.                         $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData[0]);
  562.                         $clienteForWebAndroidLogin = $emLev->getRepository('App\Structure\Usuario')->findBy(['usuLogin' => 'admin']);
  564.                         $emLev->clear();
  565.                         $emLev->close();
  567.                         $auxArrayUserAndroidWebLogin = [];
  568.                         if (isset($clienteForWebAndroidLogin[0])) {
  569.                             $auxArrayUserAndroidWebLogin['user'] = 'admin';
  570.                             $auxArrayUserAndroidWebLogin['pass'] = $clienteForWebAndroidLogin[0]->getUsuPass();
  571.                         }
  573.                         $pushServicesKeysArray = Util::buildTheServicesKeysArray($this->realContainer, $accountLicenseData[0], $auxArrayUserAndroidWebLogin); 
  575.                         if ($accountLicenseData[0]->getAwsTopicARN() && $accountLicenseData[0]->getAwsTopicARN() != '' && $accountLicenseData[0]->getAwsTopicARN() != "" ) {
  576.                             if (isset($pushServicesKeysArray['awsPush'])) {
  577.                                 $pushServicesKeysArray['awsPush']['TopicArn'] = $accountLicenseData[0]->getAwsTopicARN();
  578.                             }
  579.                         }
  581.                         $responseArr['country'] = $country;
  582.                         $responseArr['iscallcenter'] = (int) $isCallCenter;
  584.                         $isSplitedAgain = false;
  585.                         if (isset($data['splitedLogin'])) {
  586.                             
  587.                             $responseArr['splitedLogin'] = $data['splitedLogin'];
  588.                             $isSplitedAgain = true;
  589.                         }
  590.                         $responseArr['push_services'] = $pushServicesKeysArray;
  592.                         // $responseArr['uploadurl'] = $this->generateUrl('level_web_service_respond_sync_web', [], UrlGeneratorInterface::ABSOLUTE_URL);
  593.                         $responseArr['uploadurl'] = $this->realContainer->getParameter('level_scheme') . '://' . $this->realContainer->getParameter('level_host') . $this->generateUrl('level_web_service_respond_sync_web');
  595.                         $responseArr['downloadurl'] = $this->realContainer->getParameter('level_directory_data_base_url') . $accountLicenseData[0]->getAlAccountLicense() . '/' . $data['alLicenseUsername'] . '/' . $auxResponseArray[1]['fileConfigName'];
  596.                         $responseArr['downloadurl'] = str_replace(' ', '_', $responseArr['downloadurl']);
  598.                         if (isset($auxResponseArray[1]['fileExpectedName'])) {
  599.                             $responseArr['expected'] = $this->realContainer->getParameter('level_directory_data_base_url') . $accountLicenseData[0]->getAlAccountLicense() . '/' . $data['alLicenseUsername'] . '/' . $auxResponseArray[1]['fileExpectedName'];
  600.                             $responseArr['expected'] = str_replace(' ', '_', $responseArr['expected']);
  601.                         } else {
  602.                             $responseArr['expected'] = '';
  603.                         }
  605.                         if ($accountLicenseData[0]->getLevelLightUser() && isset($data['isLiteDevice']) && $accountLicenseData[0]->getHasLogedOMT() == true) {
  606.                             $this->createFileJson($path, 'Util::doOMTDashboardLoginToGetToken 2!' . "\r");
  607.                             
  608.                             $userData = $accountLicenseData[0]->getLevelLightUser();
  609.                             $apikey = Util::doOMTDashboardLoginToGetToken($this->realContainer, $userData, $path, $accountLicenseData[0]->getLoginType());
  610.                             if (!empty($apikey)) {
  611.                                 $responseArr['userToOmt']['apikey'] = $apikey;
  612.                             }
  613.                             $responseArr['userToOmt']['username'] = $userData['username'];
  614.                             $responseArr['userToOmt']['password'] = $userData['realPass'];
  615.                         }
  617.                         if ($unsetDownUrl) {
  618.                             $responseArr['downloadurl'] = '';
  619.                         }
  621.                         $theUrlTrSt = new UpdateMobileInsertJsonTransformer($this->realContainer, $responseArr);
  622.                         $xxArray = $theUrlTrSt->transform();
  624.                         if ($accountLicenseData[0]->getLoginType() == AccountLicense::LOGGED_OUT) {
  625.                             $accountLicenseData[0]->setLoginType(AccountLicense::LOGGED_BY_LEVEL_ANDROID);
  626.                         } else if ($accountLicenseData[0]->getLoginType() == AccountLicense::LOGGED_BY_LEVEL_LITE) {
  627.                             $accountLicenseData[0]->setLoginType(AccountLicense::LOGGED_BY_LEVEL_LITE_AND_ANDROID);
  628.                         }
  630.                         $em->persist($accountLicenseData[0]);
  631.                         $em->flush();
  633.                         if ($accountLicenseData[0]->getLevelLightUser() && isset($data['isLiteDevice'])) {
  634.                             $this->createFileJson($path, 'Util::doOMTDashboardLoginToGetToken 3!' . "\r");
  636.                             $userData = $accountLicenseData[0]->getLevelLightUser();
  637.                             $apykey = Util::doOMTDashboardLoginToGetToken($this->realContainer, $userData, $path, $accountLicenseData[0]->getLoginType());
  638.                             if (!empty($apykey)) {
  639.                                 $xxArray['userToOmt']['apykey'] = $apykey;
  640.                             }
  641.                             $xxArray['userToOmt']['username'] = $userData['username'];
  643.                             if (isset($userData['password'])) {
  644.                                 $xxArray['userToOmt']['password'] = $userData['password'];
  645.                             }
  646.                         }
  648.                         $jsonContent = json_encode($xxArray);
  650.                         // $splitedLogin = json_decode($jsonContent)->splitedLogin ?? null;
  652.                         // dump($splitedLogin);
  653.                         // dump(Util::definitionInitialMultipartLogin(0, true));
  654.                         // die;
  656.                         if ($splitedLogin === (Util::definitionInitialMultipartLogin(0, true) - 1)) {
  658.                             // dump("Holaa!");
  659.                             // die;
  661.                             $freeLicnesesToPairWithStations = $em->getRepository('App\Entity\LicenseDevice')->getLicenseDeviceServerRecordForInitialLogin($accountLicenseData[0]->getId());
  663.                             $historyResponse = [];
  664.                             $historyResponse["status"] = 200;
  666.                             if (isset($freeLicnesesToPairWithStations[0])) {
  668.                                 $licenseSold = $freeLicnesesToPairWithStations[0];
  670.                                 $this->createFileJson($path, "Updating old license device record with '" . $licenseSold->getId() . "' id..." . "\r");
  672.                                 $licenseSold->setLdUpdateDate($actualDate);
  673.                                 $licenseSold->setLdStationUID($data['uid']);
  675.                                 $em->persist($licenseSold);
  676.                                 $em->flush();
  678.                                 $historyResponse["actions"] = "Server station updated by initial login";
  680.                                 Util::logAction(
  681.                                     $em, 'LicenseDevice', 
  682.                                     $licenseSold->getId(), ActionHistory::ACTION_STATION_UPDATE, 'System', [
  683.                                         'data' => $historyResponse
  684.                                 ]);
  685.                             }
  687.                             ///// Limpiado de los otros dispositivos autorizados para el inicio de registro de estaciones de parte de una licencia
  688.                             $this->createFileJson($path, "Limpiado de dispositivos para que se permita el registro de nuevas estaciones segun dispositivos autorizados en '" . $accountLicenseData[0] . "'" . "\r");
  689.                             $em->getRepository('App\Entity\LicenseDevice')->clearLicenseDeviceNonServerRecordsForInitialLogin($accountLicenseData[0]->getId());
  690.                             
  691.                             Util::logAction(
  692.                                 $em, 'AccountLicense', 
  693.                                 $accountLicenseData[0]->getId(), ActionHistory::INITIAL_LOGIN, 'System', [
  694.                                     'data' => "Login completed successfully for license: " . $accountLicenseData[0]->getAlLicenseUsername()
  695.                             ]);
  696.                         }
  697.                         $this->createFileJson($pathXD, "splitedLogin => " . $splitedLogin . "\r");
  699.                         $data['license'] = $accountLicenseData[0]->getId();
  700.                         $data['isForSync'] = 1;
  701.                         $data['unactiveActiveZipcodes'] = 1;
  702.                         $data['validationByEdition'] = 0;
  704.                         $pushSendRepository = $em->getRepository('App\Entity\PushSent');
  705.                         $pushSendRepository->respondOldPushesForLicense(PushSent::PUSH_TYPE_LICENSE_RESET_UID, $accountLicenseData[0]->getId());
  707.                         $this->createFileJson($pathXD, "Has Loged OMT" . ' => ' . $accountLicenseData[0]->getHasLogedOMT());
  709.                         $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData[0]);
  711.                         $configuracion = $emLev->getRepository('App\Structure\Configuracion')->findAll();
  713.                         if (isset($configuracion[0])) {
  714.                             $configuracion[0]->setConfDeviceUid($accountLicenseData[0]->getDeviceUid());
  715.                             $emLev->persist($configuracion[0]);
  716.                             $emLev->flush();
  717.                         }
  719.                         if ($accountLicenseData[0]->getHasLogedOMT()) {
  720.                             $this->createFileJson($pathXD, "For call => makeSyncCleanseBecauseNewLogin");
  722.                             Util::makeSyncCleanseBecauseNewLogin($this->realContainer, $em, $path, $accountLicenseData[0]);
  724.                             $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData[0]);
  726.                             // Util::createSyncRecordsToOmtByUpdate($emLev, $accountLicenseData[0]);
  728.                             $emLev->clear();
  729.                             $emLev->close();
  731.                             Util::makeOwnSyncWebCurl($this->realContainer, ['nickname' => $data['alLicenseUsername']], $path);
  732.                         }
  734.                         if ($accountLicenseData[0]->getNeedZipcodes() && !$isSplitedAgain) {
  735.                             ForcedAsynchronousCommandsUtil::validateZipcodesToSyncAfterLogin($this->realContainer, $data, true);
  736.                         }
  738.                         $this->createFileJson($path, 'Login response -> ' . $jsonContent . "\r");
  740.                         $accountLicenseData[0]->setLastLoginDate(Util::getCurrentDate());
  742.                         $isThisLicenseVersion = Util::validateNewerVersion($accountLicenseData[0]->getAndroidVersionName(), $this->realContainer->getParameter('default_break_android_with_pusher'));
  744.                         if ($isThisLicenseVersion === $accountLicenseData[0]->getAndroidVersionName()) {
  745.                             $newPusherTokenCallResult = NewUtil::generateNewPusherVerificationToken($this->realContainer, $em, $accountLicenseData[0], $path);
  746.                             if (is_string($newPusherTokenCallResult)) {
  747.                                 $this->createFileJson($path, 'Error creating new pusher token -> ' . $newPusherTokenCallResult . "\r");
  748.                             } else {
  749.                                 $this->createFileJson($path, 'New pusher token created!'. "\r");
  750.                             }
  751.                         }
  753.                         if (!isset(json_decode($jsonContent)->splitedLogin)) {
  754.                             $accountLicenseData[0]->setLoginType(AccountLicense::LOGGED_BY_LEVEL_ANDROID);
  755.                             $accountLicenseData[0]->setHasAndroid(true);
  756.                         }
  757.                         // if ($accountLicenseData[0]->getLoginType() == AccountLicense::LOGGED_OUT) {
  758.                         //     $accountLicenseData[0]->setLoginType(AccountLicense::LOGGED_BY_LEVEL_ANDROID);
  759.                         // } else if ($accountLicenseData[0]->getLoginType() == AccountLicense::LOGGED_BY_LEVEL_LITE) {
  760.                         //     $accountLicenseData[0]->setLoginType(AccountLicense::LOGGED_BY_LEVEL_LITE_AND_ANDROID);
  761.                         // }
  762.                         $em->persist($accountLicenseData[0]);
  763.                         $em->flush();
  765.                         // Se valida que el parametro timeZone exista para guardarlo en las Tablas Configuracion y AccountLicense
  766.                         if (isset($data['timeZone']) && trim($data['timeZone']) !== '') {
  767.                             $timeZone = trim($data['timeZone']);
  768.                             $configuracion = $emLev->getRepository('App\Structure\Configuracion')->findAll();
  770.                             if (isset($configuracion[0])) {
  771.                                 $configuracion[0]->setTimeZoneRes($timeZone);
  772.                                 $emLev->persist($configuracion[0]);
  773.                                 $emLev->flush();
  774.                             }
  776.                             $accountLicenseData[0]->setTimeZoneRes($timeZone);
  777.                             $em->persist($accountLicenseData[0]);
  778.                             $em->flush();
  780.                         }
  782.                         $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData[0]);
  784.                         $deleteRegistActionPauseOrder = $emLev->getRepository('App\Structure\RegistActions')->deleteRegistActionPauseOrder($emLev);
  786.                         $emLev->clear();
  787.                         $emLev->close();
  789.                         return $this->respondWithItem($jsonContent, $theUrlTrSt);
  790.                     } elseif ($accountLicenseData[0]->getLevelLightUser() && isset($data["isLiteDevice"])) {
  791.                         /**  Flujo de un login correcto para level lite */
  792.                         /**  dump('Joder!'); */
  793.                         if ($accountLicenseData[0]->getLoginType() == AccountLicense::LOGGED_OUT) {
  794.                             $accountLicenseData[0]->setLoginType(AccountLicense::LOGGED_BY_LEVEL_LITE);
  795.                         } else if ($accountLicenseData[0]->getLoginType() == AccountLicense::LOGGED_BY_LEVEL_ANDROID) {
  796.                             $accountLicenseData[0]->setLoginType(AccountLicense::LOGGED_BY_LEVEL_LITE_AND_ANDROID);
  797.                         }
  799.                         $em->persist($accountLicenseData[0]);
  800.                         $em->flush();
  802.                         $userData = $accountLicenseData[0]->getLevelLightUser();
  804.                         $this->createFileJson($path, 'Util::doOMTDashboardLoginToGetToken 4!' . "\r");
  805.                         
  806.                         $apikey = Util::doOMTDashboardLoginToGetToken($this->realContainer, $userData, $path, $accountLicenseData[0]->getLoginType());
  807.                         if (!empty($apikey)) {
  808.                             $responseArr['userToOmt']['apikey'] = $apikey;
  809.                         }
  810.                         $responseArr['userToOmt']['username'] = $userData['username'];
  811.                         $responseArr['userToOmt']['password'] = $userData['realPass'];
  813.                         if (!isset($userData['realPass'])) {
  814.                             if ($accountLicenseData[0]->getHasLogedOMT() || $accountLicenseData[0]->getIsLevelLight() == true) {
  815.                                 $msnError = "The default OMT dashboard user doesn't have a password, please check the OMT database...";
  816.                                 $this->createFileJson($path, "\r" . 'LevelLite Error: ' . $msnError . "\r");
  817.                                 return $this->setStatusCode(WebService::HTTP_CODE_FORBIDDEN)
  818.                                                 ->respondWithError($msnError, WebService::CODE_COULD_NOT_AUTHENTICATE);
  819.                             } else {
  821.                                 if ($accountLicenseData[0]->getLastloguedDeviceKind() == AccountLicense::DEVICE_LITE_TYPE && $accountLicenseData[0]->getDeviceUid()) {
  822.                                     $accountLicenseData[0]->setDeviceUid(null);
  823.                                     $accountLicenseData[0]->setHasAndroid(null);
  824.                                     $accountLicenseData[0]->setWsResourceIdVerifiedAfterLogin(0);
  826.                                     $em->persist($accountLicenseData[0]);
  827.                                     $em->flush();
  828.                                 }
  830.                                 $msnError = $accountLicenseData[0] . " restaurant needs to be exported to OMT first!";
  831.                                 $this->createFileJson($path, "\r" . 'LevelLite Error: ' . $msnError . "\r");
  832.                                 return $this->setStatusCode(WebService::HTTP_CODE_FORBIDDEN)
  833.                                                 ->respondWithError($msnError, WebService::CODE_COULD_NOT_AUTHENTICATE);
  834.                             }
  835.                         }
  837.                         $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData[0]);
  839.                         //// If para asegurarse de la coincidencia de uids entre el license account y la configuracion para permitir la coreecta syn desde level web
  840.                         if ($accountLicenseData[0]->getLastloguedDeviceKind() == AccountLicense::DEVICE_LITE_TYPE) {
  841.                             $this->createFileJson($path, 'Setting of UID in configuration! :' . $accountLicenseData[0]->getDeviceUid() . "\r");
  842.                             $configuracion = $emLev->getRepository('App\Structure\Configuracion')->findAll();
  844.                             if (isset($configuracion[0])) {
  845.                                 $configuracion[0]->setConfDeviceUid($accountLicenseData[0]->getDeviceUid());
  846.                                 $emLev->persist($configuracion[0]);
  847.                                 $emLev->flush();
  848.                             }
  849.                         }
  851.                         //dump(':O');
  852.                         //die;
  854.                         $responseArr['status'] = WebService::HTTP_CODE_SUCCESS;
  855.                         $responseArr['msg'] = 'Valid level lite license!';
  856.                         $responseArr['bigbag'] = true;
  857.                         $responseArr['language'] = $language;
  859.                         if ($accountLicenseData[0]->getHasLogedOMT()) {
  860.                             // Util::createSyncRecordsToOmtByUpdate($emLev, $accountLicenseData[0]);
  861.                             $curlResponse = Util::makeOwnSyncWebCurl($this->realContainer, ['nickname' => $data['alLicenseUsername']], $path);
  863.                             $data['rwid'] = $curlResponse;
  865.                             ForcedAsynchronousCommandsUtil::consumeUpDownSyncCommand($this->realContainer, $data, true);
  866.                         }
  868.                         $emLev->clear();
  869.                         $emLev->close();
  871.                         $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  872.                         $xxArray = $theUrlTrSt->transform();
  874.                         $jsonContent = json_encode($xxArray);
  876.                         $splitedLogin = json_decode($jsonContent)->splitedLogin ?? null;
  877.                         if ($splitedLogin === (Util::definitionInitialMultipartLogin(0, true) - 1)) {
  878.                             Util::logAction(
  879.                                 $em, 'AccountLicense', 
  880.                                 $accountLicenseData[0]->getId(), ActionHistory::LEVELLITE_INITIAL_LOGIN, 'System', [
  881.                                     'data' => "Level Lite Login completed successfully for license: " . $accountLicenseData[0]->getAlLicenseUsername()
  882.                             ]);
  883.                         }
  884.                         $this->createFileJson($pathXD, "level lite splitedLogin => " . $splitedLogin . "\r");
  886.                         $accountLicenseData[0]->setLastLoginDate(Util::getCurrentDate());
  888.                         $em->persist($accountLicenseData[0]);
  889.                         $em->flush();
  891.                         return $this->respondWithItem($jsonContent, $theUrlTrSt);
  893.                     } else if (!isset($data["isLiteDevice"]) && strtolower($data['username']) == $userLite["username"]) {
  895.                         $accountLicenseData[0]->setLastloguedDeviceKind($oldLoguedDeviceKind);
  896.                         $em->persist($accountLicenseData[0]);
  897.                         $em->flush();
  899.                         // dump(isset($data["isLiteDevice"]),$data, $userLite);die;
  901.                         $this->createFileJson($path, "Error: User not valid for this platform");
  902.                         return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)
  903.                                         ->respondWithError('User not valid for this platform', WebService::CODE_INTERNAL_ERROR);
  904.                     } else {
  906.                         $accountLicenseData[0]->setLastloguedDeviceKind($oldLoguedDeviceKind);
  907.                         $em->persist($accountLicenseData[0]);
  909.                         $em->flush();
  911.                         $this->createFileJson($path, "Error: Error creating json file");
  912.                         return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)
  913.                                         ->respondWithError('Error creating json file', WebService::CODE_INTERNAL_ERROR);
  914.                     }
  915.                 } else {
  917.                     $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData[0]);
  919.                     $configuracion = $emLev->getRepository('App\Structure\Configuracion')->find(1);
  921.                     if (null == $oldUID || $oldUID == '') {
  923.                         $accountLicenseData[0]->setDeviceUid(null);
  924.                         $accountLicenseData[0]->setWsResourceIdVerifiedAfterLogin(0);
  925.                         $configuracion->setConfDeviceUid(null);
  927.                         $this->createFileJson($path, "\r" . '3 SETEO DE LEVEL UUID  IN CONFIG: IS NULL AND  HAS ANDROID : NULL' . "\r");
  928.                     
  929.                     } else {
  931.                         $this->createFileJson($path, "\r" . '4 SETEO DE LEVEL UUID  IN CONFIG: ' . $oldUID . ' AND  HAS ANDROID : NULL' . "\r");
  933.                         $accountLicenseData[0]->setDeviceUid($oldUID);
  934.                         $configuracion->setConfDeviceUid($oldUID);
  935.                     }
  937.                     $emLev->persist($configuracion);
  938.                     $emLev->flush();
  940.                     $em->persist($accountLicenseData[0]);
  941.                     $em->flush();
  943.                     $emLev->clear();
  944.                     $emLev->close();
  946.                     $this->createFileJson($path, "Error: Username not found");
  947.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  948.                                     ->respondWithError('Username not found', WebService::CODE_UNAUTHORIZED);
  949.                 }
  950.             } else {
  952.                 if (null == $oldUID || $oldUID == '') {
  954.                     $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData[0]);
  956.                     $configuracion = $emLev->getRepository('App\Structure\Configuracion')->find(1);
  958.                     $accountLicenseData[0]->setDeviceUid(null);
  959.                     $accountLicenseData[0]->setWsResourceIdVerifiedAfterLogin(0);
  960.                     $configuracion->setConfDeviceUid(null);
  961.                     $this->createFileJson($path, "\r" . '5 SETEO DE LEVEL UUID  IN CONFIG: IS OLDUID IS EMPTY AND  HAS ANDROID : NULL' . "\r");
  963.                     $accountLicenseData[0]->setHasAndroid(false);
  964.                     $configuracion->setConfHasAndriod(false);
  966.                     $emLev->persist($configuracion);
  967.                     $emLev->flush();
  969.                     $em->persist($accountLicenseData[0]);
  970.                     $em->flush();
  972.                     $emLev->clear();
  973.                     $emLev->close();
  974.                 } else {
  975.                     $accountLicenseData[0]->setDeviceUid($oldUID);
  976.                     $configuracion->setConfDeviceUid($oldUID);
  977.                     $this->createFileJson($path, "\r" . '6 SETEO DE LEVEL UUID  IN CONFIG: IS OLDUID ' . $oldUID . ' AND  HAS ANDROID : NULL' . "\r");
  978.                 }
  980.                 $this->createFileJson($path, "Error: Invalid login data please try again");
  981.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)->respondWithError('Invalid login data please try again', WebService::CODE_UNAUTHORIZED);
  982.             }
  984.         } catch (\Exception $th) {
  986.             $errorCode = uniqid();
  987.             $err = [
  988.                 'Error Message' => $th->getMessage(), 'Error Line' => $th->getLine(),
  989.                 'Error File' => $th->getFile(), 'Error Trace' => $th->getTrace()
  990.             ];
  992.             $this->createFileJson($path, "\r" . "Error Code => ". $errorCode . "\r");
  993.             $this->createFileJson($path, "\r" . json_encode($err) . "\r");
  995.             return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)->respondWithError('Internal Server Error, Please, Contact Team Licensor, Error Code: '. $errorCode, WebService::HTTP_CODE_INTERNAL_ERROR);
  996.         }
  997.     }
  999.     /**
  1000.      * Esta funcion permite al cliente adroid notificar que termino de
  1001.      * subir el archivo de sincronizacion
  1002.      * @author Aealan Z <lrobledo@kijho.com> 30/04/15
  1003.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  1004.      * @return Response Json con la informacion de respuesta
  1005.      */
  1006.     public function uploadSyncServiceUrl(Request $request) {
  1008.         // dump('Die');
  1009.         // die;
  1011.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  1013.             $arrayRequestEncripted = [];
  1014.             $arrayRequestEncripted['nickname'] = $request->request->get('nickname');
  1015.             $arrayRequestEncripted['uid'] = $request->request->get('uid');
  1016.             $arrayRequestEncripted['numberOfSyncDataRecords'] = $request->request->get('numberOfSyncDataRecords');
  1018.             $path = Util::getValidActiveLogByBaseName($this->realContainer, 'syncDownUpWS', 'syncDownUpWS0.txt');
  1019.             $this->createFileJson($path, "\r" . 'The request ' . json_encode($arrayRequestEncripted) . "\r");
  1021.             try {
  1022.                 $parameters = $request->request->all();
  1024.                 $this->createFileJson($path, 'All parameters in request -> ' . json_encode($parameters) . "\r");
  1026.                 $data = [];
  1027.                 $arrayEncryptResult = Util::decryptDataForUploadsFiles($this->realContainer, $request->request->get('nickname'));
  1028.                 $data['nickname'] = $arrayEncryptResult['data'];
  1030.                 $arrayEncryptResult = Util::decryptDataForUploadsFiles($this->realContainer, $request->request->get('uid'));
  1031.                 $data['uid'] = $arrayEncryptResult['data'];
  1033.                 $arrayEncryptResult = Util::decryptDataForUploadsFiles($this->realContainer, $request->request->get('numberOfSyncDataRecords'));
  1034.                 $data['numberOfSyncDataRecords'] = $arrayEncryptResult['data'];
  1036.                 $arrayEncryptResult = Util::decryptDataForUploadsFiles($this->realContainer, $request->request->get('prioritySMSOrderSync'));
  1037.                 $data['prioritySMSOrderSync'] = $arrayEncryptResult['data'];
  1039.                 $this->createFileJson($path, 'Decripted ' . json_encode($data) . "\r");
  1041.                 $theTrueNameFile = $request->files->get('file')->getClientOriginalName();
  1042.                 $this->createFileJson($path, 'The Client IP -> ' . $request->getClientIp() . "\r");
  1043.                 $this->createFileJson($path, 'The File -> ' . $theTrueNameFile . "\r");
  1045.                 $licenseUserName = ['alLicenseUsername' => $data['nickname']];
  1047.                 $em = $this->getDoctrine()->getManager();
  1048.                 $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findByAlLicenseUsername($licenseUserName);
  1050.                 $forcedValidationPassed = false;
  1052.                 if (empty($accountLicenseData) && (null == $data['nickname'] ||
  1053.                         empty($data['nickname']) || $data['nickname'] == 'null') &&
  1054.                         (int) $this->realContainer->getParameter('device_recognition_by_ip_enabled') &&
  1055.                         !empty($theTrueNameFile) && $theTrueNameFile != '') {
  1056.                     $this->createFileJson($path, 'Forcing server android autentication... ' . "\r");
  1057.                     $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findBy(['androidIP' => $request->getClientIp()]);
  1059.                     if (empty($accountLicenseData) || (int) $accountLicenseData[0]->getTimesCheckedIP() < (int) $this->realContainer->getParameter('ip_recognition_times_to_valid_check')) {
  1060.                         $accountLicenseData = [];
  1061.                     } else {
  1062.                         $forcedValidationPassed = true;
  1063.                         $this->createFileJson($path, 'Forced autentication succeeded! ' . "\r");
  1064.                     }
  1065.                 }
  1067.                 $countResult = count($accountLicenseData);
  1069.                 $this->createFileJson($path, 'Number of license found -> ' . $countResult . "\r");
  1071.                 if ($countResult > 0) {
  1072.                     if ($accountLicenseData[0]->getAlAccountLicense()->getDeleted()) {
  1073.                         $this->createFileJson($path, 'Salio 1! ' . "\r");
  1074.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  1075.                                         ->respondWithError('Account is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  1076.                     }
  1078.                     if (!$forcedValidationPassed && $accountLicenseData[0]->getDeviceUid() != $data['uid']) {
  1079.                         $this->createFileJson($path, 'Salio 2! ' . "\r");
  1080.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  1081.                                         ->respondWithError('Unknown device', WebService::CODE_ACCOUNT_SUSPENDED);
  1082.                     }
  1084.                     if ($accountLicenseData[0]->getAlLicenseStatus() == AccountLicense::LICENSE_STATUS_ACTIVE) {
  1086.                         $this->notifyLastSyncByLicense($em, $accountLicenseData[0]);
  1088.                         $this->createFileJson($path, 'License active! ' . "\r");
  1090.                         if (isset($data['numberOfSyncDataRecords'])) {
  1091.                             $accountLicenseData[0]->setNumberOfSyncDataRecords((int) $data['numberOfSyncDataRecords']);
  1093.                             $em->persist($accountLicenseData[0]);
  1094.                             $em->flush();
  1096.                             $licenseDataBaseEntity = $em->getRepository('App\Entity\LicenseDataBase')->findOneBy(['license' => $accountLicenseData[0]->getId()]);
  1098.                             if (!is_null($licenseDataBaseEntity)) {
  1099.                                 $this->createFileJson($path, 'Creating license database connection for => '. $data['nickname'] . "\r");
  1100.                                 $dataOptionsRoot = [
  1101.                                     'dbname' => $licenseDataBaseEntity->getDbname(),
  1102.                                     'user' => $licenseDataBaseEntity->getDbuser(),
  1103.                                     'password' => $licenseDataBaseEntity->getDbpass(),
  1104.                                     'host' => $licenseDataBaseEntity->getDbhost(),
  1105.                                     'driver' => 'pdo_mysql',
  1106.                                 ];
  1107.     
  1108.                                 $emLev = Util::emCreateConfiguration($this->realContainer, $dataOptionsRoot);
  1109.                                 $configuracion = $emLev->getRepository('App\Structure\Configuracion')->find(1);
  1110.                                 $configuracion->setNumberOfSyncDataRecords((int) $data['numberOfSyncDataRecords']);
  1111.                                 $configuracion->setMaxRecordsSyncUpDown((int) $this->realContainer->getParameter('max_records_sync_up_down'));
  1112.                                 $configuracion->setMaxRecordsSyncDownUp((int) $this->realContainer->getParameter('max_records_sync_down_up'));
  1113.                                 $emLev->persist($configuracion);
  1114.                                 $emLev->flush();
  1115.                             }else{
  1116.                                 $this->createFileJson($path, 'License database configuration not found from => '. $data['nickname'] . "\r");
  1117.                             }
  1118.                         }
  1120.                         $masterBlockingByDBUpdate = $em->getRepository('App\Entity\MasterSync')->findBy(['msLicense' => $accountLicenseData[0]->getId(), 'msType' => MasterSync::MASTER_SYNC_TYPE_DB_UPDATE, 'msStatus' => MasterSync::MASTER_STATUS_INITIALIZATED]);
  1122.                         if (!empty($masterBlockingByDBUpdate)) {
  1123.                             $this->createFileJson($path, 'Se Fue DB blocked!' . "\r");
  1124.                             return $this->setStatusCode(WebService::CODE_OBJECT_NOT_FOUND)
  1125.                                             ->respondWithError('Synchronization blocked by DB update, please wait...', WebService::NOTHING_TO_WEB_SYNCHRONIZE);
  1126.                         }
  1128.                         $masterSyncRecords = $em->getRepository('App\Entity\MasterSync')->findMastersSyncsDownUpInProcessToBlockNewSyncs($accountLicenseData[0]->getId());
  1130.                         $statusArryMsg = [];
  1132.                         $statusArryMsg['status'] = WebService::CODE_SUCCESS;
  1133.                         $statusArryMsg['msg'] = '';
  1135.                         if (!empty($masterSyncRecords)) {
  1136.                             $auxArrayResponse = Utilx::validateAndUnblockSyncsWithErrors($this->realContainer, $masterSyncRecords, $em, $accountLicenseData[0], $path);
  1138.                             if (isset($auxArrayResponse['continue']) && isset($auxArrayResponse['msg']) && !$auxArrayResponse['continue']) {
  1139.                                 $statusArryMsg['msg'] = $auxArrayResponse['msg'];
  1141.                                 $theUrlTrSt = new UploadSyncJsonNotifyTransformer($this->realContainer, $statusArryMsg);
  1142.                                 $jsonTransform = $theUrlTrSt->transform();
  1143.                                 $jsonContent = json_encode($jsonTransform);
  1145.                                 return $this->respondWithItem($jsonContent, $theUrlTrSt);
  1146.                             }
  1147.                         }
  1149.                         $readFilesDataEntity = $em->getRepository('App\Entity\ReadFilesData')->findBy(['rfStatus' => ReadFilesData::STATUS_UPLOADED, 'rfLicenseId' => $accountLicenseData[0]->getId(), 'hasPersistentError' => false]);
  1151.                         if (!empty($readFilesDataEntity)) {
  1152.                             $this->createFileJson($path, 'There is another sync petition in process, please wait until is finished' . "\r");
  1153.                             $statusArryMsg['msg'] = 'There is another sync petition in process, please wait until is finished';
  1155.                             $theUrlTrSt = new UploadSyncJsonNotifyTransformer($this->realContainer, $statusArryMsg);
  1156.                             $jsonTransform = $theUrlTrSt->transform();
  1157.                             $jsonContent = json_encode($jsonTransform);
  1159.                             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  1160.                         }
  1162.                         $readFilesDataEntity = $em->getRepository('App\Entity\ReadFilesData')->findBy(['rfStatus' => ReadFilesData::STATUS_UPLOADED, 'rfLicenseId' => $accountLicenseData[0]->getId(), 'hasPersistentError' => true]);
  1164.                         if (!empty($readFilesDataEntity)) {
  1165.                             $this->createFileJson($path, 'There is another sync petition for this license with a problem in the sever, please contact your system supplier for more information' . "\r");
  1166.                             $statusArryMsg['msg'] = 'There is another sync petition for this license with a problem in the sever, please contact your system supplier for more information';
  1168.                             $theUrlTrSt = new UploadSyncJsonNotifyTransformer($this->realContainer, $statusArryMsg);
  1169.                             $jsonTransform = $theUrlTrSt->transform();
  1170.                             $jsonContent = json_encode($jsonTransform);
  1172.                             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  1173.                         }
  1175.                         $numberOfOtherSyncsInProccess = $em->getRepository('App\Entity\ReadFilesData')->findMaxAmountOfIncomingAndroidSyncs();
  1177.                         if ($numberOfOtherSyncsInProccess >= (int) $this->realContainer->getParameter('max_concurret_down_up_sync')) {
  1178.                             $this->createFileJson($path, "There are '$numberOfOtherSyncsInProccess' another sync proccess in server, please try it later" . "\r");
  1179.                             $statusArryMsg['msg'] = "There are '$numberOfOtherSyncsInProccess' another sync proccess in server, please try it later";
  1181.                             $theUrlTrSt = new UploadSyncJsonNotifyTransformer($this->realContainer, $statusArryMsg);
  1182.                             $jsonTransform = $theUrlTrSt->transform();
  1183.                             $jsonContent = json_encode($jsonTransform);
  1185.                             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  1186.                         }
  1188.                         $isDirectoryReady = Util::createLicenseDirectory($this->realContainer, $accountLicenseData[0], $accountLicenseData[0]->getAlLicenseUsername());
  1189.                         $theAccountLicenseDirector = $isDirectoryReady['directory'];
  1191.                         if (!isset($isDirectoryReady['result']) || $isDirectoryReady['result'] == '__KO__') {
  1192.                             $msnError = 'An error occurred while creating your directory in server ';
  1193.                             return $this->setStatusCode(WebService::CODE_INTERNAL_ERROR)
  1194.                                             ->respondWithError($msnError, WebService::CODE_INTERNAL_ERROR);
  1195.                         }
  1197.                         $this->createFileJson($path, 'The license dir ' . $theAccountLicenseDirector . "\r");
  1198.                         $uploadFileResponse = Utilx::uploadFileTo($request, $theAccountLicenseDirector, $path);
  1200.                         if (!isset($uploadFileResponse['result']) || !isset($uploadFileResponse['msg'])) {
  1201.                             $this->createFileJson($path, 'Unknown error uploading file ' . "\r");
  1202.                             return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)
  1203.                                             ->respondWithError('Unknown error uploading file', WebService::CODE_INTERNAL_ERROR);
  1204.                         }
  1206.                         if (isset($uploadFileResponse['result']) && isset($uploadFileResponse['msg']) && $uploadFileResponse['result'] == '__KO__') {
  1207.                             $this->createFileJson($path, $uploadFileResponse['msg'] . "\r");
  1208.                             return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)
  1209.                                             ->respondWithError($uploadFileResponse['msg'], WebService::CODE_INTERNAL_ERROR);
  1210.                         }
  1212.                         $readFilesDataEntityByLicense = $em->getRepository('App\Entity\ReadFilesData')->findBy(['rfLicenseId' => $accountLicenseData[0]->getId(), 'rfStatus' => ReadFilesData::STATUS_STANDBY], ['rfDateSincAsk' => 'DESC']);
  1214.                         $this->createFileJson($path, 'The ReadFilesData count 1 -> ' . count($readFilesDataEntityByLicense) . "\r");
  1216.                         if (empty($readFilesDataEntityByLicense)) {
  1217.                             $readFilesDataEntityByLicense[0] = $this->setRegistNewFile($accountLicenseData[0]);
  1218.                         }
  1220.                         ///////////////// por aca iria la lectura del archivo subido para la prueba del NO_DATA
  1222.                         // dump($uploadFileResponse['fileDir']);
  1223.                         // dump(file_get_contents($uploadFileResponse['fileDir']));
  1224.                         // die;
  1226.                         $auxNoDataStringFromFile = file_get_contents($uploadFileResponse['fileDir']);
  1227.                         if (strpos($auxNoDataStringFromFile, "NO_DATA") && strlen($auxNoDataStringFromFile) < 40) {
  1228.                             $this->createFileJson($path, "No data file detected, closing opened sync... \r");
  1230.                             $masterSyncRecordToClose = $em->getRepository('App\Entity\MasterSync')->findBy(['msSyncRecord' => $readFilesDataEntityByLicense[0]->getId()]);
  1232.                             if (isset($masterSyncRecordToClose[0])) {
  1233.                                 $masterSyncRecordToClose[0]->setMsStatus(MasterSync::MASTER_STATUS_RESPONDED);
  1234.                                 $this->createFileJson($path, "Closing MasterSync with '" . $masterSyncRecordToClose[0]->getId() . "' id \r");
  1236.                                 $em->persist($masterSyncRecordToClose[0]);
  1237.                             } else {
  1238.                                 $this->createFileJson($path, 'Dafuq! o.O! ' . "\r");
  1239.                             }
  1241.                             $readFilesDataEntityByLicense[0]->setRfStatus(ReadFilesData::STATUS_DELIVERED);
  1242.                             $this->createFileJson($path, "Closing ReadFilesData with '" . $readFilesDataEntityByLicense[0]->getId() . "' id \r");
  1244.                             $accountLicenseData[0]->setNoDataFileDetected(1);
  1245.                             $em->persist($accountLicenseData[0]);
  1247.                             $em->persist($readFilesDataEntityByLicense[0]);
  1248.                             $em->flush();
  1250.                             $statusArryMsg['msg'] = 'No data file detected, closing opened sync...';
  1252.                             $theUrlTrSt = new UploadSyncJsonNotifyTransformer($this->realContainer, $statusArryMsg);
  1253.                             $jsonTransform = $theUrlTrSt->transform();
  1254.                             $jsonContent = json_encode($jsonTransform);
  1256.                             $this->createFileJson($path, 'Track X! ' . "\r");
  1257.                             $this->createFileJson($path, 'WS Response: ' . $jsonContent . "\r");
  1259.                             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  1260.                         } else {
  1261.                             $this->createFileJson($path, "Restoring NoDatFileDetectedFlag for '" . $accountLicenseData[0] . "' restaurant \r");
  1263.                             $accountLicenseData[0]->setNoDataFileDetected(0);
  1264.                             $em->persist($accountLicenseData[0]);
  1265.                             $em->flush();
  1266.                         }
  1268.                         $bucketFileLocation = Util::uploadSyncFileToS3Service($this->realContainer, $accountLicenseData[0], $uploadFileResponse['fileName'], $uploadFileResponse['fileDir'], $path);
  1269.                         $syncFileS3URI = 'https://' . $this->realContainer->getParameter('s3_bucket_name') . '.' . $this->realContainer->getParameter('s3_default_bucket_domain') . '/' . $bucketFileLocation;
  1271.                         $registerStatus = $this->updateRegistUploadFile($readFilesDataEntityByLicense[0], $uploadFileResponse['fileName'], $syncFileS3URI);
  1273.                         if ($registerStatus) {
  1274.                             $statusArryMsg['msg'] = 'File has been uploaded and the record updated';
  1275.                             $this->createFileJson($path, 'File has been uploaded and the record updated' . "\r");
  1276.                         } else {
  1277.                             $this->createFileJson($path, 'Salio 9! ' . "\r");
  1278.                             return $this->setStatusCode(WebService::HTTP_CODE_NOT_FOUND)
  1279.                                             ->respondWithError('Error updating syncronization control record', WebService::CODE_OBJECT_NOT_FOUND);
  1280.                         }
  1282.                         $licenseDataBaseEntity = $em->getRepository('App\Entity\LicenseDataBase')->findBy(['license' => $accountLicenseData[0]->getId()]);
  1284.                         if (!empty($licenseDataBaseEntity)) {
  1286.                             $pushSendRepository = $em->getRepository('App\Entity\PushSent');
  1287.                             $pushSendRepository->respondOldPushesForLicense(PushSent::PUSH_TYPE_SYNC_DOWNUP, $accountLicenseData[0]->getId());
  1289.                             $usernameByNickname = $licenseDataBaseEntity[0]->getLicense();
  1290.                             $theAccountPath = $this->realContainer->getParameter('level_directory_data_android') . $usernameByNickname->getAlAccountLicense()->getAcName() . '/' . $usernameByNickname->getAlLicenseUsername();
  1291.                             $theAccountPath = str_replace(' ', '_', $theAccountPath);
  1293.                             $dataOptionsRoot = [
  1294.                                 'dbname' => $licenseDataBaseEntity[0]->getDbname(),
  1295.                                 'user' => $licenseDataBaseEntity[0]->getDbuser(),
  1296.                                 'password' => $licenseDataBaseEntity[0]->getDbpass(),
  1297.                                 'host' => $licenseDataBaseEntity[0]->getDbhost(),
  1298.                                 'driver' => 'pdo_mysql',
  1299.                             ];
  1301.                             $msg = [
  1302.                                 'id' => $readFilesDataEntityByLicense[0]->getId(),
  1303.                                 'dataOptionsRoot' => $dataOptionsRoot,
  1304.                                 'path' => $theAccountPath,
  1305.                                 'fileName' => $readFilesDataEntityByLicense[0]->getRfNameFile(),
  1306.                                 'AccountLicense' => $usernameByNickname->getAlAccountLicense()->getAcName(),
  1307.                                 'pushchanel' => $usernameByNickname->getAlLicenseUsername()
  1308.                             ];
  1310.                             $readFilesDataEntityByLicense[0]->setIsReadedByServer(true);
  1311.                             $em->persist($readFilesDataEntityByLicense[0]);
  1312.                             $em->flush();
  1314.                             if (isset($data['prioritySMSOrderSync']) && $data['prioritySMSOrderSync']) {
  1315.                                 $this->get('priority_android_sync_producer')->setContentType('application/json');
  1316.                                 $this->get('priority_android_sync_producer')->setDeliveryMode(2);
  1317.                                 $this->get('priority_android_sync_producer')->publish(json_encode($msg));
  1318.                             } else {
  1319.                                 $this->get('incoming_android_sync_producer')->setContentType('application/json');
  1320.                                 $this->get('incoming_android_sync_producer')->setDeliveryMode(2);
  1321.                                 $this->get('incoming_android_sync_producer')->publish(json_encode($msg));
  1322.                             }
  1324.                             if (!$request->request->get('hold')) {
  1325.                                 $statusArryMsg['msg'] = 'File has been uploaded and the sync process triggered';
  1326.                                 $this->createFileJson($path, 'File has been uploaded and the sync process triggered' . "\r");
  1328.                                 $data['readFilesDataId'] = $readFilesDataEntityByLicense[0]->getId();
  1329.                                 
  1330.                                 ForcedAsynchronousCommandsUtil::consumeDownUpSyncCommand($this->realContainer, $data, true);
  1331.                             } else {
  1332.                                 $statusArryMsg['msg'] = 'File has been uploaded and the sync process is ready to start';
  1333.                                 $this->createFileJson($path, 'File has been uploaded and the sync process is ready to start' . "\r");
  1334.                             }
  1335.                         }
  1337.                         $this->createFileJson($path, 'Track 7! ' . "\r");
  1339.                         $theUrlTrSt = new UploadSyncJsonNotifyTransformer($this->realContainer, $statusArryMsg);
  1341.                         $jsonTransform = $theUrlTrSt->transform();
  1343.                         $jsonContent = json_encode($jsonTransform);
  1345.                         $this->createFileJson($path, 'Track 8! ' . "\r");
  1347.                         $this->createFileJson($path, 'UploadSyncJsonNotifyTransformer json to respond' . $jsonContent . "\r");
  1349.                         return $this->respondWithItem($jsonContent, $theUrlTrSt);
  1350.                     } else {
  1351.                         $this->createFileJson($path, 'Salio 3! ' . "\r");
  1352.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  1353.                                         ->respondWithError('Inactive License', WebService::CODE_ACCOUNT_SUSPENDED);
  1354.                     }
  1355.                 } else {
  1356.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  1357.                                     ->respondWithError('Invalid nickname', WebService::CODE_COULD_NOT_AUTHENTICATE);
  1358.                 }
  1359.             } catch (\Exception $th) {
  1360.                 $this->createFileJson($path, 'Error Message => '. $th->getMessage() . ' Error Line => '. $th->getLine() . ' Error Trace => '. $th->getTraceAsString() . "\r");
  1362.                 return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)
  1363.                                     ->respondWithError($th->getMessage(), WebService::HTTP_CODE_INTERNAL_ERROR);
  1364.             }
  1365.         } else {
  1366.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  1367.         }
  1368.     }
  1370.     /**
  1371.      * Esta funcion permite validar el acceso a la aplicacion web de level
  1372.      * validando codigo de usuario y contraseña y generando el apiKey
  1373.      * necesario para toda la aplicacion movil
  1374.      * @author Aealan Z <lrobledo@kijho.com> 28/03/15
  1375.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  1376.      * @return Response Json con la informacion de respuesta
  1377.      */
  1378.     public function syncFromWeb(Request $request) {
  1380.         $path = Util::getValidActiveLogByBaseName($this->realContainer, 'requestFromWeb', 'requestFromWeb0.txt');
  1382.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  1384.             if (0 !== strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT) && 0 !== strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE)) {
  1385.                 $this->createFileJson($path, 'Se Fue 6' . "\r");
  1386.                 return $this->errorWrongArgs('Wrong Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  1387.             }
  1389.             $params = json_decode($request->getContent(), true);
  1391.             $this->createFileJson($path, "\r" . 'Coming Content New Age: ' . json_encode($params) . "\r");
  1393.             $decodeInfo = Util::decodeInfo($params['nickname']);
  1394.             $this->createFileJson($path, 'Decode info: ' . $decodeInfo . "\r");
  1395.             $data = ['alLicenseUsername' => $decodeInfo];
  1397.             $em = $this->getDoctrine()->getManager();
  1398.             $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findByAlLicenseUsername($data);
  1399.             $countResult = count($accountLicenseData);
  1401.             $this->createFileJson($path, 'Count found: ' . $countResult . "\r");
  1403.             if ($countResult <= 0) {
  1404.                 $this->createFileJson($path, 'Se Fue 5' . "\r");
  1405.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  1406.                                 ->respondWithError('Invalid nickname', WebService::CODE_COULD_NOT_AUTHENTICATE);
  1407.             }
  1409.             $this->createFileJson($path, 'Entro coño! ' . $accountLicenseData[0]->getAlAccountLicense()->getDeleted() . "\r");
  1411.             if ($accountLicenseData[0]->getAlAccountLicense()->getDeleted() === true) {
  1412.                 $this->createFileJson($path, 'Se Fue 1: Account is inactive' . "\r");
  1413.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  1414.                                 ->respondWithError('Account is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  1415.             }
  1417.             if ($accountLicenseData[0]->getAlLicenseStatus() != AccountLicense::LICENSE_STATUS_ACTIVE) {
  1418.                 $this->createFileJson($path, 'Se Fue 4' . "\r");
  1419.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  1420.                                 ->respondWithError('Inactive License', WebService::CODE_ACCOUNT_SUSPENDED);
  1421.             }
  1423.             $priorityFlag = null;
  1424.             if (isset($params['priorityFlag'])) {
  1425.                 $priorityFlag = (int) $params['priorityFlag'];
  1426.             } 
  1428.             $this->createFileJson($path, 'pre notifyLastSyncByLicense ' . "\r");
  1430.             $this->notifyLastSyncByLicense($em, $accountLicenseData[0]);
  1432.             $masterBlockingByDBUpdate = $em->getRepository('App\Entity\MasterSync')->findBy(['msLicense' => $accountLicenseData[0]->getId(), 'msType' => MasterSync::MASTER_SYNC_TYPE_DB_UPDATE, 'msStatus' => MasterSync::MASTER_STATUS_INITIALIZATED]);
  1434.             if (!empty($masterBlockingByDBUpdate)) {
  1435.                 $this->createFileJson($path, 'Se Fue DB blocked!' . "\r");
  1436.                 return $this->setStatusCode(WebService::CODE_OBJECT_NOT_FOUND)
  1437.                                 ->respondWithError('Synchronization blocked by DB update, please wait...', WebService::NOTHING_TO_WEB_SYNCHRONIZE);
  1438.             }
  1440.             $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData[0]);
  1442.             $registActionRepository = $emLev->getRepository('App\Structure\RegistActions');
  1444.             $this->createFileJson($path, 'pre existCategoryRegistActionRecordToSync ' . "\r");
  1446.             $hasCategoryToSync = $registActionRepository->existCategoryRegistActionRecordToSync($this->realContainer->getParameter('max_records_sync_up_down'));
  1448.             if ($accountLicenseData[0]->getHasLogedOMT() && (int) $hasCategoryToSync) {
  1449.                 $this->createFileJson($path, 'pre validateMenuCategoryForOutgoingOMTSyncs ' . "\r");
  1450.                 Util::validateMenuCategoryForOutgoingOMTSyncs($emLev, $path, false);
  1451.             }
  1453.             $this->createFileJson($path, 'pre validateIfRestaurantCaDoAndroidDatabaseCleanse ' . "\r");
  1455.             $canSyncCleanseRecords = Util::validateIfRestaurantCaDoAndroidDatabaseCleanse($accountLicenseData[0], $emLev, $path);
  1457.             if (is_string($canSyncCleanseRecords)) {
  1458.                 $recordType = RegistActions::TYPE_GENERAL;
  1459.                 $this->createFileJson($path, 'Full sync with cleanse if there is one' . "\r");
  1460.                 $pendingToSyncDownRecord = $registActionRepository->alternateSmartGetRegistActionForUpDownSync($this->realContainer, RegistActions::STATUS_NOTREADED, RegistActions::TYPE_GENERAL, $this->realContainer->getParameter('max_records_sync_up_down'), $priorityFlag, $path);
  1461.                 // $pendingToSyncDownRecord = $registActionRepository->findBy(['reacStatus' => RegistActions::STATUS_NOTREADED, 'reacType' => RegistActions::TYPE_GENERAL], ['reacRegistFk' => 'DESC'], $this->realContainer->getParameter('max_records_sync_up_down'));
  1462.             } else {
  1463.                 $recordType = null;
  1464.                 $this->createFileJson($path, 'Without cleanse' . "\r");
  1465.                 $pendingToSyncDownRecord = $registActionRepository->alternateSmartGetRegistActionForUpDownSync($this->realContainer, RegistActions::STATUS_NOTREADED, null, $this->realContainer->getParameter('max_records_sync_up_down'), $priorityFlag, $path);
  1466.                 // $pendingToSyncDownRecord = $registActionRepository->findBy(['reacStatus' => RegistActions::STATUS_NOTREADED], ['reacRegistFk' => 'DESC'], $this->realContainer->getParameter('max_records_sync_up_down'));
  1467.             }
  1469.             // dump($pendingToSyncDownRecord);
  1471.             $recordsCount = count($pendingToSyncDownRecord);
  1472.             $auxRecordCount = $this->realContainer->getParameter('max_records_sync_up_down') - count($pendingToSyncDownRecord);
  1474.             if ($auxRecordCount > 0 && $priorityFlag !== false) {
  1475.                 $this->createFileJson($path, 'Completing max regist action records for sync ;) ' . "\r");
  1476.                 if (!empty($path)) {
  1477.                     $this->createFileJson($path, "'$recordsCount' total priority records were found... filling with normal records XD " . "\r");
  1478.                 }
  1480.                 $otherComplementingRegistActionRecords = $registActionRepository->alternateSmartGetRegistActionForUpDownSync($this->realContainer, RegistActions::STATUS_NOTREADED, $recordType, $auxRecordCount, false, $path);
  1481.                 $pendingToSyncDownRecord = array_merge($pendingToSyncDownRecord, $otherComplementingRegistActionRecords);
  1482.             }
  1484.             // dump($pendingToSyncDownRecord);
  1486.             $this->createFileJson($path, 'pre countPendigRecordsToPickupAndSync ' . "\r");
  1488.             $totalSyncRecords = $registActionRepository->countPendigRecordsToPickupAndSync();
  1489.             $countTotalSyncRecords = (int) $totalSyncRecords;
  1490.             $hasMoreRecordsToSync = false;
  1492.             $syncsToPerform = 1;
  1493.             if ($countTotalSyncRecords > $this->realContainer->getParameter('max_records_sync_up_down')) {
  1494.                 $hasMoreRecordsToSync = true;
  1495.                 $syncsToPerform = (int) ceil($countTotalSyncRecords / $this->realContainer->getParameter('max_records_sync_up_down'));
  1496.             }
  1498.             $responseArray = [];
  1500.             $responseArray['status'] = WebService::CODE_SUCCESS;
  1501.             $responseArray['result'] = '__OK__';
  1502.             $responseArray['wait'] = '__NO__';
  1503.             $responseArray['bigbag'] = true;
  1504.             $responseArray['hasMoreRecords'] = $hasMoreRecordsToSync;
  1505.             $responseArray['syncsToPerform'] = $syncsToPerform;
  1507.             $this->createFileJson($path, 'Count records to notify x2: ' . count($pendingToSyncDownRecord) . "\r");
  1509.             if (!empty($pendingToSyncDownRecord)) {
  1511.                 $this->createFileJson($path, 'The syncFK: ' . $pendingToSyncDownRecord[0]->getReacRegistFk() . "\r");
  1513.                 if (null == $pendingToSyncDownRecord[0]->getReacRegistFk() || $pendingToSyncDownRecord[0]->getReacRegistFk() == 0) {
  1514.                     $this->createFileJson($path, 'Records not picked yet! ' . "\r");
  1515.                     $auxResponseArray = Utilx::setRegistNewSyncWeb($this->realContainer, $em, $accountLicenseData[0], null, null, null, $syncsToPerform, $priorityFlag);
  1516.                     $responseArray['result'] = $auxResponseArray['result'];
  1517.                     $responseArray['rid'] = $auxResponseArray['rid'];
  1518.                     $this->createFileJson($path, 'The new record sync id to handle! ' . $responseArray['rid'] . "\r");
  1519.                 } else {
  1520.                     // $pendignMasterSyncRecord = $em->getRepository('App\Entity\MasterSync')->findBy(['msSyncWebRecord' => $pendingToSyncDownRecord[0]->getReacRegistFk(), 'msStatus' => MasterSync::MASTER_STATUS_INITIALIZATED]);
  1521.                     $pendignMasterSyncRecord = $em->getRepository('App\Entity\MasterSync')->findBy(['msSyncWebRecord' => $pendingToSyncDownRecord[0]->getReacRegistFk()]);
  1522.                     // $responseArray['hasMoreRecords'] = $hasMoreRecordsToSync;
  1524.                     //////
  1525.                     if (!empty($pendignMasterSyncRecord)) {
  1526.                         if ($pendignMasterSyncRecord[0]->getMsType() == MasterSync::MASTER_SYNC_TYPE_UPDOWN && $pendignMasterSyncRecord[0]->getMsStatus() == MasterSync::MASTER_STATUS_CLOSED && $pendignMasterSyncRecord[0]->getMsOMTStatus() == MasterSync::MASTER_STATUS_CLOSED) {
  1527.                             $this->createFileJson($path, 'Records about to be picked by validation, generating another web sync record! ' . "\r");
  1528.                             $auxResponseArray = Utilx::setRegistNewSyncWeb($this->realContainer, $em, $accountLicenseData[0], null, null, null, $syncsToPerform, $priorityFlag);
  1529.                             $responseArray['result'] = $auxResponseArray['result'];
  1530.                             $responseArray['rid'] = $auxResponseArray['rid'];
  1531.                             $this->createFileJson($path, 'The new records to sync with! ' . $responseArray['rid'] . "\r");
  1532.                         } else {
  1533.                             $responseArray['rid'] = $pendingToSyncDownRecord[0]->getReacRegistFk();
  1534.                             $this->createFileJson($path, 'Records picked by: ' . $responseArray['rid'] . "\r");
  1535.                         }
  1536.                     } else {
  1537.                         $this->createFileJson($path, 'Records about to be picked, generating another web sync record! ' . "\r");
  1538.                         $auxResponseArray = Utilx::setRegistNewSyncWeb($this->realContainer, $em, $accountLicenseData[0], null, null, null, $syncsToPerform, $priorityFlag);
  1539.                         $responseArray['result'] = $auxResponseArray['result'];
  1540.                         $responseArray['rid'] = $auxResponseArray['rid'];
  1541.                         $this->createFileJson($path, 'The new records to sync with! ' . $responseArray['rid'] . "\r");
  1542.                     }
  1543.                 }
  1545.                 // dump($pendingToSyncDownRecord);
  1546.                 // die;
  1548.                 $recordsJustForOMT = true;
  1549.                 $arrRegistActionsToDeleteAlready = [];
  1550.                 $arrAlreadyCheckedRegistActionRecord = [];
  1552.                 $auxArrayForRealRegistActionsRecordsToSync = [];
  1554.                 foreach ($pendingToSyncDownRecord as $registActionRecord) {
  1556.                     if (array_search($registActionRecord->getId(), $arrAlreadyCheckedRegistActionRecord) === false) {
  1557.                         $registActionRecord->setReacRegistFk($responseArray['rid']);
  1559.                         if (!$registActionRecord->getReacType() && !$registActionRecord->getReacOMTRegistFk()) {
  1560.                             $registActionRecord->setReacOMTRegistFk($responseArray['rid']);
  1561.                         }
  1563.                         $androidtname = Util::getAndroidTableName($registActionRecord->getReacTableName());
  1565.                         if ($recordsJustForOMT && (Util::getRepoServerNameByAndroidTableName($androidtname) || Util::getStructureEntityDirForForLicensorCorrespondigTable($androidtname))) {
  1566.                             $this->createFileJson($path, 'Has Android records to sync!!' . "\r");
  1567.                             $recordsJustForOMT = false;
  1568.                         }
  1569.                         array_push($arrRegistActionsToDeleteAlready, $registActionRecord->getId());
  1570.                         array_push($arrAlreadyCheckedRegistActionRecord, $registActionRecord->getId());
  1572.                         array_push($auxArrayForRealRegistActionsRecordsToSync, $registActionRecord);
  1574.                         $emLev->persist($registActionRecord);
  1575.                     }
  1576.                 }
  1578.                 $pendingToSyncDownRecord = $auxArrayForRealRegistActionsRecordsToSync;
  1580.                 // dump($pendingToSyncDownRecord);
  1582.                 if ($recordsJustForOMT) {
  1583.                     $this->createFileJson($path, 'Direct sync for OMT detected, moving forward with validations.... -_- ' . "\r");
  1584.                 }
  1586.                 // die;
  1588.                 $emLev->flush();
  1589.                 $this->createFileJson($path, 'New sync web fk?? -> ' . $responseArray['rid'] . "\r");
  1591.                 $masterSyncRecords = $em->getRepository('App\Entity\MasterSync')->findBy(['msSyncWebRecord' => $responseArray['rid']]);
  1593.                 if (!empty($masterSyncRecords) && !$recordsJustForOMT) {
  1594.                     $responseArray['msg'] = 'Processing new data..';
  1595.                     $responseArray['wait'] = '__NO__';
  1596.                     $responseArray['master_sync'] = $masterSyncRecords[0]->getId();
  1597.                     $responseArray['response_code'] = WebService::PROCESSING_UNNOTIFIED_WEB_DATA;
  1599.                     $webSyncWaiting = $masterSyncRecords[0]->getMsSyncWebRecord();
  1600.                     $this->createFileJson($path, 'Master sync record: ' . $masterSyncRecords[0]->getId() . "\r");
  1602.                     $this->createFileJson($path, 'One IF Status: ' . $webSyncWaiting->getRfwStatus() . ' Error: ' . !(boolean) $webSyncWaiting->getHasPersistentError() . "\r");
  1603.                     if ($webSyncWaiting->getRfwStatus() == ReadFilesDataWeb::STATUS_NOTIFIED && !(boolean) $webSyncWaiting->getHasPersistentError()) {
  1604.                         $isDirectoryReady = Util::createLicenseDirectory($this->realContainer, $accountLicenseData[0], $decodeInfo);
  1606.                         if (isset($isDirectoryReady['result']) && $isDirectoryReady['result'] == '__KO__') {
  1607.                             $this->createFileJson($path, 'Se Fue 1 ' . "\r");
  1608.                             $msnError = 'An error occurred while creating license directory in server ';
  1609.                             return $this->setStatusCode(WebService::CODE_INTERNAL_ERROR)
  1610.                                             ->respondWithError($msnError, WebService::CODE_INTERNAL_ERROR);
  1611.                         }
  1613.                         $this->createFileJson($path, 'Web ready sync: ' . $webSyncWaiting->getId() . "\r");
  1615.                         if ($webSyncWaiting->getIsReadedByServer()) {
  1616.                             $this->createFileJson($path, 'Web already picked by rabbit: TRUE' . "\r");
  1617.                             $responseArray['msg'] = 'Server is already synchronizing the new data to the android device, please wait.';
  1618.                             $responseArray['wait'] = '__YES__';
  1619.                             $responseArray['response_code'] = WebService::SERVER_ALREADY_WORKING_WEB_SYNC;
  1621.                             $theUrlTrSt = new SyncWebTransformer($responseArray);
  1622.                             $jsonTransform = $theUrlTrSt->transform();
  1624.                             $jsonContent = json_encode($jsonTransform);
  1626.                             return $this->respondWithURLWithoutEncriptControl($jsonContent, $theUrlTrSt);
  1627.                         }
  1629.                         $em->clear();
  1631.                         if (isset($params['waitTime']) && !(boolean) $params['waitTime'] && isset($responseArray['rid']) && $responseArray['rid'] != 0) {
  1632.                             ForcedAsynchronousCommandsUtil::produceUpDownSyncCommand($this->realContainer, $responseArray, true);
  1634.                             $this->createFileJson($path, 'No wait request triggered...' . "\r");
  1635.                         }
  1637.                         $theUrlTrSt = new SyncWebTransformer($responseArray);
  1638.                         $jsonTransform = $theUrlTrSt->transform();
  1640.                         $jsonContent = json_encode($jsonTransform);
  1642.                         $this->createFileJson($path, 'WS Response: ' . $jsonContent . "\r");
  1644.                         return $this->respondWithURLWithoutEncriptControl($jsonContent, $theUrlTrSt);
  1645.                     } else {
  1646.                         $pushRelatedRecord = $masterSyncRecords[0]->getMsPushRecord();
  1647.                         $responseArray['rid'] = 0;
  1648.                         $responseArray['response_code'] = 0;
  1649.                         $responseArray['master_sync'] = $masterSyncRecords[0]->getId();
  1651.                         if (!$pushRelatedRecord) {
  1652.                             $this->createFileJson($path, 'No push related to the master sync record' . "\r");
  1654.                             $responseArray['msg'] = 'Processing unnotified data..';
  1655.                             $responseArray['rid'] = $webSyncWaiting->getId();
  1656.                             $responseArray['response_code'] = WebService::PROCESSING_UNNOTIFIED_WEB_DATA;
  1658.                             if (isset($pendingToSyncDownRecord[0]) && $pendingToSyncDownRecord[0]->getReacStatus() == RegistActions::STATUS_NOTREADED && ReadFilesDataWeb::STATUS_RESPONSE_READED == $webSyncWaiting->getRfwStatus()) {
  1659.                                 ///// analizar si la licencia tiene OMT logueado y verificar si dichos registros son para OMT, si si, entonces enviarla desde aca directamente a OMT, si no, borrar los registros del regist action y asi evitar la inconsistencia
  1660.                                 
  1661.                                 if ($recordsJustForOMT && !$accountLicenseData[0]->getHasLogedOMT()) {
  1662.                                     $this->createFileJson($path, 'Deleting OMT RegistAction records to for non OMT license ;) ' . "\r");
  1663.                                     SyncWebUtil::deleteValidatedRegistAction($arrRegistActionsToDeleteAlready, [], $registActionRepository, false, true, $path);
  1665.                                     $this->createFileJson($path, 'Closing the related sync records ;) ' . "\r");
  1666.                                     $masterSyncRecords[0]->setMsStatus(MasterSync::MASTER_STATUS_CLOSED);
  1667.                                     $webSyncWaiting->setRfwStatus(ReadFilesDataWeb::STATUS_RESPONSE_READED);
  1668.                                     $webSyncWaiting->setIsReadedByServer(true);
  1670.                                     $em->persist($masterSyncRecords[0]);
  1671.                                     $em->persist($webSyncWaiting);
  1673.                                     $em->flush();
  1675.                                     $this->createFileJson($path, 'Preparing a propper ws response for this case ;) ' . "\r");
  1676.                                     $responseArray['msg'] = 'Cleaning web sync records, please try again in a few seconds...';
  1677.                                     $responseArray['wait'] = '__NO__';
  1678.                                     $responseArray['askAgain'] = 1;
  1679.                                     $responseArray['response_code'] = WebService::SERVER_ALREADY_WORKING_WEB_SYNC;
  1680.                                 } elseif ($recordsJustForOMT && $accountLicenseData[0]->getHasLogedOMT()) {
  1681.                                     //// amerita en elseif en donde se mande directo a OMT si la licencia si tiene OMT y estos registros andan asi como raros o mal cerrados
  1682.                                     $this->createFileJson($path, 'Sending forced sync direct to OMT!' . "\r");
  1683.                                     $data['rid'] = $webSyncWaiting->getId();
  1684.                                     $data['masterSyncId'] = $masterSyncRecords[0]->getId();
  1685.                                     $data['restaurantNickname'] = $data['alLicenseUsername'];
  1687.                                     $masterSyncRecords[0]->setMsStatus(MasterSync::MASTER_STATUS_CLOSED);
  1688.                                     if ($webSyncWaiting) {
  1689.                                         $webSyncWaiting->setRfwStatus(ReadFilesDataWeb::STATUS_RESPONSE_READED);
  1690.                                         $webSyncWaiting->setIsReadedByServer(true);
  1692.                                         $em->persist($webSyncWaiting);
  1693.                                     }
  1695.                                     $em->persist($masterSyncRecords[0]);
  1697.                                     $em->flush();
  1699.                                     $typeSync = UtilSync::hybridSync2OMT($this->realContainer, $em, $path, $data['alLicenseUsername']);
  1700.                                     // se valida el tipo de sync que se va a realizar
  1701.                                     if($typeSync){
  1702.                                         ForcedAsynchronousCommandsUtil::produceUpDownOMTSyncCommand($this->realContainer, $data, true);
  1703.                                     }else{
  1704.                                         // comando de cola para sync masiva
  1705.                                         ForcedAsynchronousCommandsUtil::produceUpDownOMTSyncMassiveCommand($this->realContainer, $data, $path, true);
  1706.                                     }
  1708.                                     $responseArray['msg'] = 'Direct sync to OMT';
  1709.                                     $responseArray['wait'] = '__NO__';
  1710.                                     $responseArray['askAgain'] = 1;
  1711.                                     $responseArray['master_sync'] = $masterSyncRecords[0]->getId();
  1712.                                     $responseArray['response_code'] = WebService::SERVER_ALREADY_WORKING_WEB_SYNC;
  1713.                                 } else {
  1714.                                     $this->createFileJson($path, 'Records bad closed by support, generating another web sync record! ' . "\r");
  1715.                                     // $auxResponseArray = Utilx::setRegistNewSyncWeb($this->realContainer, $em, $accountLicenseData[0], null, null, null, $syncsToPerform);
  1716.                                     $responseArray['result'] = $auxResponseArray['result'];
  1717.                                     $responseArray['rid'] = $auxResponseArray['rid'];
  1718.                                     $responseArray['master_sync'] = $masterSyncRecords[0]->getId();
  1719.                                     $responseArray['msg'] = 'Scheduling unprocessed sync records, please try to sync again in a few seconds';
  1720.                                     $this->createFileJson($path, 'The new records to sync with! ' . $responseArray['rid'] . " second chance \r");
  1721.                                     
  1722.                                     foreach ($pendingToSyncDownRecord as $registActionRecord) {
  1723.                                         $registActionRecord->setReacRegistFk($responseArray['rid']);
  1724.                                         if (!$registActionRecord->getReacType() && !$registActionRecord->getReacOMTRegistFk()) {
  1725.                                             $registActionRecord->setReacOMTRegistFk($responseArray['rid']);
  1726.                                         }
  1727.                                         $emLev->persist($registActionRecord);
  1728.                                     }
  1730.                                     $emLev->flush();
  1731.                                     $this->createFileJson($path, 'New sync web fk second chance?? -> ' . $responseArray['rid'] . "\r");
  1732.                                 }
  1733.                                 
  1734.                             } else {
  1735.                                 ////mandar a la cola de rabbit para que recoja los registros aun no procesados
  1736.                                 ForcedAsynchronousCommandsUtil::produceUpDownSyncCommand($this->realContainer, $responseArray, true);
  1737.                                 $this->createFileJson($path, 'No wait request triggered alternate 1 ...' . "\r");
  1738.                             }
  1739.                         } else {
  1740.                             if ($pushRelatedRecord->getPushStatus() == PushSent::STATUS_PUSH_PENDING) {
  1741.                                 $this->createFileJson($path, 'Pending for response push: ' . $pushRelatedRecord->getId() . "\r");
  1742.                                 $responseArray['msg'] = 'Push notification unconfirmed by android device, forwarding push to complete the synchronization process... ';
  1743.                                 $responseArray['wait'] = '__NO__';
  1744.                                 $responseArray['response_code'] = WebService::FORWARDING_UNNOTIFIED_WEB_PUSH;
  1745.                                 $responseArray['master_sync'] = $masterSyncRecords[0]->getId();
  1747.                                 $actualDate = Util::getCurrentDate();
  1748.                                 $actualDate->modify($this->realContainer->getParameter('maximum_minutes_to_validate_push_sending') . ' minutes');
  1750.                                 if ($pushRelatedRecord->getResendDate() < $actualDate) {
  1751.                                     $data['pushId'] = $pushRelatedRecord->getId();
  1752.                                     ForcedAsynchronousCommandsUtil::resendPushCommand($this->realContainer, $data, true);
  1753.                                 }
  1754.                             } else {
  1755.                                 if (isset($pendingToSyncDownRecord[0]) && $pendingToSyncDownRecord[0]->getReacStatus() == RegistActions::STATUS_NOTREADED && ReadFilesDataWeb::STATUS_RESPONSE_READED == $webSyncWaiting->getRfwStatus()) {
  1756.                                     if ($recordsJustForOMT && !$accountLicenseData[0]->getHasLogedOMT()) {
  1757.                                         $this->createFileJson($path, 'Deleting OMT RegistAction records to for non OMT license ;)) ' . "\r");
  1758.                                         SyncWebUtil::deleteValidatedRegistAction($arrRegistActionsToDeleteAlready, [], $registActionRepository, false, true, $path);
  1760.                                         $this->createFileJson($path, 'Closing the related sync records ;)) ' . "\r");
  1761.                                         $masterSyncRecords[0]->setMsStatus(MasterSync::MASTER_STATUS_CLOSED);
  1762.                                         $masterSyncRecords[0]->setMsOMTStatus(MasterSync::MASTER_STATUS_CLOSED);
  1763.                                         $webSyncWaiting->setRfwStatus(ReadFilesDataWeb::STATUS_RESPONSE_READED);
  1764.                                         $webSyncWaiting->setIsReadedByServer(true);
  1766.                                         $em->persist($masterSyncRecords[0]);
  1767.                                         $em->persist($webSyncWaiting);
  1769.                                         $em->flush();
  1771.                                         $this->createFileJson($path, 'Preparing a propper ws response for this case ;)) ' . "\r");
  1772.                                         $responseArray['msg'] = 'Cleaning web sync records, please try again in a few seconds...';
  1773.                                         $responseArray['wait'] = '__NO__';
  1774.                                         $responseArray['askAgain'] = 1;
  1775.                                         $responseArray['master_sync'] = $masterSyncRecords[0]->getId();
  1776.                                         $responseArray['response_code'] = WebService::SERVER_ALREADY_WORKING_WEB_SYNC;
  1777.                                     } elseif ($recordsJustForOMT && $accountLicenseData[0]->getHasLogedOMT()) {
  1778.                                         $this->createFileJson($path, 'Sending forced sync direct to OMT!!' . "\r");
  1779.                                         $data['rid'] = $webSyncWaiting->getId();
  1780.                                         $data['masterSyncId'] = $masterSyncRecords[0]->getId();
  1781.                                         $data['restaurantNickname'] = $data['alLicenseUsername'];
  1783.                                         $masterSyncRecords[0]->setMsStatus(MasterSync::MASTER_STATUS_CLOSED);
  1784.                                         $webSyncWaiting->setRfwStatus(ReadFilesDataWeb::STATUS_RESPONSE_READED);
  1785.                                         $webSyncWaiting->setIsReadedByServer(true);
  1787.                                         $em->persist($masterSyncRecords[0]);
  1788.                                         $em->persist($webSyncWaiting);
  1790.                                         $em->flush();
  1792.                                         $typeSync = UtilSync::hybridSync2OMT($this->container, $em, $path, $data['alLicenseUsername']);
  1793.                                         // se valida el tipo de sync que se va a realizar
  1794.                                         if($typeSync){
  1795.                                             $this->createFileJson($path, 'Sending standard sync direct to OMT 1 !!' . "\r");
  1796.                                             ForcedAsynchronousCommandsUtil::produceUpDownOMTSyncCommand($this->container, $data, true);
  1797.                                         }else{
  1798.                                             // comando de cola para sync masiva
  1799.                                             $this->createFileJson($path, 'Sending hybrid sync direct to OMT 1 !!' . "\r");
  1800.                                             ForcedAsynchronousCommandsUtil::produceUpDownOMTSyncMassiveCommand($this->container, $data, $path, true);
  1801.                                         }
  1803.                                         $responseArray['msg'] = 'Direct sync to OMT';
  1804.                                         $responseArray['wait'] = '__NO__';
  1805.                                         $responseArray['askAgain'] = 1;
  1806.                                         $responseArray['master_sync'] = $masterSyncRecords[0]->getId();
  1807.                                         $responseArray['response_code'] = WebService::SERVER_ALREADY_WORKING_WEB_SYNC;
  1808.                                     } else {
  1809.                                         $this->createFileJson($path, 'Records bad closed by support, generating another web sync record! ' . "\r");
  1810.                                         // $auxResponseArray = Utilx::setRegistNewSyncWeb($this->realContainer, $em, $accountLicenseData[0], null, null, null, $syncsToPerform);
  1811.                                         $responseArray['result'] = $auxResponseArray['result'];
  1812.                                         $responseArray['rid'] = $auxResponseArray['rid'];
  1813.                                         $responseArray['msg'] = 'Scheduling unprocessed sync records, please try to sync again in a few seconds';
  1814.                                         $responseArray['master_sync'] = $masterSyncRecords[0]->getId();
  1815.                                         $this->createFileJson($path, 'The new records to sync with! ' . $responseArray['rid'] . " second chance \r");
  1816.                                         
  1817.                                         foreach ($pendingToSyncDownRecord as $registActionRecord) {
  1818.                                             $registActionRecord->setReacRegistFk($responseArray['rid']);
  1819.                                             if (!$registActionRecord->getReacType() && !$registActionRecord->getReacOMTRegistFk()) {
  1820.                                                 $registActionRecord->setReacOMTRegistFk($responseArray['rid']);
  1821.                                             }
  1822.                                             $emLev->persist($registActionRecord);
  1823.                                         }
  1825.                                         $emLev->flush();
  1826.                                         $this->createFileJson($path, 'New sync web fk second chance?? -> ' . $responseArray['rid'] . "\r");
  1827.                                     }
  1828.                                 } else {
  1829.                                     $this->createFileJson($path, 'Sync unresponded by android device: ' . $pushRelatedRecord->getId() . "\r");
  1830.                                     $responseArray['msg'] = 'Forwarding push with new code to complete the synchronization process...';
  1831.                                     $responseArray['wait'] = '__YES__';
  1832.                                     $responseArray['response_code'] = WebService::FORWARDING_UNNOTIFIED_WEB_PUSH;
  1834.                                     $actualDate = Util::getCurrentDate();
  1835.                                     $actualDate->modify($this->realContainer->getParameter('maximum_minutes_to_validate_push_sending') . ' minutes');
  1837.                                     if ($pushRelatedRecord->getResendDate() < $actualDate) {
  1838.                                         $data['pushId'] = $pushRelatedRecord->getId();
  1839.                                         $data['forcePushNewCode'] = true;
  1841.                                         ForcedAsynchronousCommandsUtil::resendPushCommand($this->realContainer, $data, true);
  1842.                                     }
  1843.                                 }
  1844.                             }
  1845.                         }
  1846.                     }
  1848.                     $theUrlTrSt = new SyncWebTransformer($responseArray);
  1849.                     $jsonTransform = $theUrlTrSt->transform();
  1851.                     $jsonContent = json_encode($jsonTransform);
  1853.                     $this->createFileJson($path, 'WS Response: ' . $jsonContent . "\r");
  1855.                     return $this->respondWithURLWithoutEncriptControl($jsonContent, $theUrlTrSt);
  1856.                 } elseif (!empty($masterSyncRecords) && $recordsJustForOMT) {
  1858.                     $responseArray['master_sync'] = $masterSyncRecords[0]->getId();
  1860.                     $webSyncWaiting = $masterSyncRecords[0]->getMsSyncWebRecord();
  1862.                     if (!$accountLicenseData[0]->getHasLogedOMT()) {
  1863.                         $this->createFileJson($path, 'Deleting OMT RegistAction records to for non OMT license ;)) ' . "\r");
  1864.                         SyncWebUtil::deleteValidatedRegistAction($arrRegistActionsToDeleteAlready, [], $registActionRepository, false, true, $path);
  1866.                         $this->createFileJson($path, 'Closing the related sync records ;)) ' . "\r");
  1867.                         $masterSyncRecords[0]->setMsStatus(MasterSync::MASTER_STATUS_CLOSED);
  1868.                         $masterSyncRecords[0]->setMsOMTStatus(MasterSync::MASTER_STATUS_CLOSED);
  1869.                         if ($webSyncWaiting) {
  1870.                             $webSyncWaiting->setRfwStatus(ReadFilesDataWeb::STATUS_RESPONSE_READED);
  1871.                             $webSyncWaiting->setIsReadedByServer(true);
  1873.                             $em->persist($webSyncWaiting);
  1874.                         }
  1876.                         $em->persist($masterSyncRecords[0]);
  1878.                         $em->flush();
  1880.                         $this->createFileJson($path, 'Preparing a propper ws response for this case ;)) ' . "\r");
  1881.                         $responseArray['msg'] = 'Cleaning web sync records, please try again in a few seconds...';
  1882.                         $responseArray['wait'] = '__NO__';
  1883.                         $responseArray['askAgain'] = 1;
  1884.                         $responseArray['response_code'] = WebService::SERVER_ALREADY_WORKING_WEB_SYNC;
  1885.                     } else {
  1886.                         $this->createFileJson($path, 'Sending forced sync direct to OMT!!' . "\r");
  1887.                         $data['rid'] = $webSyncWaiting->getId();
  1888.                         $data['masterSyncId'] = $masterSyncRecords[0]->getId();
  1889.                         $data['restaurantNickname'] = $data['alLicenseUsername'];
  1891.                         $masterSyncRecords[0]->setMsStatus(MasterSync::MASTER_STATUS_CLOSED);
  1892.                         if ($webSyncWaiting) {
  1893.                             $webSyncWaiting->setRfwStatus(ReadFilesDataWeb::STATUS_RESPONSE_READED);
  1894.                             $webSyncWaiting->setIsReadedByServer(true);
  1896.                             $em->persist($webSyncWaiting);
  1897.                         }
  1899.                         $em->persist($masterSyncRecords[0]);
  1901.                         $em->flush();
  1903.                         $typeSync = UtilSync::hybridSync2OMT($this->realContainer, $em, $path, $data['alLicenseUsername']);
  1904.                         // se valida el tipo de sync que se va a realizar
  1905.                         if($typeSync){
  1906.                             $this->createFileJson($path, 'Sending standard sync direct to OMT 2 !!' . "\r");
  1907.                             ForcedAsynchronousCommandsUtil::produceUpDownOMTSyncCommand($this->realContainer, $data, true);
  1908.                         }else{
  1909.                             // comando de cola para sync masiva
  1910.                             $this->createFileJson($path, 'Sending hybrid sync direct to OMT 2 !!' . "\r");
  1911.                             ForcedAsynchronousCommandsUtil::produceUpDownOMTSyncMassiveCommand($this->realContainer, $data, $path, true);
  1912.                         }
  1914.                         $responseArray['msg'] = 'Direct sync to OMT';
  1915.                         $responseArray['wait'] = '__NO__';
  1916.                         $responseArray['askAgain'] = 1;
  1917.                         $responseArray['response_code'] = WebService::SERVER_ALREADY_WORKING_WEB_SYNC;
  1918.                     }
  1919.                 } else {
  1920.                     $this->createFileJson($path, 'Se Fue 2' . "\r");
  1921.                     $msnError = 'Nothing to synchronize! ';
  1922.                     return $this->setStatusCode(WebService::CODE_OBJECT_NOT_FOUND)
  1923.                                     ->respondWithError($msnError, WebService::NOTHING_TO_WEB_SYNCHRONIZE);
  1924.                 }
  1926.                 $theUrlTrSt = new SyncWebTransformer($responseArray);
  1927.                 $jsonTransform = $theUrlTrSt->transform();
  1929.                 $jsonContent = json_encode($jsonTransform);
  1931.                 $this->createFileJson($path, 'WS Response: ' . $jsonContent . "\r");
  1933.                 return $this->respondWithURLWithoutEncriptControl($jsonContent, $theUrlTrSt);
  1934.             } else {
  1935.                 $masterSyncRecords = $em->getRepository('App\Entity\MasterSync')->findBy(['msLicense' => $accountLicenseData[0]->getId(), 'msType' => MasterSync::MASTER_SYNC_TYPE_UPDOWN, 'msStatus' => MasterSync::MASTER_STATUS_PROCESSED], ['id' => 'ASC']);
  1937.                 if (!empty($masterSyncRecords)) {
  1938.                     $this->createFileJson($path, 'Uncomplet master record found -> ' . $masterSyncRecords[0]->getId() . "\r");
  1940.                     $webSyncWaiting = $masterSyncRecords[0]->getMsSyncWebRecord();
  1941.                     $pushRelatedRecord = $masterSyncRecords[0]->getMsPushRecord();
  1942.                     $responseArray['rid'] = 0;
  1943.                     $responseArray['master_sync'] = $masterSyncRecords[0]->getId();
  1945.                     if (!$pushRelatedRecord) {
  1946.                         $this->createFileJson($path, 'No push related to the master sync record' . "\r");
  1948.                         $responseArray['msg'] = 'Processing unnotified data..';
  1949.                         $responseArray['rid'] = $webSyncWaiting->getId();
  1950.                         $responseArray['response_code'] = WebService::PROCESSING_UNNOTIFIED_WEB_DATA;
  1951.                     } else {
  1952.                         if ($pushRelatedRecord->getPushStatus() == PushSent::STATUS_PUSH_PENDING) {
  1953.                             $this->createFileJson($path, 'Pending for response push: ' . $pushRelatedRecord->getId() . "\r");
  1954.                             $responseArray['msg'] = 'Push notification unconfirmed by android device, forwarding push to complete the synchronization process... ';
  1955.                             $responseArray['wait'] = '__NO__';
  1956.                             $responseArray['response_code'] = WebService::FORWARDING_UNNOTIFIED_WEB_PUSH;
  1958.                             $actualDate = Util::getCurrentDate();
  1959.                             $actualDate->modify($this->realContainer->getParameter('maximum_minutes_to_validate_push_sending') . ' minutes');
  1961.                             if ($pushRelatedRecord->getResendDate() < $actualDate) {
  1962.                                 $data['pushId'] = $pushRelatedRecord->getId();
  1963.                                 ForcedAsynchronousCommandsUtil::resendPushCommand($this->realContainer, $data, true);
  1964.                             }
  1965.                         } else {
  1966.                             $this->createFileJson($path, 'Sync unresponded by android device: ' . $pushRelatedRecord->getId() . "\r");
  1967.                             $responseArray['msg'] = 'Forwarding push with new code to complete the synchronization process...';
  1968.                             $responseArray['wait'] = '__YES__';
  1969.                             $responseArray['response_code'] = WebService::FORWARDING_UNNOTIFIED_WEB_PUSH;
  1971.                             $actualDate = Util::getCurrentDate();
  1972.                             $actualDate->modify($this->realContainer->getParameter('maximum_minutes_to_validate_push_sending') . ' minutes');
  1974.                             if ($pushRelatedRecord->getResendDate() < $actualDate) {
  1975.                                 $data['pushId'] = $pushRelatedRecord->getId();
  1976.                                 $data['forcePushNewCode'] = true;
  1978.                                 ForcedAsynchronousCommandsUtil::resendPushCommand($this->realContainer, $data, true);
  1979.                             }
  1980.                         }
  1981.                     }
  1982.                 } else {
  1983.                     $masterBlockingByFalseSync = $em->getRepository('App\Entity\MasterSync')->findBy(['msLicense' => $accountLicenseData[0]->getId(), 'msType' => MasterSync::MASTER_SYNC_TYPE_UPDOWN, 'msStatus' => MasterSync::MASTER_STATUS_INITIALIZATED]);
  1985.                     foreach ($masterBlockingByFalseSync as $falseMasterSync) {
  1986.                         Utilx::updateRegistCloseByEmptySyncFile($em, $falseMasterSync, $path);
  1987.                     }
  1989.                     $this->createFileJson($path, 'Se Fue 3' . "\r");
  1990.                     $msnError = 'Nothing to synchronize! ';
  1991.                     return $this->setStatusCode(WebService::CODE_OBJECT_NOT_FOUND)
  1992.                                     ->respondWithError($msnError, WebService::NOTHING_TO_WEB_SYNCHRONIZE);
  1993.                 }
  1995.                 $theUrlTrSt = new SyncWebTransformer($responseArray);
  1996.                 $jsonTransform = $theUrlTrSt->transform();
  1998.                 $jsonContent = json_encode($jsonTransform);
  2000.                 $this->createFileJson($path, 'WS Response: ' . $jsonContent . "\r");
  2002.                 return $this->respondWithURLWithoutEncriptControl($jsonContent, $theUrlTrSt);
  2003.             }
  2004.         } else {
  2005.             $this->createFileJson($path, 'Se Fue 7' . "\r");
  2006.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  2007.         }
  2008.     }
  2010.     /**
  2011.      * Funcion tipo polling para activar el consumidor de una sincronizacion de
  2012.      * arriba a abajo ya encolada por medio de la solicitud de un ajax
  2013.      * @author Aealan Z <lrobledo@kijho.com> 11/06/2016
  2014.      * @param Request $request peticion realizada por medio de un ajax
  2015.      * @param type $id id del registro de sincronizacion web de esa licencia
  2016.      * @return type repuesta de la sincronizacion para el ajax en formato json
  2017.      */
  2018.     public function activateWebConsumerByAjax(Request $request, $id) {
  2020.         $em = $this->getDoctrine()->getManager();
  2022.         $path = Util::getValidActiveLogByBaseName($this->realContainer, 'requestFromWebYYY', 'requestFromWebYYY0.txt');
  2024.         $paramNick = $request->request->get('nickname');
  2025.         if ($paramNick == null) {
  2026.             $paramNick = $request->query->get('nickname');
  2027.         }
  2029.         $this->createFileJson($path, 'Searching sync with id: ' . $id . "\r");
  2031.         $syncWebRecord = $em->getRepository('App\Entity\ReadFilesDataWeb')->find($id);
  2033.         $this->createFileJson($path, 'Instant Request Auch -> Llego Llego!' . "\r");
  2035.         if ($syncWebRecord) {
  2037.             for ($i = 0; $i <= 4; $i++) {
  2039.                 if ($paramNick != $syncWebRecord->getRfwLicenseId()->getAlLicenseUsername()) {
  2041.                     $responseToAjax['msg'] = 'License Not Found!';
  2042.                     $responseToAjax['result'] = '__KO__';
  2044.                     return $this->respondJsonAjax($responseToAjax);
  2045.                 }
  2047.                 $responseToAjax['result'] = '__OK__';
  2049.                 sleep(4);
  2051.                 $this->createFileJson($path, 'Instant Request Auch -> ' . $syncWebRecord->getIsReadedByServer() . ' | ' . $syncWebRecord->getRfwStatus() . "\r");
  2053.                 $statusReadFileWeb = $em->getRepository('App\Entity\ReadFilesDataWeb')->find($id);
  2054.                 $statusSyncMaster = $em->getRepository('App\Entity\MasterSync')->findBy(['msSyncWebRecord' => $id]);
  2056.                 if ($statusSyncMaster[0]->getMsType() == MasterSync::MASTER_SYNC_TYPE_UPDOWN &&
  2057.                 $statusSyncMaster[0]->getMsStatus() == MasterSync::MASTER_STATUS_PROCESSED &&
  2058.                 $statusSyncMaster[0]->getMsPushRecord() !== null &&
  2059.                 ReadFilesDataWeb::STATUS_READED_DELIVERED == $statusReadFileWeb->getRfwStatus()) {
  2061.                     $em->clear();
  2063.                     $this->createFileJson($path, 'Instant Request Processed!' . "\r");
  2065.                     $responseToAjax['msg'] = 'Data for the Android server send, please check for the new data!';
  2066.                     $responseToAjax['response_code'] = WebService::WEB_DATA_SENDED_TO_ANDROID;
  2067.                     break;
  2069.                 } else if ($syncWebRecord->getIsReadedByServer() && ReadFilesDataWeb::STATUS_NOTIFIED == $syncWebRecord->getRfwStatus()) {
  2071.                     $em->clear();
  2073.                     $data['rwid'] = $syncWebRecord->getId();
  2074.                     ForcedAsynchronousCommandsUtil::consumeUpDownSyncCommand($this->realContainer, $data, true);
  2076.                     $this->createFileJson($path, 'Instant Request Processed!' . "\r");
  2078.                     $responseToAjax['msg'] = 'The data is being processed, please verify the changes in a few seconds...';
  2079.                     $responseToAjax['response_code'] = WebService::WEB_DATA_SENDED_TO_ANDROID;
  2081.                     break;
  2083.                 } else {
  2084.                     $responseToAjax['msg'] = 'Server is working... Please try 20 seconds latter!';
  2085.                     $responseToAjax['response_code'] = WebService::SERVER_ALREADY_WORKING_WEB_SYNC;
  2086.                 }
  2087.             }
  2089.         } else {
  2091.             if ($id == 0) {
  2093.                 $this->createFileJson($path, 'Instant Request Push Resend -> XD' . "\r");
  2095.                 sleep(4);
  2097.                 $responseToAjax['msg'] = 'Push forwarded, please check the Android server!';
  2098.                 $responseToAjax['result'] = '__KO__';
  2099.                 $responseToAjax['response_code'] = WebService::FORWARDING_UNNOTIFIED_WEB_PUSH;
  2101.             } else {
  2103.                 $this->createFileJson($path, 'Instant Request Auch -> License sync web record not found!' . "\r");
  2105.                 $responseToAjax['msg'] = 'License sync web record not found!';
  2106.                 $responseToAjax['result'] = '__KO__';
  2107.             }
  2109.             return $this->respondJsonAjax($responseToAjax);
  2110.         }
  2112.         return $this->respondJsonAjax($responseToAjax);
  2113.     }
  2115.     /**
  2116.      * Funcion que solicitar una sincronizacion de arriba a abajo a un servidor
  2117.      * android por medio de un push
  2118.      * @author Aealan Z <lrobledo@kijho.com> 11/06/2016
  2119.      * @param Request $request solicitud que llega por ajax pidiendo una sincronizacion de abajo a arriba
  2120.      * @param type $id id de la licencia a la cual se le solicita la sincronizacion
  2121.      * @return type respuesta del envio del push que solicita la sincronizacion de tipo json para un ajax
  2122.      */
  2123.     public function activateAndroidSyncManually(Request $request, $id) {
  2125.         $em = $this->getDoctrine()->getManager();
  2126.         $path = Util::getValidActiveLogByBaseName($this->realContainer, 'requestForManuallySync', 'requestForManuallySync0.txt');
  2128.         $paramNick = $request->request->get('nickname');
  2130.         if ($paramNick == null) {
  2131.             $paramNick = $request->query->get('nickname');
  2132.         }
  2134.         $this->createFileJson($path, "\r" . 'Sync Android Up Manually: ' . $paramNick . "\r");
  2135.         $licenseToSync = $em->getRepository('App\Entity\AccountLicense')->find($id);
  2137.         if ($licenseToSync) {
  2139.             if ($paramNick != $licenseToSync->getAlLicenseUsername()) {
  2140.                 $this->createFileJson($path, 'Bad nickname!' . "\r");
  2141.                 $responseToAjax['msg'] = 'License not found!';
  2142.                 $responseToAjax['result'] = '__KO__';
  2144.                 return $this->respondJsonAjax($responseToAjax);
  2145.             }
  2147.             $this->createFileJson($path, 'Sync Android Up Manually: License Found!' . "\r");
  2149.             $masterBlockingByDBUpdate = $em->getRepository('App\Entity\MasterSync')->findBy(['msLicense' => $licenseToSync->getId(), 'msType' => MasterSync::MASTER_SYNC_TYPE_DB_UPDATE, 'msStatus' => MasterSync::MASTER_STATUS_INITIALIZATED]);
  2151.             if (!empty($masterBlockingByDBUpdate)) {
  2152.                 $this->createFileJson($path, 'Synchronization blocked by DB update, please wait...' . "\r");
  2153.                 $responseToAjax['msg'] = 'Synchronization blocked by DB update, please wait...';
  2154.                 $responseToAjax['result'] = '__KO__';
  2155.                 $responseToAjax['response_code'] = WebService::SYNC_BLOQUED_DB;
  2157.                 return $this->respondJsonAjax($responseToAjax);
  2158.             }
  2160.             $this->createFileJson($path, 'No blocked synchronization by DB update, moving forward...' . "\r");
  2162.             $infiniteSyncIdentified = false;
  2164.             if ($licenseToSync->getAlLockedByInfiniteSync() == false && $licenseToSync->getLastLoginDate() != null) {
  2166.                 $resultCheck = Utilx::validateAndLockLicenseWithInfiniteSync($em, $this->realContainer, $licenseToSync);
  2167.                 $infiniteSyncIdentified = !$resultCheck["continue"] ;
  2168.             }
  2170.             if ($infiniteSyncIdentified == true || $licenseToSync->getAlLockedByInfiniteSync() == true) {
  2172.                 $this->createFileJson($path, 'Sync blocked by infinite loop problems issues' . "\r");
  2174.                 $responseToAjax['msg'] = 'Sync blocked by infinite loop problems issues';
  2175.                 $responseToAjax['result'] = '__KO__';
  2176.                 $responseToAjax['response_code'] = WebService::SYNC_LOCKED_BY_INFINITE_LOOP;
  2178.                 return $this->respondJsonAjax($responseToAjax);
  2179.             }
  2181.             $this->createFileJson($path, 'No blocked synchronization by by infinite loop issues, moving forward...' . "\r");
  2183.             $masterSyncRecords = $em->getRepository('App\Entity\MasterSync')->findMastersSyncsDownUpInProcessToBlockNewSyncs($licenseToSync->getId());
  2185.             if (!empty($masterSyncRecords)) {
  2187.                 $auxArrayResponse = Utilx::validateAndUnblockSyncsWithErrors($this->realContainer, $masterSyncRecords, $em, $licenseToSync, $path);
  2189.                 if (isset($auxArrayResponse['continue']) && isset($auxArrayResponse['msg']) && !$auxArrayResponse['continue']) {
  2190.                     
  2191.                     $this->createFileJson($path, $auxArrayResponse['msg'] . "\r");
  2193.                     $responseToAjax['msg'] = $auxArrayResponse['msg'];
  2194.                     $responseToAjax['result'] = '__KO__';
  2195.                     $responseToAjax['response_code'] = WebService::ANOTHER_SYNC_IN_PROCESS;
  2197.                     return $this->respondJsonAjax($responseToAjax);
  2198.                 }
  2199.             }
  2201.             $lastReadDataForLicense = $em->getRepository('App\Entity\ReadFilesData')->findLastSyncPetitionIdByLicense($id);
  2203.             $responseToAjax['result'] = '__OK__';
  2204.             $responseToAjax['lastId'] = (int) $lastReadDataForLicense;
  2206.             $isInProssesASync = $em->getRepository('App\Entity\ReadFilesData')->findBy(['id' => $lastReadDataForLicense, 'isReadedByServer' => true, 'hasPersistentError' => false, 'rfStatus' => ReadFilesData::STATUS_UPLOADED]);
  2208.             if (!empty($isInProssesASync)) {
  2210.                 $responseToAjax['result'] = '__KO__';
  2212.                 $this->createFileJson($path, 'An Android server synchronization is already in process.. Please check if the new data has been uploaded in one minute!' . "\r");
  2213.                 
  2214.                 $responseToAjax['msg'] = 'An Android server synchronization is already in process.. Please check if the new data has been uploaded in one minute!';
  2215.                 $responseToAjax['response_code'] = WebService::SYNC_ALREADY_IN_PROCESS;
  2217.             }
  2219.             $this->createFileJson($path, 'Ready to send push asking for down up synchronization!' . "\r");
  2221.             $dataResponse = [];
  2222.             $dataResponse["status"] = WebService::CODE_SUCCESS;
  2223.             $dataResponse["actions"] = "updatedb";
  2224.             $dataResponse['uploadurl'] = $this->realContainer->getParameter('level_scheme') . '://' . $this->realContainer->getParameter('level_host') . $this->generateUrl('level_web_service_sync_upload_data_android');
  2226.             $typePush = PushSent::PUSH_TYPE_SYNC_DOWNUP;
  2227.             
  2228.             Util::sendSuperPush($this->realContainer, $em, $dataResponse, $typePush, $licenseToSync, $path);
  2230.         } else {
  2232.             $responseToAjax['msg'] = 'License not found!';
  2233.             $responseToAjax['result'] = '__KO__';
  2235.             return $this->respondJsonAjax($responseToAjax);
  2236.         }
  2238.         return $this->respondJsonAjax($responseToAjax);
  2239.     }
  2241.     /**
  2242.      * Funcion para hacer el polling para un ajax verificando si la peticion
  2243.      * de sincronizacion manual de abajo a arriba fue completada con exito
  2244.      * @author Aealan Z <lrobledo@kijho.com> 11/06/2016
  2245.      * @param Request $request peticion recivida por ajax
  2246.      * @param type $id id de la licencia a la que se le solicito la sincronizacion
  2247.      * @return type json con la respuesta del polling formateada para el ajax
  2248.      */
  2249.     public function checkAndroidSyncManuallyCompleted(Request $request, $id) {
  2250.         $em = $this->getDoctrine()->getManager();
  2252.         $path = Util::getValidActiveLogByBaseName($this->realContainer, 'requestForManuallySyncXXX', 'requestForManuallySyncXXX0.txt');
  2254.         $this->createFileJson($path, 'Sync Android Up Manually: Llego al check! ' . "\r");
  2256.         $paramNick = $request->request->get('nickname');
  2257.         if ($paramNick == null) {
  2258.             $paramNick = $request->query->get('nickname');
  2259.         }
  2261.         $paramLastId = $request->request->get('lastId');
  2262.         if ($paramLastId == null) {
  2263.             $paramLastId = $request->query->get('lastId');
  2264.         }
  2266.         $this->createFileJson($path, 'Sync Android Up Manually: nickname' . $paramNick . "\r");
  2267.         $this->createFileJson($path, 'Sync Android Up Manually: lastId' . $paramLastId . "\r");
  2269.         if (null != $paramLastId && (int) $paramLastId >= 0) {
  2270.             $licenseToSync = $em->getRepository('App\Entity\AccountLicense')->find($id);
  2272.             $this->createFileJson($path, 'Sync Android Up Manually: Entro 1' . $paramLastId . "\r");
  2274.             if ($licenseToSync) {
  2275.                 $this->createFileJson($path, 'Sync Android Up Manually: Entro 2' . $paramLastId . "\r");
  2277.                 if ($paramNick != $licenseToSync->getAlLicenseUsername()) {
  2278.                     $responseToAjax['msg'] = 'License not found!';
  2279.                     $responseToAjax['result'] = '__KO__';
  2281.                     return $this->respondJsonAjax($responseToAjax);
  2282.                 }
  2284.                 $responseToAjax['result'] = '__OK__';
  2286.                 $pollingResultArray = $this->checkForDownUpPolling($id, $paramLastId, $path);
  2288.                 $responseToAjax['msg'] = $pollingResultArray['msg'];
  2289.                 $responseToAjax['response_code'] = $pollingResultArray['response_code'];
  2291.                 $this->createFileJson($path, 'Sync Android Up Manually: Super!' . $paramLastId . "\r");
  2292.             } else {
  2293.                 $responseToAjax['msg'] = 'License not found!';
  2294.                 $responseToAjax['result'] = '__KO__';
  2296.                 $this->createFileJson($path, 'Sync Android Up Manually: Chango1 ' . $paramLastId . "\r");
  2298.                 return $this->respondJsonAjax($responseToAjax);
  2299.             }
  2300.         } else {
  2301.             $this->createFileJson($path, 'Sync Android Up Manually: Chango2 ' . $paramLastId . "\r");
  2303.             $responseToAjax['msg'] = 'License not found!';
  2304.             $responseToAjax['result'] = '__KO__';
  2306.             return $this->respondJsonAjax($responseToAjax);
  2307.         }
  2309.         return $this->respondJsonAjax($responseToAjax);
  2310.     }
  2312.     /**
  2313.      * Esta funcion permite al cliente adroid notificar que termino de
  2314.      * subir el archivo de sincronizacion
  2315.      * @author Aealan Z <lrobledo@kijho.com> 30/04/15
  2316.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  2317.      * @return Response Json con la informacion de respuesta
  2318.      */
  2319.     public function uploadAndoridSyncWebResponse(Request $request) {
  2321.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  2322.             $path = Util::getValidActiveLogByBaseName($this->realContainer, 'requestRespondForWebSyncFromAndroid', 'requestRespondForWebSyncFromAndroid0.txt');
  2324.             try {
  2325.                 $this->createFileJson($path, "\r" . 'Upload Sync Up-Down Andorid Response File: Llego? ' . "\r");
  2327.                 $this->createFileJson($path, 'Whole request -> ' . $request . "\r");
  2328.                 $this->createFileJson($path, 'Maybe some content here...? -> ' . $request->getContent() . "\r");
  2330.                 $parameters = $request->request->all();
  2332.                 $this->createFileJson($path, 'All parameters in request -> ' . json_encode($parameters) . "\r");
  2334.                 $this->createFileJson($path, 'Nickname -> ' . $request->request->get('nickname') . "\r");
  2335.                 $this->createFileJson($path, 'UID -> ' . $request->request->get('uid') . "\r");
  2337.                 $data = [];
  2338.                 $dataForTrack = [];
  2339.                 $arrayEncryptResult = Util::decryptDataForUploadsFiles($this->realContainer, $request->request->get('nickname'));
  2340.                 $data['nickname'] = $arrayEncryptResult['data'];
  2341.                 $dataForTrack['nick_encrypt'] = $request->request->get('nickname');
  2342.                 $dataForTrack['nick_decrypt'] = $arrayEncryptResult['data'];
  2344.                 $arrayEncryptResult = Util::decryptDataForUploadsFiles($this->realContainer, $request->request->get('uid'));
  2345.                 $data['uid'] = $arrayEncryptResult['data'];
  2346.                 $dataForTrack['uid_encrypt'] = $request->request->get('uid');
  2347.                 $dataForTrack['uid_decrypt'] = $arrayEncryptResult['data'];
  2349.                 $arrayEncryptResult = Util::decryptDataForUploadsFiles($this->realContainer, $request->request->get('NO_DATA'));
  2350.                 $data['NO_DATA'] = $arrayEncryptResult['data'];
  2351.                 $dataForTrack['uid_encrypt'] = $request->request->get('NO_DATA');
  2352.                 $dataForTrack['uid_decrypt'] = $arrayEncryptResult['data'];
  2354.                 $this->createFileJson($path, 'Full -> ' . json_encode($dataForTrack) . "\r");
  2356.                 $this->createFileJson($path, 'The Client IP -> ' . $request->getClientIp() . "\r");
  2358.                 $hasFile = false;
  2359.                 if ($request->files->get('file')) {
  2360.                     $hasFile = true;
  2361.                     $this->createFileJson($path, 'The File -> ' . $request->files->get('file')->getClientOriginalName() . "\r");
  2362.                 } else {
  2363.                     $this->createFileJson($path, 'No file uploaded, returning ' . "\r");
  2364.                 }
  2366.                 $licenseUserName = ['alLicenseUsername' => $data['nickname']];
  2368.                 $em = $this->getDoctrine()->getManager();
  2369.                 $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findBy($licenseUserName);
  2370.                 $countResult = count($accountLicenseData);
  2372.                 if ($countResult > 0 && $hasFile) {
  2373.                     if ($accountLicenseData[0]->getAlAccountLicense()->getDeleted()) {
  2374.                         $this->createFileJson($path, 'Licensia borrada! o.O' . "\r");
  2375.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2376.                                         ->respondWithError('Account is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  2377.                     }
  2379.                     if ($accountLicenseData[0]->getDeviceUid() != $data['uid']) {
  2380.                         $this->createFileJson($path, 'UID diferente! o.O' . "\r");
  2381.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2382.                                         ->respondWithError('Unknown device', WebService::CODE_ACCOUNT_SUSPENDED);
  2383.                     }
  2385.                     $statusArryMsg = [];
  2387.                     $statusArryMsg['status'] = WebService::CODE_SUCCESS;
  2388.                     $statusArryMsg['msg'] = '';
  2390.                     if (isset($data['NO_DATA'])) {
  2391.                         $statusArryMsg['msg'] = 'Empty file delivered for Android!!!! ...closing sync...';
  2392.                         $this->createFileJson($path, 'Empty file delivered for Android!!!! ...closing sync...' . " O.o!  \r");
  2394.                         // $registerStatus = Util::updateWebSyncUploadResponseFile($em, $readFilesDataEntityByLicense[0], $data['NO_DATA']);
  2396.                         $theUrlTrSt = new UploadSyncJsonNotifyTransformer($this->realContainer, $statusArryMsg);
  2397.                         $jsonTransform = $theUrlTrSt->transform();
  2399.                         $jsonContent = json_encode($jsonTransform);
  2401.                         return $this->respondWithItem($jsonContent, $theUrlTrSt);
  2402.                     }
  2404.                     if ($accountLicenseData[0]->getAlLicenseStatus() == AccountLicense::LICENSE_STATUS_ACTIVE) {
  2405.                         $pushSentArray = [];
  2407.                         $readFilesDataEntityByLicense = $em->getRepository('App\Entity\ReadFilesDataWeb')->findBy(['rfwLicenseId' => $accountLicenseData[0]->getId(), 'rfwStatus' => ReadFilesDataWeb::STATUS_READED_DELIVERED], ['rfwDateSincAsk' => 'ASC'], 2);
  2409.                         if (isset($readFilesDataEntityByLicense[0]) && $readFilesDataEntityByLicense[0]->getRfwStatus() == ReadFilesDataWeb::STATUS_READED_DELIVERED) {
  2411.                             $this->createFileJson($path, 'Encontrada la ' . $readFilesDataEntityByLicense[0]->getId() . " :)  \r");
  2413.                             $masterSyncForWebResponse = $em->getRepository('App\Entity\MasterSync')->findBy(['msSyncWebRecord' => $readFilesDataEntityByLicense[0]->getId()]);
  2415.                             if (isset($masterSyncForWebResponse[0])) {
  2416.                                 $this->createFileJson($path, 'Into push validation response ' . $masterSyncForWebResponse[0]->getId() . " :)  \r");
  2417.                                 $pushWebPushSend = $masterSyncForWebResponse[0]->getMsPushRecord();
  2419.                                 if ($pushWebPushSend) {
  2420.                                     if ($pushWebPushSend->getPushStatus() == PushSent::STATUS_PUSH_PENDING) {
  2421.                                         $pushWebPushSend->setPushStatus(PushSent::STATUS_PUSH_READED);
  2422.                                         $actualDate = Util::getCurrentDate();
  2423.                                         $pushWebPushSend->setRespondDate($actualDate);
  2425.                                         $em->persist($pushWebPushSend);
  2426.                                         $em->flush();
  2428.                                         $this->createFileJson($path, 'Updated push status by sync response for ' . $pushWebPushSend->getId() . " ;)  \r");
  2429.                                     } else {
  2430.                                         $this->createFileJson($path, 'Already responded by Android server XD' . "\r");
  2431.                                     }
  2432.                                 } else {
  2433.                                     $this->createFileJson($path, 'Not related push, it may be an initial login... ' . "\r");
  2434.                                 }
  2435.                             }
  2437.                             $isDirectoryReady = Util::createLicenseDirectory($this->realContainer, $accountLicenseData[0], $data['nickname']);
  2438.                             $theAccountLicenseDirector = $isDirectoryReady['directory'];
  2440.                             if (!isset($isDirectoryReady['result']) || $isDirectoryReady['result'] == '__KO__') {
  2441.                                 $this->createFileJson($path, 'No existe el directorio de la licensia coño! o.O' . "\r");
  2442.                                 $msnError = 'An error occurred while creating your directory in server ';
  2443.                                 return $this->setStatusCode(WebService::CODE_INTERNAL_ERROR)
  2444.                                                 ->respondWithError($msnError, WebService::CODE_INTERNAL_ERROR);
  2445.                             }
  2447.                             $uploadFileResponse = Utilx::uploadFileTo($request, $theAccountLicenseDirector, $path);
  2449.                             if (!isset($uploadFileResponse['result']) || !isset($uploadFileResponse['msg'])) {
  2450.                                 $this->createFileJson($path, 'Unknown error uploading file ' . "\r");
  2451.                                 return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)
  2452.                                                 ->respondWithError('Unknown error uploading file', WebService::CODE_INTERNAL_ERROR);
  2453.                             }
  2455.                             if (isset($uploadFileResponse['result']) && isset($uploadFileResponse['msg']) && $uploadFileResponse['result'] == '__KO__') {
  2456.                                 $this->createFileJson($path, $uploadFileResponse['msg'] . "\r");
  2457.                                 return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)
  2458.                                                 ->respondWithError($uploadFileResponse['msg'], WebService::CODE_INTERNAL_ERROR);
  2459.                             }
  2461.                             $bucketFileLocation = Util::uploadSyncFileToS3Service($this->realContainer, $accountLicenseData[0], $uploadFileResponse['fileName'], $uploadFileResponse['fileDir'], $path);
  2462.                             $syncResponseFileS3URI = 'https://' . $this->realContainer->getParameter('s3_bucket_name') . '.' . $this->realContainer->getParameter('s3_default_bucket_domain') . '/' . $bucketFileLocation;
  2464.                             $registerStatus = Util::updateWebSyncUploadResponseFile($em, $readFilesDataEntityByLicense[0], $uploadFileResponse['fileName'], $syncResponseFileS3URI);
  2466. //////////// validacion para determinar si se puede marcar la licencia con login inicial exitoso
  2467.                             $theProcessedUploadedFile = $readFilesDataEntityByLicense[0]->getRfwNameProcessedFile();
  2468.                             if (($readFilesDataEntityByLicense[0]->getSplitLoginIndex() == 0 && count(explode('_', $theProcessedUploadedFile)) == 2 && strpos($theProcessedUploadedFile, 'heInitialData') === 1) ||
  2469.                                     ($readFilesDataEntityByLicense[0]->getSplitLoginIndex() == 4 && count(explode('_', $theProcessedUploadedFile)) == 4 && strpos($theProcessedUploadedFile, 'heInitialData_user') === 1)) {
  2470.                                 $accountLicenseData[0]->setLastLoginWasOk(true);
  2472.                                 $em->persist($accountLicenseData[0]);
  2473.                                 $em->flush();
  2474.                             }
  2476.                             if ($registerStatus) {
  2477.                                 $statusArryMsg['msg'] = 'File has been uploaded and the record updated';
  2478.                                 $this->createFileJson($path, ':D 6' . "\r");
  2479.                             } else {
  2480.                                 $this->createFileJson($path, 'Error actualizando el MasterSync coño! o.O' . "\r");
  2481.                                 return $this->setStatusCode(WebService::HTTP_CODE_NOT_FOUND)
  2482.                                                 ->respondWithError('Error updating syncronization control record', WebService::CODE_OBJECT_NOT_FOUND);
  2483.                             }
  2485.                             $this->createFileJson($path, 'Hay Chingada!?' . "\r");
  2487.                             $licenseDataBaseEntity = $em->getRepository('App\Entity\LicenseDataBase')->findBy(['license' => $accountLicenseData[0]->getId()]);
  2489.                             $this->createFileJson($path, 'O No Hay!?' . "\r");
  2491.                             if (!empty($licenseDataBaseEntity)) {
  2492.                                 $this->createFileJson($path, 'Entro Trigger' . "\r");
  2494.                                 $usernameByNickname = $licenseDataBaseEntity[0]->getLicense();
  2495.                                 $theAccountPath = $this->realContainer->getParameter('level_directory_data_android') . $usernameByNickname->getAlAccountLicense()->getAcName() . '/' . $usernameByNickname->getAlLicenseUsername();
  2496.                                 $theAccountPath = str_replace(' ', '_', $theAccountPath);
  2498.                                 $dataOptionsRoot = [
  2499.                                     'dbname' => $licenseDataBaseEntity[0]->getDbname(),
  2500.                                     'user' => $licenseDataBaseEntity[0]->getDbuser(),
  2501.                                     'password' => $licenseDataBaseEntity[0]->getDbpass(),
  2502.                                     'host' => $licenseDataBaseEntity[0]->getDbhost(),
  2503.                                     'driver' => 'pdo_mysql',
  2504.                                 ];
  2506.                                 $msg = [
  2507.                                     'id' => $readFilesDataEntityByLicense[0]->getId(),
  2508.                                     'dataOptionsRoot' => $dataOptionsRoot,
  2509.                                     'path' => $theAccountPath,
  2510.                                     'filename' => $readFilesDataEntityByLicense[0]->getRfwClientResponseFile(),
  2511.                                     'AccountLicense' => $usernameByNickname->getAlAccountLicense()->getAcName()
  2512.                                 ];
  2514.                                 $this->get('incoming_web_android_sync_response_producer')->setContentType('application/json');
  2515.                                 $this->get('incoming_web_android_sync_response_producer')->setDeliveryMode(2);
  2516.                                 $this->get('incoming_web_android_sync_response_producer')->publish(json_encode($msg));
  2518.                                 $statusArryMsg['msg'] = 'File has been uploaded and the sync web response process is ready to consume';
  2520.                                 $holdTheComsume = $request->request->get('hold');
  2522.                                 if (null == $holdTheComsume) {
  2523.                                     $statusArryMsg['msg'] = 'File has been uploaded and the sync web response process triggered';
  2525.                                     sleep(5);
  2527.                                     $this->createFileJson($path, 'Instant parameter sended to consumer command -> ' . $readFilesDataEntityByLicense[0]->getId() . "\r");
  2529.                                     $data['syncRecord'] = $readFilesDataEntityByLicense[0]->getId();
  2530.                                     ForcedAsynchronousCommandsUtil::consumeUpDownSyncResponseCommand($this->realContainer, $data, true);
  2532.                                     $this->createFileJson($path, 'Corrio Trigger? ' . "\r");
  2533.                                 }
  2534.                             }
  2536.                             $this->createFileJson($path, ':D 7' . "\r");
  2538.                             if (null != $request->request->get('code')) {
  2539.                                 $arrayEncryptResult = Util::decryptDataForUploadsFiles($this->realContainer, $request->request->get('code'));
  2540.                                 $data['code'] = $arrayEncryptResult['data'];
  2541.                                 $pushSendRecords = $em->getRepository('App\Entity\PushSent')->findBy(['verificationCode' => $data['code'], 'pushStatus' => PushSent::STATUS_PUSH_PENDING]);
  2543.                                 if (!empty($pushSendRecords)) {
  2544.                                     $this->updateRegistPushSend($pushSendRecords[0]);
  2545.                                 }
  2546.                             }
  2548.                             $this->createFileJson($path, ':D 8' . "\r");
  2550.                             $theUrlTrSt = new UploadSyncJsonNotifyTransformer($this->realContainer, $statusArryMsg);
  2551.                             $jsonTransform = $theUrlTrSt->transform();
  2553.                             $jsonContent = json_encode($jsonTransform);
  2555.                             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  2556.                         } else {
  2557.                             $this->createFileJson($path, 'No encontro el registro de la sincronizacion web coño! o.O' . "\r");
  2558.                             return $this->setStatusCode(WebService::HTTP_CODE_NOT_FOUND)
  2559.                                             ->respondWithError('No syncronization data registered', WebService::CODE_OBJECT_NOT_FOUND);
  2560.                         }
  2561.                     } else {
  2562.                         $this->createFileJson($path, 'Licensia inactiva! o.O' . "\r");
  2563.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2564.                                         ->respondWithError('Inactive License', WebService::CODE_ACCOUNT_SUSPENDED);
  2565.                     }
  2566.                 } else {
  2567.                     $this->createFileJson($path, 'No encontro la licencia! o.O' . "\r");
  2568.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2569.                                     ->respondWithError('Invalid nickname or file not uploaded properly', WebService::CODE_COULD_NOT_AUTHENTICATE);
  2570.                 }
  2571.             } catch (\Exception $ex) {
  2572.                 $this->createFileJson($path, 'Error on request: -> ' . $ex->getMessage() . "\r");
  2573.             }
  2574.         } else {
  2575.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  2576.         }
  2577.     }
  2579.     /**
  2580.      * WS generico para que el cliente andorid responda todos los push enviados a los clientes
  2581.      * @author Aealan Z <lrobledo@kijho.com> 18/06/15
  2582.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  2583.      * @return Response Json con la informacion de respuesta
  2584.      */
  2585.     public function respondedReadedPush(Request $request) {
  2586.     
  2587.         $path = Util::getValidActiveLogByBaseName($this->realContainer, 'pushResponseFromAndroid', 'pushResponseFromAndroid0.txt');
  2588.         $this->createFileJson($path, 'Push Responded: ' . $request->getContent() . "\r");
  2590.         $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  2592.         $params = json_decode($arrayEncryptResult['data'], true);
  2594.         $this->createFileJson($path, 'Push Responded decode params: ' . $arrayEncryptResult['data'] . "\r");
  2596.         if (!isset($params['code'])) {
  2597.             $this->createFileJson($path, 'No code argument send' . "\r");
  2598.             return $this->errorWrongArgs('No code argument send', WebService::CODE_WRONG_ARGUMENTS);
  2599.         }
  2601.         $em = $this->realContainer->get('doctrine')->getManager();
  2603.         $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->validateRestauratAndAccountActive($params['nickname']);
  2605.         $pushSendRepository = $em->getRepository('App\Entity\PushSent');
  2607.         $firstBy = null;
  2608.         if (isset($params['pushProvider']) && $params['pushProvider'] == 'Pushy') {
  2609.             $firstBy = PushSent::SENDED_FIRST_BY_PUSHY;
  2610.         } elseif (isset($params['pushProvider']) && $params['pushProvider'] == 'Pubnub') {
  2611.             $firstBy = PushSent::SENDED_FIRST_BY_PUBNUB;
  2612.         } elseif (isset($params['pushProvider']) && $params['pushProvider'] == 'Level') {
  2613.             $firstBy = PushSent::SENDED_FIRST_BY_LICENSOR;
  2614.         }
  2616.         $this->createFileJson($path, "step 1 \r");
  2618.         $response = null;
  2619.         if (isset($params['response'])) {
  2620.             $response = (int) $params['response'];
  2621.         }
  2623.         $responsePushType = $pushSendRepository->selectPushTypeByCode($params['code']);
  2625.         $this->createFileJson($path, "step 2 \r");
  2627.         if (!$responsePushType) {
  2628.             $msnError = 'Push record not found! ';
  2630.             $this->createFileJson($path, "$msnError \r");
  2631.             return $this->setStatusCode(WebService::CODE_INTERNAL_ERROR)
  2632.                             ->respondWithError($msnError, WebService::CODE_INTERNAL_ERROR);
  2633.         }
  2635.         $responseUpdate = $pushSendRepository->updateReadedPush($params['code'], $firstBy, $response);
  2637.         if (PushSent::PUSH_TYPE_UPLOAD_S3_BACKUP == $responsePushType) {
  2638.             $pushSendRepository->updateLicenseRecordByPush($params['code']);
  2639.         }
  2641.         $pushSendRepository->respondOldPushesForLicense($responsePushType, $accountLicenseData);
  2642.         $pushSendRepository->closeUnansweredS3Pushes($accountLicenseData);
  2644.         $this->createFileJson($path, "step 3 \r");
  2646.         if (!$responseUpdate) {
  2647.             $msnError = 'An error occurred while updatin the push send record or push already answered.';
  2649.             $this->createFileJson($path, "$msnError \r");
  2650.             return $this->setStatusCode(WebService::CODE_INTERNAL_ERROR)
  2651.                             ->respondWithError($msnError, WebService::CODE_INTERNAL_ERROR);
  2652.         }
  2654.         $responseArray['status'] = WebService::CODE_SUCCESS;
  2655.         $responseArray['msg'] = 'Server notified';
  2657.         $this->createFileJson($path, "step 4 \r");
  2659.         $theUrlTrSt = new RespondedNotificationPushTransformer($responseArray);
  2660.         $jsonTransform = $theUrlTrSt->transform();
  2662.         $this->createFileJson($path, "step 5 \r");
  2664.         $jsonContent = json_encode($jsonTransform);
  2666.         $this->createFileJson($path, "$jsonContent \r");
  2667.         return $this->respondWithItem($jsonContent, $theUrlTrSt);
  2668.     }
  2670.     /**
  2671.      * WS generico para que el servidor andorid responda una pregunta realizada en un push
  2672.      * @author Aealan Z <lrobledo@kijho.com> 15/06/16
  2673.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  2674.      * @return Response Json con la informacion de respuesta
  2675.      */
  2676.     public function respondedAskInPush(Request $request) {
  2677.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  2679.             if (0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT) || 0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE)) {
  2681.                 $path = Util::getValidActiveLogByBaseName($this->realContainer, 'requestEncriptedFromAndroid', 'requestEncriptedFromAndroid0.txt');
  2682.                 $this->createFileJson($path, "\r" . 'Push Ask: ' . $request->getContent() . "\r");
  2684.                 $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  2686.                 $params = json_decode($arrayEncryptResult['data'], true);
  2688.                 $this->createFileJson($path, 'Push Responded decode params: ' . $arrayEncryptResult['data'] . "\r");
  2690.                 if (!isset($params['nickname']) || !isset($params['code'])) {
  2691.                     return $this->errorWrongArgs('Wrong Arguments', WebService::CODE_WRONG_ARGUMENTS);
  2692.                 }
  2694.                 $em = $this->getDoctrine()->getManager();
  2696.                 $data = ['alLicenseUsername' => $params['nickname']];
  2698.                 $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findByAlLicenseUsername($data);
  2700.                 $data = ['channelName' => $params['nickname']];
  2701.                 $subLicenseData = $em->getRepository('App\Entity\SubLicense')->findBy($data);
  2702.                 $countResult = count($accountLicenseData) + count($subLicenseData);
  2704.                 if ($countResult > 0) {
  2706.                     if (!empty($accountLicenseData)) {
  2707.                         if ($accountLicenseData[0]->getAlAccountLicense()->getDeleted()) {
  2708.                             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2709.                                             ->respondWithError('Account is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  2710.                         }
  2712.                         if ($accountLicenseData[0]->getAlLicenseStatus() == AccountLicense::LICENSE_STATUS_INACTIVE) {
  2713.                             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2714.                                             ->respondWithError('Inactive License', WebService::CODE_ACCOUNT_SUSPENDED);
  2715.                         }
  2716.                     }
  2718.                     $pushSendRecords = $em->getRepository('App\Entity\PushSent')->searchPushSendRecords($params['code']);
  2719.                     $responseArray = [];
  2721.                     $responseUpdate = false;
  2722.                     if (!empty($pushSendRecords)) {
  2723.                         if (isset($params['response'])) {
  2724.                             $pushSendRecords[0]->setAskedResponse((boolean) $params['response']);
  2725.                         }
  2727.                         $responseUpdate = $this->updateRegistPushSend($pushSendRecords[0]);
  2728.                     } else {
  2729.                         $msnError = 'Push send record not found ';
  2730.                         return $this->setStatusCode(WebService::CODE_INTERNAL_ERROR)
  2731.                                         ->respondWithError($msnError, WebService::CODE_INTERNAL_ERROR);
  2732.                     }
  2734.                     if (!$responseUpdate) {
  2735.                         $msnError = 'An error occurred while updatin the push send record..';
  2736.                         return $this->setStatusCode(WebService::CODE_INTERNAL_ERROR)
  2737.                                         ->respondWithError($msnError, WebService::CODE_INTERNAL_ERROR);
  2738.                     }
  2740.                     $responseArray['status'] = WebService::CODE_SUCCESS;
  2741.                     $responseArray['msg'] = 'Push ask response notified';
  2743.                     $theUrlTrSt = new RespondedNotificationPushTransformer($responseArray);
  2744.                     $jsonTransform = $theUrlTrSt->transform();
  2746.                     $jsonContent = json_encode($jsonTransform);
  2748.                     return $this->respondWithItem($jsonContent, $theUrlTrSt);
  2749.                 } else {
  2750.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2751.                                     ->respondWithError('Invalid nickname or channelname', WebService::CODE_COULD_NOT_AUTHENTICATE);
  2752.                 }
  2753.             } else {
  2754.                 return $this->errorWrongArgs('Wrong Arguments', WebService::CODE_WRONG_ARGUMENTS);
  2755.             }
  2756.         } else {
  2757.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  2758.         }
  2759.     }
  2761.     /**
  2762.      * WS generico para que los dispositivos android notifique de un error por correo
  2763.      * @author Aealan Z <lrobledo@kijho.com> 13/07/15
  2764.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  2765.      * @return Response Json con la informacion de respuesta
  2766.      */
  2767.     public function notifyAndroidError(Request $request) {
  2768.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  2770.             if (0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT) || 0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE)) {
  2772.                 /////////////////////// Otra sospecha de caida del servidor de licensor prod
  2773.                 $path = Util::getValidActiveLogByBaseName($this->realContainer, 'notifyErrorAndroid', 'notifyErrorAndroid0.txt');
  2774.                 $this->createFileJson($path, "\r" . 'The content: ' . $request->getContent() . "\r");
  2776.                 $responseArray['status'] = WebService::CODE_SUCCESS;
  2777.                 $responseArray['msg'] = 'Server notified';
  2779.                 $theUrlTrSt = new RespondedNotificationPushTransformer($responseArray);
  2780.                 $jsonTransform = $theUrlTrSt->transform();
  2782.                 $this->createFileJson($path, 'The encoded ws response: ' . json_encode($responseArray) . "\r");
  2784.                 $jsonContent = json_encode($jsonTransform);
  2786.                 $this->createFileJson($path, 'The transform: ' . $jsonContent . "\r");
  2788.                 return $this->respondWithItem($jsonContent, $theUrlTrSt);
  2789.                 ///////////////////
  2792.                 $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  2794.                 $this->createFileJson($path, 'The decrypted content: ' . $request->getContent() . "\r");
  2796.                 $params = json_decode($arrayEncryptResult['data'], true);
  2798.                 $this->createFileJson($path, 'The request array: ' . $arrayEncryptResult['data'] . "\r");
  2800.                 if (!isset($params['nickname']) || !isset($params['msg']) || !isset($params['uid'])) {
  2801.                     return $this->errorWrongArgs('Wrong Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  2802.                 }
  2804.                 $data = ['alLicenseUsername' => $params['nickname']];
  2806.                 $em = $this->getDoctrine()->getManager();
  2807.                 $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findByAlLicenseUsername($data);
  2809.                 $data = ['channelName' => $params['nickname']];
  2810.                 $subLicenseData = $em->getRepository('App\Entity\SubLicense')->findBy($data);
  2811.                 $countResult = count($accountLicenseData) + count($subLicenseData);
  2813.                 if ($countResult > 0) {
  2815.                     if (!empty($accountLicenseData)) {
  2816.                         if ($accountLicenseData[0]->getAlAccountLicense()->getDeleted()) {
  2817.                             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2818.                                             ->respondWithError('Account is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  2819.                         }
  2821.                         if ($accountLicenseData[0]->getAlLicenseStatus() == AccountLicense::LICENSE_STATUS_INACTIVE) {
  2822.                             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2823.                                             ->respondWithError('Inactive License', WebService::CODE_ACCOUNT_SUSPENDED);
  2824.                         }
  2826.                         if ($accountLicenseData[0]->getDeviceUid() != $params['uid']) {
  2827.                             $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData[0]);
  2829.                             $subLicenseData = $emLev->getRepository('App\Structure\Stations')->findBy(['staDeviceCode' => $params['uid']]);
  2831.                             if (empty($subLicenseData)) {
  2832.                                 $emLev->close();
  2833.                                 $this->createFileJson($path, 'Error: Unknown device' . "\r");
  2834.                                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2835.                                                 ->respondWithError('Unknown device', WebService::CODE_UNAUTHORIZED);
  2836.                             } else {
  2837.                                 $emLev->close();
  2838.                             }
  2839.                         }
  2840.                     }
  2842.                     $sendEmail = $this->realContainer->getParameter('level_emails_syncs_errors');
  2844.                     if (isset($params['msg']) && $params['msg'] == '') {
  2845.                         return $this->setStatusCode(WebService::CODE_WRONG_ARGUMENTS)
  2846.                                         ->respondWithError('Empty error message', WebService::CODE_ACCOUNT_SUSPENDED);
  2847.                     }
  2848.                     
  2849.                     $errors = $em->getRepository('App\Entity\ErrorAndroidEmailSent')->getAllErrorMsg();
  2850.                     list($errorMsg) = explode("->", $params['msg']);
  2851.                     $theErrorEmailEntity=null;
  2852.                     
  2853.                     $countErrors = count($errors);
  2854.                     for ($i=0; $i < $countErrors ; ++$i) { 
  2855.                         $error=$errors[$i]["errorMsg"];
  2856.                         $pos = strpos($errorMsg, $error);
  2857.                         if ($pos !== false) {
  2858.                             $theErrorEmailEntity = $em->getRepository('App\Entity\ErrorAndroidEmailSent')->findBy(['errorMsg' => $error]);
  2859.                             $theErrorEmailEntity = $theErrorEmailEntity[0];
  2860.                             break;
  2861.                         }
  2862.                     }
  2863.                     
  2864.                     $body = "<p><label>Server: <strong>http://" . $this->realContainer->getParameter("licensor_base_url") . "/licensor/login</strong></label><br></p>";
  2865.                     $body .= "<p><label>" . $params['nickname'] . "</label></p><br>";
  2866.                     $body .= "<p><label><strong>Error: </strong></label><br></p><p><label>" . nl2br($params['msg']) . "</label></p><br>";
  2867.                     $actualDate = Utilx::getCurrentDate();
  2868.                     if(!empty($theErrorEmailEntity)){
  2869.                         $theErrorEmailEntity->setDateErrorLastReport($actualDate);
  2870.                         $theErrorEmailEntity->setErrorCounter(1 + (int) $theErrorEmailEntity->getErrorCounter());
  2871.                         $em->persist($theErrorEmailEntity);
  2872.                         $em->flush();
  2873.                     } else {
  2874.                         $androidErrorCode = $em->getRepository('App\Entity\ErrorAndroidEmailSent')->findRegisteredErrorCodeLicense();
  2875.                         ++$androidErrorCode;
  2876.                         if (!empty($accountLicenseData)) {
  2877.                             $theErrorEmailEntity = $this->setRegistErrorEmail($accountLicenseData[0], $sendEmail[0], $errorMsg, $params['uid'], $androidErrorCode);
  2878.                         } else {
  2879.                             $theErrorEmailEntity = $this->setRegistErrorEmail(null, $sendEmail[0], $errorMsg, $params['uid'], $androidErrorCode, $subLicenseData[0]);
  2880.                         }
  2882.                         $body .= "<p><label><strong>Error Code: </strong></label><br></p><p><label>" . $theErrorEmailEntity->getErrorCode() . "</label></p>";
  2883.                         
  2884.                         if ($accountLicenseData[0]) {
  2885.                             $respArray['subject'] = 'Error In ' . $params['nickname'] . ' ' . $theErrorEmailEntity->getErrorCode();
  2886.                         } else {
  2887.                             $respArray['subject'] = 'Error ' . $theErrorEmailEntity->getErrorCode();
  2888.                         }
  2890.                         $respArray['message'] = "";
  2891.                         $this->createFileJson($path, "Mail to -> " . $sendEmail[0] . "\r");
  2892.                         $respArray['to'] = $sendEmail[0];
  2893.                         Utilx::sendMailInfo($this->realContainer, $respArray, $path, $body);
  2894.                         $theErrorEmailEntity->setDateErrorEmailSent($actualDate);
  2895.                         $em->persist($theErrorEmailEntity);
  2896.                         $em->flush();
  2897.                     }
  2898.                     
  2899.                     if (!empty($accountLicenseData)) {
  2900.                         $theAndroidErrorEntity = $this->setRegistAndroidError($theErrorEmailEntity,$accountLicenseData[0], $sendEmail[0], $params['msg'], $params['uid']);
  2901.                     } else {
  2902.                         $theAndroidErrorEntity = $this->setRegistAndroidError($theErrorEmailEntity,null, $sendEmail[0], $params['msg'], $params['uid'], $subLicenseData[0]);
  2903.                     }
  2905.                     if(!is_null($theErrorEmailEntity->getErrorQualifier())){
  2906.                         if($theErrorEmailEntity->getErrorQualifier() >= ErrorAndroidEmailSent::ERROR_QUALIFIER_COMPARISON ){
  2907.                             if ($accountLicenseData[0]) {
  2908.                                 $respArray['subject'] = 'Error In ' . $params['nickname'] . ' ' . $theErrorEmailEntity->getErrorCode();
  2909.                             } else {
  2910.                                 $respArray['subject'] = 'Error ' . $theErrorEmailEntity->getErrorCode();
  2911.                             }
  2912.                                                         
  2913.                             $body .= "<p><label><strong>Error Code: </strong></label><br></p><p><label>" . $theErrorEmailEntity->getErrorCode() . "</label></p>";
  2914.                             
  2915.                             $respArray['message'] = "";
  2916.                             $this->createFileJson($path, "Mail to -> " . $sendEmail[0] . "\r");
  2917.                             $respArray['to'] = $sendEmail[0];
  2918.         
  2919.                             Utilx::sendMailInfo($this->realContainer, $respArray, $path, $body);
  2920.                             $theAndroidErrorEntity->setDateErrorEmailSent($actualDate);
  2921.                             $em->persist($theAndroidErrorEntity);
  2922.                             $em->flush();
  2923.                         }
  2924.                     }
  2925.                                         
  2926.                     $responseArray['status'] = WebService::CODE_SUCCESS;
  2927.                     $responseArray['msg'] = 'Server notified';
  2929.                     $theUrlTrSt = new RespondedNotificationPushTransformer($responseArray);
  2930.                     $jsonTransform = $theUrlTrSt->transform();
  2932.                     $this->createFileJson($path, 'The encoded ws response: ' . json_encode($responseArray) . "\r");
  2934.                     $jsonContent = json_encode($jsonTransform);
  2936.                     $this->createFileJson($path, 'The transform: ' . $jsonContent . "\r");
  2938.                     return $this->respondWithItem($jsonContent, $theUrlTrSt);
  2939.                 } else {
  2940.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2941.                                     ->respondWithError('Invalid nickname', WebService::CODE_COULD_NOT_AUTHENTICATE);
  2942.                 }
  2943.             } else {
  2944.                 return $this->errorWrongArgs('Wrong Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  2945.             }
  2946.         } else {
  2947.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  2948.         }
  2949.     }
  2951.     /**
  2952.      * WS generico para que los dispositivos android envien su
  2953.      * log por correo a los administradores del sistema
  2954.      * @author Aealan Z <lrobledo@kijho.com> 13/07/15
  2955.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  2956.      * @return Response Json con la informacion de respuesta
  2957.      */
  2958.     public function notifyAndroidLog(Request $request) {
  2959.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  2961.             if (0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT) || 0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE)) {
  2963.                 $path = Util::getValidActiveLogByBaseName($this->realContainer, 'notifyAndroidLog', 'notifyAndroidLog0.txt');
  2964.                 $this->createFileJson($path, 'Notify Android Log: ' . $request->getContent() . "\r");
  2966.                 $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  2968.                 $this->createFileJson($path, 'The decrypted content: ' . $request->getContent() . "\r");
  2970.                 $params = json_decode($arrayEncryptResult['data'], true);
  2972.                 $this->createFileJson($path, 'The request array: ' . $arrayEncryptResult['data'] . "\r");
  2974.                 if (!isset($params['nickname']) || !isset($params['log']) || !isset($params['uid'])) {
  2975.                     return $this->errorWrongArgs('Wrong Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  2976.                 }
  2978.                 $data = ['alLicenseUsername' => $params['nickname']];
  2980.                 $em = $this->getDoctrine()->getManager();
  2981.                 $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findBy($data);
  2983.                 $data = ['channelName' => $params['nickname']];
  2984.                 $subLicenseData = $em->getRepository('App\Entity\SubLicense')->findBy($data);
  2985.                 $countResult = count($accountLicenseData) + count($subLicenseData);
  2987.                 if ($countResult > 0) {
  2989.                     if (!empty($accountLicenseData)) {
  2990.                         $theLicenses = $accountLicenseData[0];
  2991.                         $theUID = $accountLicenseData[0]->getDeviceUid();
  2992.                     } elseif (!empty($subLicenseData)) {
  2993.                         $theLicenses = $subLicenseData[0]->getLicense();
  2994.                         $theUID = $subLicenseData[0]->getDeviceUid();
  2995.                     }
  2997.                     if ($theLicenses->getAlAccountLicense()->getDeleted()) {
  2998.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2999.                                         ->respondWithError('Account is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  3000.                     }
  3002.                     if ($theLicenses->getAlLicenseStatus() == AccountLicense::LICENSE_STATUS_INACTIVE) {
  3003.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  3004.                                         ->respondWithError('Inactive License', WebService::CODE_ACCOUNT_SUSPENDED);
  3005.                     }
  3007.                     if ($theUID != $params['uid']) {
  3008.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  3009.                                         ->respondWithError('Unknown device', WebService::CODE_ACCOUNT_SUSPENDED);
  3010.                     }
  3012.                     if ($params['log'] == '') {
  3013.                         return $this->setStatusCode(WebService::CODE_WRONG_ARGUMENTS)
  3014.                                         ->respondWithError('Empty log content', WebService::CODE_WRONG_ARGUMENTS);
  3015.                     }
  3017.                     $sendEmail = $this->realContainer->getParameter('level_emails_syncs_errors');
  3019.                     $isSameLog = false;
  3020.                     $sameLogs = $em->getRepository('App\Entity\LogAndroidEmailSent')->findBy(['logMsg' => $params['log']]);
  3022.                     if (!empty($sameLogs)) {
  3023.                         $isSameLog = true;
  3024.                         $theLogEmailEntity = $sameLogs[0];
  3025.                     } else {
  3026.                         $androidLogCode = $em->getRepository('App\Entity\LogAndroidEmailSent')->findRegisteredLogCodeLicense();
  3027.                         ++$androidLogCode;
  3029.                         $numEmails = count($sendEmail);
  3031.                         for ($i = 0; $i < $numEmails; ++$i) {
  3032.                             if (!empty($accountLicenseData)) {
  3033.                                 $theLogEmailEntity = $this->setRegistLogEmail($accountLicenseData[0], $sendEmail[$i], $params['log'], $params['uid'], $androidLogCode);
  3034.                             } else {
  3035.                                 $theLogEmailEntity = $this->setRegistLogEmail(null, $sendEmail[$i], $params['log'], $params['uid'], $androidLogCode, $subLicenseData[0]);
  3036.                             }
  3037.                         }
  3038.                     }
  3040.                     $body = "<p><label>Server: <strong>http://" . $this->realContainer->getParameter("licensor_base_url") . "/login</strong></label><br></p>";
  3041.                     $body .= "<p><label>" . $params['nickname'] . "</label></p><br>";
  3042.                     $body .= "<p><label><strong>Log: </strong></label><br></p><p><label>" . nl2br($params['log']) . "</label></p><br>";
  3044.                     $respArray['subject'] = 'Android device log ' . $params['nickname'];
  3045.                     $respArray['message'] = "";
  3047.                     foreach ($sendEmail as $mailTo) {
  3048.                         $this->createFileJson($path, "Mail to -> " . $mailTo . "\r");
  3050.                         $respArray['to'] = $mailTo;
  3052.                         Utilx::sendMailInfo($this->realContainer, $respArray, $path, $body);
  3053.                     }
  3055.                     $responseArray['status'] = WebService::CODE_SUCCESS;
  3056.                     $responseArray['msg'] = 'Android log notified';
  3058.                     $theUrlTrSt = new RespondedNotificationPushTransformer($responseArray);
  3059.                     $jsonTransform = $theUrlTrSt->transform();
  3061.                     $this->createFileJson($path, 'The encoded ws response: ' . json_encode($responseArray) . "\r");
  3063.                     $jsonContent = json_encode($jsonTransform);
  3065.                     $this->createFileJson($path, 'The transform: ' . $jsonContent . "\r");
  3067.                     return $this->respondWithItem($jsonContent, $theUrlTrSt);
  3068.                 } else {
  3069.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  3070.                                     ->respondWithError('Invalid nickname', WebService::CODE_COULD_NOT_AUTHENTICATE);
  3071.                 }
  3072.             } else {
  3073.                 return $this->errorWrongArgs('Wrong Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  3074.             }
  3075.         } else {
  3076.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  3077.         }
  3078.     }
  3080.     /**
  3081.      * WS Para validar el logue de dispositivos tanto de licencias como de sublicencias,
  3082.      * dado el caso de que sea necesario actualizar el dispositivo logueado,
  3083.      * este sera notificado mediante la validacion de su logueo en este ws
  3084.      * necesario para toda la aplicacion movil
  3085.      * @author Aealan Z <lrobledo@kijho.com> 20/12/15
  3086.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  3087.      * @return Response Json con la informacion de respuesta
  3088.      */
  3089.     public function validateLogin(Request $request) {
  3090.         $path = Util::getValidActiveLogByBaseName($this->realContainer, 'validateLogin', 'validateLogin0.txt');
  3091.         $this->createFileJson($path, "\r" . 'Validate Login: ' . $request->getContent() . "\r");
  3093.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  3095.             if (0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE) || 0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT)) {
  3097.                 $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  3098.                 $this->createFileJson($path, "\r" . 'arrayEncryptResult: ' . json_encode($arrayEncryptResult) . "\r");
  3100.                 $data = json_decode($arrayEncryptResult['data'], true);
  3102.                 if (!isset($data['version']) || !isset($data['uid'])) {
  3103.                     return $this->errorWrongArgs('Wrong Arguments!', WebService::CODE_WRONG_ARGUMENTS);
  3104.                 }
  3106.                 $this->createFileJson($path, 'The Client IP -> ' . $request->getClientIp() . "\r");
  3108.                 $dataToSearch = ['deviceUid' => $data['uid']];
  3110.                 $em = $this->getDoctrine()->getManager();
  3111.                 $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findBy($dataToSearch);
  3113.                 if (empty($accountLicenseData)) {
  3114.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  3115.                                     ->respondWithError('Invalid UID', WebService::CODE_COULD_NOT_AUTHENTICATE);
  3116.                 }
  3118.                 if (isset($data['channelname'])) {
  3119.                     $dataToSearch = ['deviceUid' => $data['uid']];
  3120.                     $subLicenseData = $em->getRepository('App\Entity\SubLicense')->findBy($dataToSearch);
  3121.                     $countResult = count($accountLicenseData) + count($subLicenseData);
  3122.                 } else {
  3123.                     $countResult = count($accountLicenseData);
  3124.                 }
  3126.                 if ($countResult > 0) {
  3127.                     if ($accountLicenseData[0]->getAlAccountLicense()->getDeleted()) {
  3128.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  3129.                                         ->respondWithError('Account is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  3130.                     }
  3132.                     if ($accountLicenseData[0]->getAlLicenseStatus() != AccountLicense::LICENSE_STATUS_ACTIVE) {
  3133.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  3134.                                         ->respondWithError('License is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  3135.                     }
  3137.                     if (isset($data['channelname']) && !empty($subLicenseData)) {
  3138.                         $licenseOrSublicenseToValidate = $subLicenseData[0];
  3139.                     } elseif (empty($subLicenseData) && isset($data['channelname'])) {
  3140.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  3141.                                         ->respondWithError('Invalid channelname', WebService::CODE_COULD_NOT_AUTHENTICATE);
  3142.                     } else {
  3143.                         $licenseOrSublicenseToValidate = $accountLicenseData[0];
  3144.                     }
  3146.                     if ((int) $this->realContainer->getParameter('device_recognition_by_ip_enabled') && $licenseOrSublicenseToValidate->getAndroidIP() == $request->getClientIp()) {
  3147.                         $licenseOrSublicenseToValidate->setTimesCheckedIP($licenseOrSublicenseToValidate->getTimesCheckedIP() + 1);
  3148.                     } else {
  3149.                         $licenseOrSublicenseToValidate->setAndroidIP($request->getClientIp());
  3150.                         $licenseOrSublicenseToValidate->setTimesCheckedIP(0);
  3151.                     }
  3153.                     if (isset($data['databaseSize'])) {
  3154.                         $licenseOrSublicenseToValidate->setAndroidDatabaseSize((int) $data['databaseSize']);
  3155.                         $licenseOrSublicenseToValidate->setLastUpdateOfDatabaseSize(new DateTime("now"));
  3157.                         if ((int) $data['databaseSize'] > (int) $this->realContainer->getParameter('max_android_database_size_to_consider_cleanse')) {
  3158.                             //  $body = "<p><label>Server: <strong>http://" . $this->realContainer->getParameter("licensor_base_url") . "/licensor/login</strong></label><br></p>";
  3159.                             //  $body .= "<p><label>License: <strong>" . $accountLicenseData[0] . "</strong></label></p>";
  3160.                             //  $body .= "<p><label>Message: Database has a size of <strong>'" . Util::humanFilesize($data['databaseSize']) . "' </strong> and the Android server could be having an slow performance for this reason</label><br></p>";
  3162.                             // $respArray['subject'] = "Android database cleanse is needed for '" . $accountLicenseData[0]->getAlLicenseUsername() . "' license";
  3163.                             // $respArray['message'] = "";
  3165.                             // $sendEmail = $this->realContainer->getParameter('level_emails_support_warnings');
  3167.                             // foreach ($sendEmail as $mailTo) {
  3168.                             //     $this->createFileJson($path, "Mail to -> " . $mailTo . "\r");
  3170.                             //     $respArray['to'] = $mailTo;
  3172.                             //     Utilx::sendMailInfo($this->realContainer, $respArray, $path, $body);
  3173.                             // }
  3174.                             
  3175.                             // Inicio de lógica, validación de notificación.
  3176.                             $currentDate = Utilx::getCurrentDate();
  3177.                             $seed = $em->getRepository("App\Entity\NotificationInLicensorBell")->findOneBy(["context"=>NotificationInLicensorBell::CONTEXT_NOTIFICATION_ANDROID_DATABASE_CLEANSE_NEEDED, "license"=>$accountLicenseData[0]]);
  3178.                             if(!is_null($seed)){
  3179.                                 $dateMinusOneWeek = clone $currentDate;
  3180.                                 $dateMinusOneWeek->modify('-1 week');
  3181.                                 if ($dateMinusOneWeek>=$seed->getPickedtByValidatingCronDate()) {
  3182.                                     $seed->setDateCreated($currentDate);
  3183.                                     $seed->setPickedtByValidatingCronDate(null);
  3184.                                     $seed->setNotificationMsg("License:" . $accountLicenseData[0] . "Database has a size of " . Util::humanFilesize($data['databaseSize']) . "  and the Android server could be having an slow performance for this reason");
  3185.                                     $em->persist($seed);
  3186.                                     $em->flush();
  3187.                                 }
  3188.                             }else{
  3189.                                 $currentDate = Utilx::getCurrentDate();
  3190.                                 $seed = new NotificationInLicensorBell();
  3191.                                 $seed->setNotificationTitle('Android database cleanse is needed for ' . $accountLicenseData[0]->getAlLicenseUsername() . ' license');
  3192.                                 $seed->setNotificationLabel(NotificationInLicensorBell::NOTIFICATION_TYPE_WARNING);
  3193.                                 $seed->setNotificationMsg("License:" . $accountLicenseData[0] . "Database has a size of " . Util::humanFilesize($data['databaseSize']) . "  and the Android server could be having an slow performance for this reason");
  3194.                                 $seed->setDateCreated($currentDate);
  3195.                                 $seed->setContext(NotificationInLicensorBell::CONTEXT_NOTIFICATION_ANDROID_DATABASE_CLEANSE_NEEDED);
  3196.                                 $seed->setLicense($accountLicenseData[0]);
  3197.                                 $seed->setTypeRoleToNotify(NotificationInLicensorBell::ROLE_ADMINISTRATOR);
  3199.                                 $em->persist($seed);
  3200.                                 $em->flush();
  3201.                             }
  3202.                             // Fin de lógica, validación de notificación.
  3203.                         }
  3204.                     }
  3206.                     if(isset($data['numberOfSyncDataRecords']) || (isset($data["validateLogin"]) && $data["validateLogin"] == true)){
  3208.                         $licenseDataBaseEntity = $em->getRepository('App\Entity\LicenseDataBase')->findOneBy(['license' => $licenseOrSublicenseToValidate->getId()]);
  3210.                         $dataOptionsRoot = [
  3211.                             'dbname' => $licenseDataBaseEntity->getDbname(),
  3212.                             'user' => $licenseDataBaseEntity->getDbuser(),
  3213.                             'password' => $licenseDataBaseEntity->getDbpass(),
  3214.                             'host' => $licenseDataBaseEntity->getDbhost(),
  3215.                             'driver' => 'pdo_mysql',
  3216.                         ];
  3218.                         $emLev = Util::emCreateConfiguration($this->realContainer, $dataOptionsRoot);
  3219.                         
  3220.                         
  3221.                         if (isset($data['numberOfSyncDataRecords'])) {
  3222.                             $licenseOrSublicenseToValidate->setNumberOfSyncDataRecords((int) $data['numberOfSyncDataRecords']);
  3223.     
  3224.                             // $licenseDataBaseEntity = $em->getRepository('App\Entity\LicenseDataBase')->findOneBy(['license' => $licenseOrSublicenseToValidate->getId()]);
  3225.     
  3226.                             // $dataOptionsRoot = [
  3227.                             //     'dbname' => $licenseDataBaseEntity->getDbname(),
  3228.                             //     'user' => $licenseDataBaseEntity->getDbuser(),
  3229.                             //     'password' => $licenseDataBaseEntity->getDbpass(),
  3230.                             //     'host' => $licenseDataBaseEntity->getDbhost(),
  3231.                             //     'driver' => 'pdo_mysql',
  3232.                             // ];
  3233.     
  3234.                             // $emLev = Util::emCreateConfiguration($this->realContainer, $dataOptionsRoot);
  3235.                             $configuracion = $emLev->getRepository('App\Structure\Configuracion')->find(1);
  3236.                             $configuracion->setNumberOfSyncDataRecords((int) $data['numberOfSyncDataRecords']);
  3237.                             $configuracion->setMaxRecordsSyncUpDown((int) $this->realContainer->getParameter('max_records_sync_up_down'));
  3238.                             $configuracion->setMaxRecordsSyncDownUp((int) $this->realContainer->getParameter('max_records_sync_down_up'));
  3239.                             $emLev->persist($configuracion);
  3240.                             $emLev->flush();
  3241.                         }
  3242.                     }
  3245.                     $em->persist($licenseOrSublicenseToValidate);
  3246.                     $em->flush();
  3248.                     try {
  3249.                         $theRespArray = Util::getLastVersionByJsonVersionFile($this->realContainer, $data['version'], true, $path);
  3250.                     } catch (\Exception $ex) {
  3251.                         $theRespArray['updateAppError'] = true;
  3252.                     }
  3254.                     try {
  3255.                         $theRespArrayTwo = Util::getLastVersionByDirAvailableVersions($this->realContainer, $data['version'], true, $path);
  3256.                     } catch (\Exception $ex) {
  3257.                         $theRespArrayTwo['updateAppError'] = true;
  3258.                     }
  3260.                     if (isset($theRespArray['updateAppError']) && $theRespArray['updateAppError'] && isset($theRespArrayTwo['updateAppError']) && $theRespArrayTwo['updateAppError']) {
  3261.                         return $this->setStatusCode(WebService::HTTP_CODE_SERVICE_UNAVAILABLE)
  3262.                                         ->respondWithError('Error finding last version', WebService::CODE_OBJECT_NOT_FOUND);
  3263.                     }
  3265.                     if (isset($theRespArray["newVersion"]) && isset($theRespArrayTwo["newVersion"])) {
  3266.                         if ($theRespArray["newVersion"] < $theRespArrayTwo["newVersion"]) {
  3267.                             $theRespArray = $theRespArrayTwo;
  3268.                         }
  3269.                     } elseif (!isset($theRespArray["newVersion"]) && isset($theRespArrayTwo["newVersion"])) {
  3270.                         $theRespArray = $theRespArrayTwo;
  3271.                     }
  3273.                     if (isset($data['version'])) {
  3274.                         if (strpos($data['version'], '-')) {
  3275.                             $this->createFileJson($path, 'Is a testing version...?  ' . $data['version'] . "\r");
  3276.                             $data['version'] = explode('-', $data['version'])[0];
  3277.                         }
  3278.                     }
  3280.                     ForcedAsynchronousCommandsUtil::recoveryInformationInProyects($this->realContainer, ['licenseId' => $accountLicenseData[0]->getId(), 'mode' => 0]);
  3282.                     if (isset($theRespArray['newVersion'])) {
  3284.                         $newVersionString = Util::validateNewerVersion($data['version'], $theRespArray['newVersion']);
  3286.                         if ($newVersionString == $theRespArray['newVersion'] && $newVersionString != $data['version']) {
  3287.                             $country = $accountLicenseData[0]->getCity()->getCiState()->getStCountry()->getCoVal();
  3288.                             $isCallCenter = $accountLicenseData[0]->getIsCallCenter();
  3290.                             $theRespArray['success'] = WebService::CODE_SUCCESS;
  3291.                             $theRespArray['country'] = $country;
  3292.                             $theRespArray['iscallcenter'] = (int) $isCallCenter;
  3294.                             $theUrlTrSt = new UpdateAndroidCommandTransformer($this->realContainer, $theRespArray);
  3295.                             $xxArray = $theUrlTrSt->transform();
  3297.                             $jsonContent = json_encode($xxArray);
  3299.                             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  3300.                         }
  3301.                     }
  3303.                     $newVersionString = Util::validateNewerVersion($accountLicenseData[0]->getAndroidVersionName(), $data['version']);
  3305.                     if (!isset($theRespArray["newVersion"]) && $newVersionString != $accountLicenseData[0]->getAndroidVersionName() && preg_match('/^(\d+\.)(\d+\.)(\d+)$/', $data['version'])) {
  3306.                         $body = "<p><label>Server: <strong>http://" . $this->realContainer->getParameter("licensor_base_url") . "/licensor/login</strong></label><br></p>";
  3307.                         $body .= "<p><label><strong>" . $accountLicenseData[0]->getAlLicenseUsername() . "</strong></label></p>";
  3308.                         $body .= "<p><label>The server has been updated from version: <strong>" . $accountLicenseData[0]->getAndroidVersionName() . "</strong>  to version: <strong>" . $data['version'] . "</strong></label><br></p>";
  3310.                         $respArray['subject'] = 'Android APK version updated ' . $accountLicenseData[0]->getAlLicenseUsername();
  3311.                         $respArray['message'] = "";
  3313.                         $accountLicenseData[0]->setAndroidVersionName($data['version']);
  3314.                         $accountLicenseData[0]->setVersionUpdatedDate(Util::getCurrentDate());
  3316.                         $em->persist($accountLicenseData[0]);
  3317.                         $em->flush();
  3319.                         $sendEmail = $this->realContainer->getParameter('level_emails_syncs_errors');
  3321.                         foreach ($sendEmail as $mailTo) {
  3322.                             $this->createFileJson($path, "Mail to -> " . $mailTo . "\r");
  3324.                             $respArray['to'] = $mailTo;
  3326.                             Utilx::sendMailInfo($this->realContainer, $respArray, $path, $body);
  3327.                         }
  3329.                         $pushSendRepository = $em->getRepository('App\Entity\PushSent');
  3330.                         $pushSendRepository->respondOldPushesForLicense(PushSent::PUSH_TYPE_APK_UPDATE, $accountLicenseData[0]->getId());
  3331.                     }
  3333.                     if ($data['version']) {
  3334.                         $connectionRecord = $em->getRepository('App\Entity\AccountLicense')->getTheLastesVersionRegisteredInDataBaseByWorkingAPKs();
  3336.                         $newVersionString = Util::getDifferenceBetweenVersion($this->realContainer->getParameter('max_difference_in_APK_server_version_allowed'), $data['version'], $connectionRecord['androidVersionName']);
  3338.                         if (is_array($newVersionString) && isset($newVersionString['needsEmail']) && $newVersionString['needsEmail']) {
  3339.                             // $body = "<p><label>Server: <strong>http://" . $this->realContainer->getParameter("licensor_base_url") . "/licensor/login</strong></label><br></p>";
  3340.                             // $body .= "<p><label>License: <strong>" . $accountLicenseData[0] . "</strong></label></p>";
  3341.                             // $body .= "<p><label>License Version: <strong>" . $data['version'] . "</strong></label></p>";
  3342.                             // $body .= "<p><label>Newer Version In Use: <strong>" . $connectionRecord['androidVersionName'] . "</strong></label></p>";
  3343.                             // $body .= "<p><label>Message: <strong>" . sprintf($newVersionString['versionResult'], "'" . $accountLicenseData[0] . "'") . "</strong></label><br></p>";
  3345.                             // $respArray['subject'] = "Android APK needs an immediate update for '" . $accountLicenseData[0]->getAlLicenseUsername() . "' license";
  3346.                             // $respArray['message'] = "";
  3348.                             // $sendEmail = $this->realContainer->getParameter('level_emails_support_warnings');
  3350.                             // foreach ($sendEmail as $mailTo) {
  3351.                             //     $this->createFileJson($path, "Mail to -> " . $mailTo . "\r");
  3353.                             //     $respArray['to'] = $mailTo;
  3355.                             //     Utilx::sendMailInfo($this->realContainer, $respArray, $path, $body);
  3356.                             // }
  3358.                             // Inicio de lógica, validación de notificación.
  3359.                             if(!$accountLicenseData[0]->getIsTesting()){
  3360.                                 $currentDate = Utilx::getCurrentDate();
  3361.                                 $seed = $em->getRepository("App\Entity\NotificationInLicensorBell")->findOneBy(["context" => NotificationInLicensorBell::CONTEXT_NOTIFICATION_ANDROID_UPDATE_NEEDED, "license" => $accountLicenseData[0]]);
  3362.     
  3363.                                 if(!is_null($seed)){
  3364.                                     $dateMinusOneWeek = clone $currentDate;
  3365.                                     $dateMinusOneWeek->modify('-1 week');
  3366.     
  3367.                                     if ($dateMinusOneWeek >= $seed->getPickedtByValidatingCronDate()) {
  3368.                                         $seed->setDateCreated($currentDate);
  3369.                                         $seed->setPickedtByValidatingCronDate(null);
  3370.                                         $seed->setNotificationMsg("License:" . $accountLicenseData[0] . "License Version:".$data['version'] ."Newer Version In Use:" .$connectionRecord['androidVersionName'] ."Message:" . sprintf($newVersionString['versionResult'], "'" . $accountLicenseData[0] . "'"));
  3371.     
  3372.                                         $em->persist($seed);
  3373.                                         $em->flush();
  3374.                                     }
  3375.                                 }else{
  3376.                                     $seed = new NotificationInLicensorBell();
  3377.     
  3378.                                     $seed->setNotificationTitle('Android APK needs update for ' . $accountLicenseData[0]->getAlLicenseUsername() . ' license');
  3379.                                     $seed->setNotificationLabel(NotificationInLicensorBell::NOTIFICATION_TYPE_WARNING);
  3380.                                     $seed->setNotificationMsg("License:" . $accountLicenseData[0] . "License Version:".$data['version'] ."Newer Version In Use:" .$connectionRecord['androidVersionName'] ."Message:" . sprintf($newVersionString['versionResult'], "'" . $accountLicenseData[0] . "'"));
  3381.                                     $seed->setDateCreated($currentDate);
  3382.                                     $seed->setContext(NotificationInLicensorBell::CONTEXT_NOTIFICATION_ANDROID_UPDATE_NEEDED);
  3383.                                     $seed->setLicense($accountLicenseData[0]);
  3384.                                     $seed->setTypeRoleToNotify(NotificationInLicensorBell::ROLE_ADMINISTRATOR);
  3385.     
  3386.                                     $em->persist($seed);
  3387.                                     $em->flush();
  3388.                                 }
  3389.                             }
  3390.                         }
  3391.                         // Fin de lógica, validación de notificación por una semana.
  3392.                     }
  3394.                     if(isset($data["debug"]) && $data["debug"]){
  3395.                         dump((isset($emLev) && !empty($emLev)));
  3396.                         dump(isset($emLev) && $emLev);
  3397.                         dump($emLev, isset($emLev), !empty($emLev));
  3398.                     } 
  3400.                     if (isset($emLev) && !empty($emLev)) {
  3401.                         $clienteForWebAndroidLogin = $emLev->getRepository('App\Structure\Usuario')->findBy(['usuLogin' => 'admin']);
  3403.                         $auxArrayUserAndroidWebLogin = [];
  3404.                         if (isset($clienteForWebAndroidLogin[0])) {
  3405.                             $auxArrayUserAndroidWebLogin['user'] = 'admin';
  3406.                             $auxArrayUserAndroidWebLogin['pass'] = $clienteForWebAndroidLogin[0]->getUsuPass();
  3407.                             $auxArrayUserAndroidWebLogin['nickname'] = $accountLicenseData[0]->getAlLicenseUsername();
  3408.                         }
  3410.                         $pushServicesKeysArray = Util::buildTheServicesKeysArray($this->realContainer, $accountLicenseData[0], $auxArrayUserAndroidWebLogin);
  3411.                     } else {
  3412.                         $pushServicesKeysArray = Util::buildTheServicesKeysArray($this->realContainer, $accountLicenseData[0]);
  3413.                     }
  3415.                     if ($accountLicenseData[0]->getLevelLightUser()) {
  3416.                         $userData = $accountLicenseData[0]->getLevelLightUser();
  3418.                         /**
  3419.                          * Allows to add the apikey to the user of lite level this exported in OMT
  3420.                          */
  3421.                         if ($accountLicenseData[0]->getHasLogedOMT() == true) {
  3422.                             $apikey = Util::doOMTDashboardLoginToGetToken($this->realContainer, $userData, $path, $accountLicenseData[0]->getLoginType());
  3423.                             
  3424.                             if (!empty($apikey)) {
  3425.                                 $userData['apikey'] = $apikey;
  3426.                                 $responseArr['userToOmt']['apikey'] = $apikey;
  3427.                             } else {
  3428.                                 $responseArr['userToOmt']['apikey'] = '';
  3429.                             }
  3431.                             $accountLicenseData[0]->setLevelLightUser($userData);
  3432.                             $em->persist($accountLicenseData[0]);
  3433.                             $em->flush();
  3434.                         } else {
  3435.                             $responseArr['userToOmt']['apikey'] = '';
  3436.                         }
  3438.                         $responseArr['userToOmt']['username'] = $userData['username'];
  3439.                         $responseArr['userToOmt']['password'] = $userData['realPass'];
  3440.                     }
  3442.                     if ($accountLicenseData[0]->getAwsTopicARN() && $accountLicenseData[0]->getAwsTopicARN() != '' && $accountLicenseData[0]->getAwsTopicARN() != "" ) {
  3443.                         if (isset($pushServicesKeysArray['awsPush'])) {
  3444.                             $pushServicesKeysArray['awsPush']['TopicArn'] = $accountLicenseData[0]->getAwsTopicARN();
  3445.                         }
  3446.                     }
  3448.                     ///////
  3450.                     if ($accountLicenseData[0]->getNeedsOneUpdaownSync()) {
  3451.                         ForcedAsynchronousCommandsUtil::callPriorityUpDownSync($this->realContainer, ['license' => $accountLicenseData[0]->getId()], true);
  3452.                         //// podria ser el llamdo con prioridad que se haga desde aca, toca verificar la prioridad en cuanto al funcionamiento general de sync
  3453.                     }
  3455.                     ///////
  3457.                     $responseArr['status'] = WebService::CODE_SUCCESS;
  3458.                     $responseArr['push_services'] = $pushServicesKeysArray;
  3459.                     $responseArr['msg'] = 'Valid login and actual apk version installed!';
  3460.                     $responseArr['url'] = '';
  3461.                     $responseArr['directoryOmtS3'] = [
  3462.                         'directoryImageProduct' => $this->realContainer->getParameter('AWS_ENVIRONMENT_FOLDER') . 'images/product',
  3463.                         'directoryImageRestaurant' => $this->realContainer->getParameter('AWS_ENVIRONMENT_FOLDER') . 'images/restaurant'
  3464.                     ];
  3466.                     $accountLicenseData[0]->setLastValidatedLoginDate(Util::getCurrentDate());
  3468.                     if ($accountLicenseData[0]->getLoginType() == AccountLicense::LOGGED_OUT) {
  3469.                         $accountLicenseData[0]->setLoginType(AccountLicense::LOGGED_BY_LEVEL_ANDROID);
  3470.                     } else if ($accountLicenseData[0]->getLoginType() == AccountLicense::LOGGED_BY_LEVEL_LITE) {
  3471.                         $accountLicenseData[0]->setLoginType(AccountLicense::LOGGED_BY_LEVEL_LITE_AND_ANDROID);
  3472.                     }
  3474.                     $em->persist($accountLicenseData[0]);
  3475.                     $em->flush();
  3477.                     // Se valida que el parametro timeZone exista para guardarlo en las Tablas Configuracion y AccountLicense
  3478.                     if (isset($data['timeZone']) && trim($data['timeZone']) !== '') {
  3479.                         $timeZone = trim($data['timeZone']);
  3480.                         $configuracion = $emLev->getRepository('App\Structure\Configuracion')->findAll();
  3482.                         if (isset($configuracion[0])) {
  3483.                             $configuracion[0]->setTimeZoneRes($timeZone);
  3484.                             $emLev->persist($configuracion[0]);
  3485.                             $emLev->flush();
  3486.                         }
  3488.                         $accountLicenseData[0]->setTimeZoneRes($timeZone);
  3489.                         $em->persist($accountLicenseData[0]);
  3490.                         $em->flush();
  3492.                     }
  3494.                     $theUrlTrSt = new DemoForLoginTransformer($this->realContainer, $responseArr);
  3495.                     $xxArray = $theUrlTrSt->transform();
  3497.                     $jsonContent = json_encode($xxArray);
  3499.                     return $this->respondWithItem($jsonContent, $theUrlTrSt);
  3500.                 } else {
  3501.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  3502.                                     ->respondWithError('Invalid UID', WebService::CODE_COULD_NOT_AUTHENTICATE);
  3503.                 }
  3504.             } else {
  3505.                 $this->createFileJson($path, "\r" . 'Wrong Content.', WebService::CODE_WRONG_ARGUMENTS . "\r");
  3506.                 return $this->errorWrongArgs('Wrong Content.', WebService::CODE_WRONG_ARGUMENTS);
  3507.             }
  3508.         } else {
  3509.             $this->createFileJson($path, "\r" . 'Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method" . "\r");
  3510.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  3511.         }
  3512.     }
  3514.     /**
  3515.      * WS Para validar giftcards segun la licencia, el estado de esta y el
  3516.      * saldo registrado en licensor
  3517.      * @author Aealan Z <lrobledo@kijho.com> 02/02/16
  3518.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  3519.      * @return Response Json con la informacion de respuesta
  3520.      */
  3521.     public function giftCardTransaction(Request $request, ArmorService $armor, Log $log) {
  3522.         $path = Util::getValidActiveLogByBaseName($this->realContainer, 'GiftCardTransaction', 'GiftCardTransaction0.txt');
  3524.         // validacion del metodo de peticion POST
  3525.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  3527.             // Validacion de tamaño en contenido, validacion de datos nulos - vacios
  3528.             if (0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE) || 0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT)) {
  3529.                 $this->createFileJson($path, "\r" . 'Validate GiftCard: ' . $request->getContent() . "\r");
  3531.                 $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  3533.                 // Datos desencriptados
  3534.                 $data = json_decode($arrayEncryptResult['data'], true);
  3536.                 $em = $this->getDoctrine()->getManager();
  3537.                 $worksWithArmor = false;
  3539.                 //////
  3541.                 /*
  3542.                  *
  3543.                     {
  3544.                     "nickname": "noonansb_206",
  3545.                     "uid": "5ad093af8070f25f",
  3546.                     "type": 1,
  3547.                     "order_id": "720b4297-90df-4c2a-b06b-d9c0815390f5",
  3548.                     "amount": 25,
  3549.                     "gift_code": "8814"
  3550.                     }
  3552.                     {
  3553.                     "nickname":"blackdoc_28",
  3554.                     "uid":"coquitoXX",
  3555.                     "token":"ElTokenCochinoEse"
  3556.                     }
  3557.                     *
  3558.                     *
  3559.                     {
  3560.                     "gift_card_id":"3b02add2-e376-11e8-853e-0242ac130004",  // primaria en la bd de licensor
  3561.                     "issuing": "406b63b7-9ad6-4327-9af9-bdbca33ee637",      // usuario al que pertenece la giftCard
  3562.                     "number": "6",
  3563.                     "balance": "4800",
  3564.                     "activation_date": "1409175049",
  3565.                     "deactivation_date": "1509175049",
  3566.                     "identifier": "b07b77b7-7ad7-7777-7af7-bdbca77ee77",    // no se sabe para que putas, me la invento y ya
  3567.                     "status": "1"
  3568.                     }
  3569.                  *
  3570.                  */
  3572.                 if (isset($data['token']) && base64_encode(base64_decode($data['token'])) === $data['token']) {
  3574.                     $decodeJWT = json_decode(Encryptor::decodeInfo($data['token'], 5), true);
  3576.                     $armorGiftCodeToSearch = $decodeJWT['number'];
  3578.                     $data['amount'] = Encryptor::decodeInfo($decodeJWT['balance'], 5);
  3579.                     $data['gift_code'] = Encryptor::decodeInfo($decodeJWT['number'], 5);
  3580.                     $data['order_id'] = $decodeJWT['order_id'];
  3581.                     $data['type'] = $decodeJWT['type'];
  3582.                     $data['identifier'] = $decodeJWT['identifier'];
  3583.                     $data['activation_date'] = $decodeJWT['activation_date'];
  3585.                     $client = $em->getRepository('App\Entity\OmtClient')->find($decodeJWT['issuing']);
  3586.                     if (!$client) {
  3587.                         return $this->errorWrongArgs('Customer not found!', WebService::CODE_OBJECT_NOT_FOUND);
  3588.                     }
  3590.                     $worksWithArmor = true;
  3591.                 }
  3593.                 if (((!isset($data['nickname']) || !isset($data['uid']) || !isset($data['type']) 
  3594.                 || !isset($data['amount']) || !isset($data['gift_code'])) && !$worksWithArmor) 
  3595.                 || ($worksWithArmor && !isset($data['token']))) {
  3597.                     $this->createFileJson($path, 'Error: Wrong Arguments!' . "\r");
  3598.                     return $this->errorWrongArgs('Wrong Arguments!', WebService::CODE_WRONG_ARGUMENTS);
  3600.                 }
  3602.                 if (!is_numeric($data['amount']) || !is_numeric($data['type']) || $data['gift_code'] == '') {
  3604.                     $this->createFileJson($path, 'Error: Wrong Type Arguments!' . "\r");
  3605.                     return $this->errorWrongArgs('Wrong Type Arguments!', WebService::CODE_WRONG_ARGUMENTS);
  3607.                 }
  3609.                 $dataToSearch = ['alLicenseUsername' => $data['nickname']];
  3611.                 $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findBy($dataToSearch);
  3613.                 if (empty($accountLicenseData)) {
  3615.                     $this->createFileJson($path, 'Error: Invalid nickname' . "\r");
  3617.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  3618.                     ->respondWithError('Invalid nickname', WebService::CODE_COULD_NOT_AUTHENTICATE);
  3620.                 } else {
  3622.                     $gcStatus = $accountLicenseData[0]->getGiftCardStatus();
  3623.                     if (!$gcStatus) {
  3624.                         $this->createFileJson($path, "The restaurant has no active gift card payments \r");
  3625.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  3626.                                     ->respondWithError('The restaurant has no active gift card payments', WebService::CODE_ACCOUNT_SUSPENDED);
  3627.                     }
  3629.                     if ($accountLicenseData[0]->getAlAccountLicense()->getDeleted()) {
  3631.                         $this->createFileJson($path, 'Error: Account is inactive' . "\r");
  3633.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  3634.                         ->respondWithError('Account is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  3636.                     }
  3638.                     if ($accountLicenseData[0]->getAlLicenseStatus() != AccountLicense::LICENSE_STATUS_ACTIVE) {
  3640.                         $this->createFileJson($path, 'Error: License is inactive' . "\r");
  3642.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  3643.                         ->respondWithError('License is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  3645.                     }
  3647.                     $licenseToValidate = $accountLicenseData[0];
  3649.                     if ($licenseToValidate->getDeviceUid() != $data['uid']) {
  3651.                         $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData[0]);
  3653.                         $registeredClientsByUID = $emLev->getRepository('App\Structure\Stations')->findBy(['staDeviceCode' => $data['uid']]);
  3655.                         if (empty($registeredClientsByUID)) {
  3657.                             $emLev->close();
  3658.                             $this->createFileJson($path, 'Error: Unknown device' . "\r");
  3660.                             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)->respondWithError('Unknown device', WebService::CODE_UNAUTHORIZED);
  3661.                         
  3662.                         } else {
  3663.                             $emLev->close();
  3664.                         }
  3665.                     }
  3667.                     $actualDate = Util::getCurrentDate();
  3669.                     $responseArr['bigbag'] = true;
  3671.                     if (isset($data['transaction_id']) && $data['transaction_id'] != '' 
  3672.                     && (GiftCardTransaction::TRANSACTION_TYPE_BUY_WITH_GIFTCARD == (int) $data['type'] 
  3673.                     || GiftCardTransaction::TRANSACTION_TYPE_REFUND_GIFTCARD == (int) $data['type'])) {
  3675.                         $giftCardTransaction = $em->getRepository('App\Entity\GiftCardTransaction')->find($data['transaction_id']);
  3676.                     
  3677.                     } else {
  3679.                         $giftCardTransaction = new GiftCardTransaction();
  3680.                     }
  3682.                     if (!$giftCardTransaction) {
  3684.                         $this->createFileJson($path, 'GiftCard transaction not found in licensor!' . "\r");
  3686.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  3687.                         ->respondWithError('GiftCard transaction not found!', WebService::GIFTCARD_WS_STATUS_GIFTCARD_TRANSACTION_NOT_FOUND_ERROR);
  3688.                     }
  3690.                     $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData[0]);
  3692.                     $theTransactionType = $data['type'];
  3693.                     $levelWebGiftCardRepo = $emLev->getRepository('App\Structure\GiftCard');
  3695.                     $doGiftCardLogRecord = true;
  3697.                     if ($worksWithArmor && GiftCardTransaction::TRANSACTION_TYPE_NEW_GIFTCARD != (int) $data['type']) {
  3699.                         $log->createChannel('gift_card');
  3701.                         $url = $this->getParameter('armor_host') . "gift/gift-cards/" . $decodeJWT['number'] . "/number";
  3703.                         $dataResponse = $armor->armorGet($request, $url, $log);
  3705.                         if (!isset($dataResponse['id'])) {
  3706.                             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  3707.                             ->respondWithError('Giftcard not found in Armor!', WebService::GIFTCARD_WS_STATUS_GIFTCARDNOTFOUND_ERROR);
  3708.                         }
  3710.                         $giftCardRecord = $em->getRepository('App\Entity\GiftCard')->findBy(['gcVerificationCode' => $dataResponse['id']]);
  3712.                         if (empty($giftCardRecord)) {
  3713.                             $giftCardRecord = $em->getRepository('App\Entity\GiftCard')->findBy(['gcVerificationCode' => $data['nickname'] .'-'. $dataResponse['id']]);
  3714.                         }
  3716.                         $amountInArmor = Encryptor::decodeInfo($dataResponse['balance'], 5);
  3718.                         if (isset($giftCardRecord[0]) && $amountInArmor != $giftCardRecord[0]->getGcAmount()) {
  3720.                             $this->createFileJson($path, 'Different GT amount error!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!' . "\r");
  3721.                             $this->createFileJson($path, 'Armor amount -> ' . $amountInArmor . "\r");
  3722.                             $this->createFileJson($path, 'Licensor amount -> ' . $giftCardRecord[0]->getGcAmount() . "\r");
  3724.                             $giftCardRecord[0]->setGcAmount($amountInArmor);
  3726.                             $em->persist($giftCardRecord[0]);
  3727.                             $em->flush();
  3729.                         } elseif (!isset($giftCardRecord[0])) {
  3731.                             $this->createFileJson($path, 'GiftCard not found in Licensor A!!!' . $giftCardRecord[0]->getGcAmount() . "\r");
  3732.                             return $this->errorWrongArgs('GiftCard not found!', WebService::CODE_OBJECT_NOT_FOUND);
  3734.                         }
  3736.                         $data['gift_code'] = $dataResponse['id'];
  3738.                     } else {
  3740.                         $otherAuxGiftcardCode = $data['nickname'] .'-'. $data['gift_code'];
  3742.                         $giftCardRecord = $em->getRepository('App\Entity\GiftCard')->findBy(['gcVerificationCode' => $otherAuxGiftcardCode]);
  3744.                         if (empty($giftCardRecord)) {
  3746.                             $giftCardRecord = $em->getRepository('App\Entity\GiftCard')->findOneBy(['gcVerificationCode' => $data['gift_code']]);
  3748.                             if ($giftCardRecord && $giftCardRecord->getGcCreatorLicense()->getId() != $accountLicenseData[0]->getId()) {
  3749.                                 
  3750.                                 $giftCardRecord = null;
  3751.                                 $this->createFileJson($path, 'New giftcard with same base code as other licence ' . $data['gift_code'] . "\r");
  3752.                             
  3753.                             } else {
  3754.                                 $this->createFileJson($path, 'Redy for a very new giftcard with base code ' . $data['gift_code'] . "\r");
  3755.                             }
  3757.                         }
  3759.                         if (isset($data['debug'])) {
  3760.                             dump($giftCardRecord);
  3761.                         }
  3762.                     }
  3764.                     if (GiftCardTransaction::TRANSACTION_TYPE_NEW_GIFTCARD == (int) $data['type'] && empty($giftCardRecord)) {
  3766.                         $this->createFileJson($path, 'New GiftCard to licensor ' . "\r");
  3768.                         $theGiftCard = new GiftCard();
  3770.                         $theGiftCard->setGcAmount($data['amount']);
  3771.                         $theGiftCard->setGcVerificationCode($data['nickname'] .'-'. $data['gift_code']);
  3773.                         $theGiftCard->setGcReleaseDate($actualDate);
  3775.                         if (isset($data['activation_date'])) {
  3777.                             try {
  3778.                                 $theGiftCard->setGcActivateDate(new DateTime($data['activation_date']));
  3779.                             } catch (\Exception $ex) {
  3780.                                 $theGiftCard->setGcActivateDate(new DateTime('now'));
  3781.                             }
  3783.                         } else {
  3784.                             $theGiftCard->setGcActivateDate(new DateTime('now'));
  3785.                         }
  3787.                         if (isset($data['status'])) {
  3788.                             $theGiftCard->setGcStatus(GiftCard::STATUS_DEACTIVATE);
  3789.                         } else {
  3790.                             $theGiftCard->setGcStatus(GiftCard::STATUS_ACTIVE);
  3791.                         }
  3793.                         $theGiftCard->setGcCreatorLicense($licenseToValidate);
  3794.                         $theGiftCard->setGcAccount($licenseToValidate->getAlAccountLicense());
  3796.                         $em->persist($theGiftCard);
  3797.                         $em->flush();
  3799.                         if ($worksWithArmor) {
  3801.                             $decodeJWT['gift_card_id'] = $theGiftCard->getId();
  3802.                             $decodeJWT['identifier'] = $theGiftCard->getId();
  3803.                             $decodeJWT['balance'] = Encryptor::encodeInfo($data['amount'], 5);
  3805.                             $token = Encryptor::encodeInfo(json_encode($decodeJWT));
  3807.                             $request = $armor->duplicateRequestWithOverwritedContentForArmorServer($request, ['token' => $token]);
  3809.                             $log->createChannel('gift_card');
  3811.                             $url = $this->getParameter('armor_host') . "gift/add-gift-card";
  3812.                             $dataResponse = $armor->armorPost($request, $url, $log);
  3814.                             if ($dataResponse instanceof Response) {
  3816.                                 $jsonResponse = $dataResponse->getContent();
  3818.                                 $decodedResponse = json_decode($jsonResponse, true);
  3819.                                 $neededArmorId = $data['nickname'] .'-'. $decodedResponse['data']['gift_card_id'];
  3820.                                 $data['gift_code'] = $neededArmorId;
  3822.                                 $theGiftCard->setGcVerificationCode($neededArmorId);
  3824.                                 $em->persist($theGiftCard);
  3825.                                 $em->flush();
  3826.                             }
  3827.                         }
  3829.                         $giftCardWebData = new stdClass();
  3830.                         $giftCardWebData->gift_status = $data['type'];
  3831.                         $giftCardWebData->gift_price = $data['amount'];
  3832.                         $giftCardWebData->gift_code = $data['gift_code'];
  3833.                         $giftCardWebData->gift_date = $actualDate->format('Y-m-d H:i:s');
  3834.                         $giftCardWebData->licId = $theGiftCard->getId();
  3835.                         $giftCardWebData->id = UUIDGeneratorUtil::getUUIDv4();
  3837.                         $this->createFileJson($path, 'Ready to insert GiftCard into license database -> ' . json_encode($giftCardWebData) . "\r");
  3839.                         $emLevCreatorGiftCard = $emLev;
  3840.                         $queryResponse = $levelWebGiftCardRepo->setDataUploadOne($this->realContainer, $giftCardWebData, $path);
  3842.                         if (is_array($queryResponse)) {
  3844.                             $responseArr['msg'] = 'GiftCard registed and activated successfully!!';
  3845.                             $responseArr['status'] = WebService::GIFTCARD_WS_STATUS_NEW_GIFTCARD_SUCCESS;
  3847.                             $this->createFileJson($path, 'New GiftCard registed successfully!' . "\r");
  3849.                         } else {
  3850.                             
  3851.                             if (strpos($queryResponse, '1062 Duplicate entry') && strpos($queryResponse, $data['nickname'] .'-'. $data['gift_code'])) {
  3852.                                 
  3853.                                 $responseArr['msg'] = "GiftCard with '" . $data['gift_code'] . "' code already registed in " . $accountLicenseData[0] . " restaurant" ;
  3854.                                 $responseArr['status'] = WebService::GIFTCARD_WS_STATUS_GIFTCARD_ALREADY_REGISTED_ERROR;
  3855.                                 
  3856.                                 $this->createFileJson($path, "GiftCard with '" . $data['gift_code'] . "' code already registed in " . $accountLicenseData[0] . " restaurant" . "\r");
  3857.                             
  3858.                             } else {
  3860.                                 $this->createFileJson($path, 'Error in licensor new Giftcard transaction! -> ' . $queryResponse . "\r");
  3861.                                 
  3862.                                 return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)
  3863.                                 ->respondWithError('Error in transaction!', WebService::GIFTCARD_WS_STATUS_TRANSACTION_ERROR);
  3864.                             }
  3866.                         }
  3868.                     } elseif (GiftCardTransaction::TRANSACTION_TYPE_NEW_GIFTCARD == (int) $data['type'] && !empty($giftCardRecord)) {
  3869.                         
  3870.                         $this->createFileJson($path, 'Error: GiftCard already registed in licensor' . "\r");
  3871.                         
  3872.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  3873.                         ->respondWithError('GiftCard already registed!', WebService::GIFTCARD_WS_STATUS_GIFTCARD_ALREADY_REGISTED_ERROR);
  3874.                     
  3875.                     } elseif (!empty($giftCardRecord) && $giftCardRecord[0]->getGcStatus() != GiftCard::STATUS_DEACTIVATE) {
  3876.                         
  3877.                         $this->createFileJson($path, 'Searching old licensor giftcard...' . "\r");
  3879.                         if (!empty($giftCardRecord)) {
  3881.                             $this->createFileJson($path, 'Licensor giftcard found!' . "\r");
  3882.                             $theGiftCard = $giftCardRecord[0];
  3884.                             // if ($licenseToValidate->getAlAccountLicense()->getId() != $theGiftCard->getGcAccount()->getId()) {
  3885.                             //  $this->createFileJson($path, 'Error: Giftcard of another franchise!' . "\r");
  3886.                             //  return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  3887.                             //  ->respondWithError('Giftcard of another franchise!', WebService::GIFTCARD_WS_STATUS_GIFTCARD_OTHER_FRANCHISE_ERROR);
  3888.                             // }
  3890.                             if ($theGiftCard->getGcCreatorLicense()->getId() != $licenseToValidate->getId()) {
  3891.                                 
  3892.                                 $emLevCreatorGiftCard = Util::emLicenseConnection($this->realContainer, $em, $licenseToValidate);
  3893.                                 $levelWebGiftCardCreatorRepo = $emLevCreatorGiftCard->getRepository('App\Structure\GiftCard');
  3894.                             
  3895.                             } else {
  3897.                                 $emLevCreatorGiftCard = $emLev;
  3898.                                 $levelWebGiftCardCreatorRepo = $levelWebGiftCardRepo;
  3900.                             }
  3902.                             switch ($data['type']) {
  3904.                                 case GiftCardTransaction::TRANSACTION_TYPE_BUY_WITH_GIFTCARD:
  3906.                                     $this->createFileJson($path, 'Transaction successfully!' . "\r");
  3908.                                     if (isset($data['transaction_id'])) {
  3910.                                         $theGiftCard->setGcLastTransactionDate($actualDate);
  3912.                                     } else {
  3914.                                         if (($theGiftCard->getGcAmount() - (double) $data['amount']) < 0.0) {
  3915.                                             
  3916.                                             $this->createFileJson($path, 'Not eunogh founds in giftcard, transaction declined!' . "\r");
  3917.                                             
  3918.                                             $responseArr['msg'] = 'Not eunogh founds in giftcard, transaction declined!';
  3919.                                             $responseArr['status'] = WebService::GIFTCARD_WS_STATUS_TRANSACTION_ERROR;
  3920.                                             $responseArr['amount'] = $theGiftCard->getGcAmount();
  3921.                                             $responseArr['requestedAmount'] = $data['amount'];
  3922.                                             $responseArr['isActive'] = (int) ((boolean) ($theGiftCard->getGcStatus() % GiftCard::STATUS_DEACTIVATE));
  3923.                                             
  3924.                                             $responseArr['activationDate'] = "";
  3926.                                             if ($theGiftCard->getGcActivateDate()) {
  3927.                                                 $responseArr['activationDate'] = $theGiftCard->getGcActivateDate()->format('Y-m-dTH:i:s');
  3928.                                             }
  3930.                                             $responseArr['lastTransactionDate'] = "";
  3932.                                             if ($theGiftCard->getGcLastTransactionDate()) {
  3933.                                                 $responseArr['lastTransactionDate'] = $theGiftCard->getGcLastTransactionDate()->format('Y-m-dTH:i:s');
  3934.                                             }
  3936.                                             $responseArr['deactivationDate'] = "";
  3938.                                             if ($theGiftCard->getGcDeactivateDate()) {
  3939.                                                 $responseArr['deactivationDate'] = $theGiftCard->getGcDeactivateDate()->format('Y-m-dTH:i:s');
  3940.                                             }
  3942.                                             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  3943.                                             $xxArray = $theUrlTrSt->transform();
  3945.                                             $jsonContent = json_encode($xxArray);
  3947.                                             $this->createFileJson($path, 'The WS Response -> ' . $jsonContent . "\r");
  3949.                                             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  3951.                                         } else {
  3952.                                             $theGiftCard->setGcAmount($theGiftCard->getGcAmount() - (double) $data['amount']);
  3953.                                         }
  3954.                                     }
  3956.                                     $responseArr['msg'] = 'Transaction successfully!';
  3957.                                     $responseArr['status'] = WebService::GIFTCARD_WS_STATUS_TRANSACTION_SUCCESS;
  3959.                                     break;
  3960.                                 case GiftCardTransaction::TRANSACTION_TYPE_RECHARGE_GIFTCARD:
  3962.                                     $this->createFileJson($path, 'Recharge successfully!' . "\r");
  3963.                                     
  3964.                                     $theGiftCard->setGcLastTransactionDate($actualDate);
  3965.                                     $theGiftCard->setGcAmount($theGiftCard->getGcAmount() + (double) $data['amount']);
  3967.                                     $responseArr['msg'] = 'Recharge successfully!';
  3968.                                     $responseArr['status'] = WebService::GIFTCARD_WS_STATUS_RECHARGE_SUCCESS;
  3970.                                     break;
  3971.                                 case GiftCardTransaction::TRANSACTION_TYPE_REFUND_RECHARGE_GIFTCARD:
  3973.                                     $this->createFileJson($path, 'Recharge canceled successfully!' . "\r");
  3975.                                     $theGiftCard->setGcLastTransactionDate($actualDate);
  3976.                                     $theGiftCard->setGcAmount($theGiftCard->getGcAmount() - (double) $data['amount']);
  3978.                                     $responseArr['msg'] = 'Recharge canceled successfully!';
  3979.                                     $responseArr['status'] = WebService::GIFTCARD_WS_STATUS_REFUND_RECHARGE_SUCCESS;
  3981.                                     break;
  3982.                                 case GiftCardTransaction::TRANSACTION_TYPE_REFUND_GIFTCARD:
  3984.                                     $this->createFileJson($path, 'Refund successfully!' . "\r");
  3985.                                     $theGiftCard->setGcLastTransactionDate($actualDate);
  3987.                                     if (isset($data['transaction_id'])) {
  3989.                                         $this->createFileJson($path, 'GiftCard if Refund!' . "\r");
  3991.                                         $theGiftCard->setGcLastTransactionDate($actualDate);
  3992.                                         $theRealTransactionAmount = $theGiftCard->getGcAmount() + (double) $data['amount'];
  3993.                                         $giftCardTransaction->setGtTransactionAmount($data['amount']);
  3994.                                         $theGiftCard->setGcAmount($theRealTransactionAmount);
  3996.                                     } else {
  3998.                                         $this->createFileJson($path, 'GiftCard else Refund!' . "\r");
  3999.                                         $theGiftCard->setGcAmount($theGiftCard->getGcAmount() + (double) $data['amount']);
  4000.                                     }
  4002.                                     $responseArr['msg'] = 'Refund successfully!';
  4003.                                     $responseArr['status'] = WebService::GIFTCARD_WS_STATUS_REFUND_SUCCESS;
  4005.                                     break;
  4006.                                 case GiftCardTransaction::TRANSACTION_TYPE_ADJUST_TRANSACTION:
  4008.                                     $this->createFileJson($path, 'Try adjust order!' . "\r");
  4009.                                     $theGiftCard->setGcLastTransactionDate($actualDate);
  4011.                                     if (isset($data['transaction_id'])) {
  4013.                                         $oldGiftCardTransaction = $em->getRepository('App\Entity\GiftCardTransaction')->find($data['transaction_id']);
  4015.                                         $theRealTransactionAmount = $theGiftCard->getGcAmount() + $oldGiftCardTransaction->getGtTransactionAmount() - (double) $data['amount'];
  4016.                                         $giftCardTransaction->setGtTransactionAmount($data['amount']);
  4017.                                         $theGiftCard->setGcAmount($theRealTransactionAmount);
  4019.                                         $responseArr['msg'] = 'Adjust successfully!';
  4020.                                         $responseArr['status'] = WebService::GIFTCARD_WS_STATUS_ADJUST_SUCCESS;
  4021.                                     }
  4023.                                     break;
  4024.                                 case GiftCardTransaction::TRANSACTION_TYPE_BUY_DEVOLUTION_GIFTCARD:
  4026.                                     $this->createFileJson($path, 'Devolution successfully!' . "\r");
  4028.                                     $theGiftCard->setGcLastTransactionDate($actualDate);
  4029.                                     $theGiftCard->setGcAmount($theGiftCard->getGcAmount() + (double) $data['amount']);
  4031.                                     $responseArr['msg'] = 'Devolution successfully!';
  4032.                                     $responseArr['status'] = WebService::GIFTCARD_WS_STATUS_DEVOLUTION_SUCCESS;
  4034.                                     break;
  4035.                                 case GiftCardTransaction::TRANSACTION_TYPE_BUY_CANCELED_GIFTCARD:
  4037.                                     $this->createFileJson($path, 'Cancelation successfully!' . "\r");
  4039.                                     $theGiftCard->setGcLastTransactionDate($actualDate);
  4040.                                     $theGiftCard->setGcAmount($theGiftCard->getGcAmount() + (double) $data['amount']);
  4042.                                     $responseArr['msg'] = 'Cancelation successfully!';
  4043.                                     $responseArr['status'] = WebService::GIFTCARD_WS_STATUS_CANCELATION_SUCCESS;
  4045.                                     break;
  4046.                                 case GiftCardTransaction::TRANSACTION_TYPE_INFORMATION_GIFTCARD:
  4048.                                     $this->createFileJson($path, 'Information request!' . "\r");
  4050.                                     $responseArr['msg'] = 'Information request!';
  4051.                                     $responseArr['status'] = WebService::GIFTCARD_WS_STATUS_INFORMATION_SUCCESS;
  4053.                                     break;
  4054.                                 case GiftCardTransaction::TRANSACTION_TYPE_DISABLE_GIFTCARD: 
  4056.                                     $this->createFileJson($path, 'GiftCard Disabled...' . "\r");
  4058.                                     $theGiftCard->setGcDeactivateDate($actualDate);
  4059.                                     $theGiftCard->setIsDeactivationNotified(true);
  4060.                                     $theGiftCard->setGcStatus(GiftCard::STATUS_DEACTIVATE);
  4062.                                     $responseArr['msg'] = 'GiftCard Disabled!';
  4063.                                     $responseArr['status'] = WebService::GIFTCARD_WS_STATUS_DISABLED_SUCCESS;
  4065.                                     break;
  4066.                                 default:
  4068.                                     $data['type'] = GiftCardTransaction::TRANSACTION_TYPE_UNKNOWN_TRANSACTION;
  4070.                                     $theTransactionType = $data['type'];
  4071.                                     $this->createFileJson($path, 'Unknown Transaction...' . "\r");
  4073.                                     $theGiftCard->setGcDeactivateDate($actualDate);
  4074.                                     $theGiftCard->setIsDeactivationNotified(true);
  4075.                                     $theGiftCard->setGcStatus(GiftCard::STATUS_DEACTIVATE);
  4077.                                     $responseArr['msg'] = 'Unknown Transaction!';
  4078.                                     $responseArr['status'] = WebService::GIFTCARD_WS_STATUS_UNKNOWN_TRANSACTION;
  4080.                                     break;
  4081.                             }
  4082.                             
  4083.                         } else {
  4085.                             $this->createFileJson($path, 'Error: Licensor Giftcard not found!' . "\r");
  4087.                             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  4088.                             ->respondWithError('Giftcard not found!', WebService::GIFTCARD_WS_STATUS_GIFTCARDNOTFOUND_ERROR);
  4089.                         }
  4091.                         $auxSearchingCode = $data['nickname'] . '-' . $data['gift_code'];
  4093.                         $this->createFileJson($path, 'Searching level GiftCard with code -> ' . $auxSearchingCode . "\r");
  4094.                         $levelGiftCard = $levelWebGiftCardCreatorRepo->findBy(['gcVerificationCode' => $auxSearchingCode]);
  4096.                         if (empty($levelGiftCard)) {
  4098.                             $this->createFileJson($path, 'Searching old level GiftCard with code -> ' . $data['gift_code'] . "\r");
  4099.                             $levelGiftCard = $levelWebGiftCardCreatorRepo->findBy(['gcVerificationCode' => $data['gift_code']]);
  4100.                         }
  4102.                         if (isset($data['debug'])) {
  4104.                             dump($theGiftCard);
  4105.                             dump($levelGiftCard);
  4107.                         }
  4109.                         if (empty($levelGiftCard)) {
  4111.                             $this->createFileJson($path, 'Level GiftCard not found, geting GiftCard from Licensor!' . "\r");
  4112.                             
  4113.                             $giftCardWebData = Util::getStdClassForGiftCard($theGiftCard, true);
  4114.                             $giftCardWebData->id = UUIDGeneratorUtil::getUUIDv4();
  4115.                             $queryResponse = $levelWebGiftCardCreatorRepo->setDataUploadOne($this->realContainer, $giftCardWebData, $path);
  4117.                         } else {
  4119.                             $this->createFileJson($path, 'Level web GiftCard found!' . "\r");
  4120.                             
  4121.                             $giftCardWebData = Util::getStdClassForGiftCard($theGiftCard, true);
  4122.                             $giftCardWebData->id = $levelGiftCard[0]->getId();
  4123.                             
  4124.                             $this->createFileJson($path, 'Level web GiftCard id found -> ' . $levelGiftCard[0]->getId() . "\r");
  4125.                             $queryResponse = $levelWebGiftCardCreatorRepo->setDataUpdateUploadOne($this->realContainer, $levelGiftCard[0], $giftCardWebData, $path);
  4126.                         }
  4128.                         if (isset($data['debug'])) {
  4129.                             dump($queryResponse);
  4130.                             die;
  4131.                         }
  4133.                         if (!is_array($queryResponse) && GiftCardTransaction::TRANSACTION_TYPE_REFUND_RECHARGE_GIFTCARD != (int) $data['type']) {
  4134.                             
  4135.                             // dump(strpos($queryResponse, '1062 Duplicate entry'));
  4136.                             // dump(strpos($queryResponse, $data['nickname'] .'-'. $data['gift_code']));
  4137.                             // die;
  4139.                             if (strpos($queryResponse, '1062 Duplicate entry') && strpos($queryResponse, $data['nickname'] .'-'. $data['gift_code'])) {
  4140.                                 
  4141.                                 $responseArr['msg'] = "GiftCard with '" . $data['gift_code'] . "' code already registed in " . $accountLicenseData[0] . " restaurant" ;
  4142.                                 $responseArr['status'] = WebService::GIFTCARD_WS_STATUS_GIFTCARD_ALREADY_REGISTED_ERROR;
  4143.                                 
  4144.                                 $this->createFileJson($path, "GiftCard with '" . $data['gift_code'] . "' code already registed in " . $accountLicenseData[0] . " restaurant" . "\r");
  4145.                             
  4146.                             } else {
  4148.                                 $this->createFileJson($path, 'Error in licensor Giftcard transaction! -> ' . $queryResponse . "\r");
  4149.                                 
  4150.                                 return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)
  4151.                                 ->respondWithError('Error in transaction!', WebService::GIFTCARD_WS_STATUS_TRANSACTION_ERROR);
  4152.                             
  4153.                             }
  4155.                         } elseif (!is_array($queryResponse)) {
  4157.                             $this->createFileJson($path, 'Error in licensor Giftcard recharge cancelation! -> ' . $queryResponse . "\r");
  4158.                             return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)
  4159.                                             ->respondWithError('Error in recharge cancelation!', WebService::GIFTCARD_WS_STATUS_GIFTCARD_RECHARGE_CANCELATION_ERROR);
  4160.                         }
  4162.                     } elseif (!empty($giftCardRecord) && $giftCardRecord[0]->getGcStatus() == GiftCard::STATUS_DEACTIVATE) {
  4163.                         
  4164.                         $doGiftCardLogRecord = false;
  4165.                         $theGiftCard = $giftCardRecord[0];
  4167.                         $responseArr['msg'] = 'GiftCard Disabled!';
  4168.                         $responseArr['status'] = WebService::GIFTCARD_WS_STATUS_DISABLED_SUCCESS;
  4169.                         
  4170.                         $this->createFileJson($path, 'Deactivated GiftCard request found!' . "\r");
  4172.                     } elseif (empty($giftCardRecord) && GiftCardTransaction::TRANSACTION_TYPE_DISABLE_GIFTCARD == (int) $data['type']) {
  4173.                         
  4174.                         $this->createFileJson($path, 'Error trying to disabled an unknown giftcard -> ' . "\r");
  4175.                         
  4176.                         return $this->setStatusCode(WebService::CODE_ERR_CONFLICT)
  4177.                         ->respondWithError('Error trying to disabled an unknown giftcard!', WebService::GIFTCARD_WS_STATUS_TRANSACTION_ERROR);
  4178.                     }
  4180.                     // else {
  4181.                     //     $this->createFileJson($path, 'Error in licensor Giftcard recharge cancelation! -> ' . $queryResponse . "\r");
  4182.                     //     return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)
  4183.                     //                     ->respondWithError('Error in recharge cancelation!', WebService::GIFTCARD_WS_STATUS_GIFTCARD_RECHARGE_CANCELATION_ERROR);
  4184.                     // }
  4186.                     if (isset($data['debug'])) {
  4187.                         die;
  4188.                     }
  4190.                     if (GiftCardTransaction::TRANSACTION_TYPE_NEW_GIFTCARD != (int) $data['type']) {
  4192.                         $em->persist($theGiftCard);
  4193.                         $this->createFileJson($path, 'Licensor Giftcard updated!' . "\r");
  4195.                         if ($worksWithArmor) {
  4197.                             $log->createChannel('gift_card');
  4199.                             $urlData = [
  4200.                                 'gift_card_id' => $theGiftCard->getGcVerificationCode(),
  4201.                                 'identifier' => $theGiftCard->getId()
  4202.                             ];
  4204.                             $paramToken = $armor->token($urlData);
  4206.                             $decodeJWT['gift_card_id'] = $theGiftCard->getId();
  4207.                             $decodeJWT['identifier'] = $theGiftCard->getId();
  4208.                             $decodeJWT['balance'] = Encryptor::encodeInfo($theGiftCard->getGcAmount(), 5);
  4209.                             $decodeJWT['status'] = $theGiftCard->getGcStatus();
  4210.                             $token = Encryptor::encodeInfo(json_encode($decodeJWT));
  4212.                             $request = $armor->duplicateRequestWithOverwritedContentForArmorServer($request, ['token' => $token]);
  4214.                             $url = $this->getParameter('armor_host') . 'gift/gift-cards/' . $paramToken . '/update';
  4216.                             $dataResponse = $armor->armorPut($request, $url, $log);
  4218.                             if ($dataResponse instanceof Response && $dataResponse->getStatusCode() != WebService::HTTP_CODE_SUCCESS) {
  4219.                                 $jsonResponse = $dataResponse->getContent();
  4221.                                 $decodedResponse = json_decode($jsonResponse, true);
  4223.                                 $this->createFileJson($path, 'Unknown Armor error!!!! -> ' . $decodedResponse['data'] . "\r");
  4224.                             }
  4225.                         }
  4226.                     }
  4228.                     if ($doGiftCardLogRecord) {
  4230.                         $giftCardTransaction->setGtType($data['type']);
  4232.                         if (isset($data['order_id']) && $data['order_id'] != '') {
  4233.                             $giftCardTransaction->setGtOrder($data['order_id']);
  4234.                         }
  4236.                         if (isset($data['inv_id']) && $data['inv_id'] != '') {
  4237.                             $giftCardTransaction->setGtInvoice($data['inv_id']);
  4238.                         }
  4240.                         $giftCardTransaction->setGtTransactionAmount($data['amount']);
  4242.                         $giftCardTransaction->setGtGiftCard($theGiftCard);
  4243.                         $giftCardTransaction->setGtTransactionDate($actualDate);
  4244.                         $giftCardTransaction->setGtCreatorLicense($licenseToValidate);
  4245.                         $giftCardTransaction->setGtTotalAmount($theGiftCard->getGcAmount());
  4247.                         $em->persist($giftCardTransaction);
  4248.                         $this->createFileJson($path, 'Licensor GiftCardTransaction registed!' . "\r");
  4249.                     }
  4251.                     $em->flush();
  4253.                     if ($doGiftCardLogRecord && is_array($queryResponse)) {
  4255.                         $this->createFileJson($path, 'Preparing new GiftCardLog to level!' . "\r");
  4257.                         $levelGiftCardLogData = new stdClass();
  4259.                         $levelGiftCardLogData->gift_id = array_keys($queryResponse)[0];
  4260.                         $levelGiftCardLogData->licId = $giftCardTransaction->getId();
  4261.                         $levelGiftCardLogData->gifl_total = $theGiftCard->getGcAmount();
  4262.                         $levelGiftCardLogData->gifl_type = $theTransactionType;
  4263.                         $levelGiftCardLogData->gifl_price = $data['amount'];
  4265.                         if (isset($data['order_id']) && $data['order_id'] != '' ) {
  4266.                             $levelGiftCardLogData->ord_id = $data['order_id'];
  4267.                         }
  4269.                         if (isset($data['inv_id']) && $data['inv_id'] != '') {
  4270.                             $levelGiftCardLogData->inv_id = $data['inv_id'];
  4271.                         }
  4273.                         $levelGiftCardLogData->gift_code = $data['gift_code'];
  4274.                         $levelGiftCardLogData->gifl_date = $actualDate->format('Y-m-d H:i:s');
  4276.                         if (isset($data['transaction_id']) && (GiftCardTransaction::TRANSACTION_TYPE_BUY_WITH_GIFTCARD == (int) $data['type'] || GiftCardTransaction::TRANSACTION_TYPE_REFUND_GIFTCARD == (int) $data['type'])) {
  4277.                             
  4278.                             $licesneGiftCardLogRecordToUpdate = $emLevCreatorGiftCard->getRepository('App\Structure\GiftCardLog')->findBy(['gclLicFk' => $giftCardTransaction->getId()]);
  4280.                             if (empty($licesneGiftCardLogRecordToUpdate)) {
  4281.                                 
  4282.                                 $this->createFileJson($path, 'GiftCard log not found in license!' . "\r");
  4283.                                 
  4284.                                 return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)
  4285.                                 ->respondWithError('GiftCard log not found!', WebService::GIFTCARD_WS_STATUS_GIFTCARD_LOG_NOT_FOUND_ERROR);
  4286.                             
  4287.                             } else {
  4289.                                 $licenseGiftCardLogOldRecord = $licesneGiftCardLogRecordToUpdate[0];
  4290.                                 $queryResponse = $emLevCreatorGiftCard->getRepository('App\Structure\GiftCardLog')->setDataUpdateUploadOne($this->realContainer, $licenseGiftCardLogOldRecord, $levelGiftCardLogData, $path);
  4291.                             
  4292.                             }
  4294.                         } else {
  4295.                             $levelGiftCardLogData->id = UUIDGeneratorUtil::getUUIDv4();
  4296.                             $queryResponse = $emLevCreatorGiftCard->getRepository('App\Structure\GiftCardLog')->setDataUploadOne($this->realContainer, $levelGiftCardLogData, $path);
  4297.                         }
  4299.                         $responseArr['gift_id'] = '';
  4301.                         if (!is_array($queryResponse)) {
  4303.                             $this->createFileJson($path, 'Error in level GiftCardLog transaction! -> ' . $queryResponse . "\r");
  4304.                             
  4305.                             return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)
  4306.                             ->respondWithError('Error registering GiftCardLog!', WebService::GIFTCARD_WS_STATUS_GIFTCARDLOG_ERROR);
  4307.                         
  4308.                         } else {
  4310.                             $this->createFileJson($path, 'The actual $queryResponse  -> ' . json_encode($queryResponse) . "\r");
  4311.                             
  4312.                             $responseArr['gift_id'] = array_keys($queryResponse)[0];
  4313.                             $this->createFileJson($path, 'GiftCardLog id to android -> ' . $responseArr['gift_id'] . "\r");
  4314.                         }
  4315.                     }
  4317.                     $responseArr['amount'] = $theGiftCard->getGcAmount();
  4318.                     $responseArr['transaction_id'] = $giftCardTransaction->getId();
  4319.                     $responseArr['isActive'] = (int) ((boolean) ($theGiftCard->getGcStatus() % GiftCard::STATUS_DEACTIVATE));
  4320.                     
  4321.                     $responseArr['activationDate'] = "";
  4322.                     if ($theGiftCard->getGcActivateDate()) {
  4323.                         $responseArr['activationDate'] = $theGiftCard->getGcActivateDate()->format('Y-m-dTH:i:s');
  4324.                     }
  4326.                     $responseArr['lastTransactionDate'] = "";
  4328.                     if ($theGiftCard->getGcLastTransactionDate()) {
  4329.                         $responseArr['lastTransactionDate'] = $theGiftCard->getGcLastTransactionDate()->format('Y-m-dTH:i:s');
  4330.                     }
  4332.                     $responseArr['deactivationDate'] = "";
  4334.                     if ($theGiftCard->getGcDeactivateDate()) {
  4335.                         $responseArr['deactivationDate'] = $theGiftCard->getGcDeactivateDate()->format('Y-m-dTH:i:s');
  4336.                     }
  4338.                     $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  4339.                     $xxArray = $theUrlTrSt->transform();
  4341.                     $jsonContent = json_encode($xxArray);
  4343.                     $this->createFileJson($path, 'The WS Response -> ' . $jsonContent . "\r");
  4345.                     return $this->respondWithItem($jsonContent, $theUrlTrSt);
  4346.                 }
  4348.             } else {
  4350.                 $this->createFileJson($path, 'Error: Wrong Content' . "\r");
  4352.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  4353.                 ->respondWithError('Wrong Content.', WebService::CODE_WRONG_ARGUMENTS);
  4354.             }
  4356.         } else {
  4358.             $this->createFileJson($path, 'Error: Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . "\r");
  4359.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  4361.         }
  4362.     }
  4364.     /**
  4365.      * WS para notificar por correo electronico a los encargados de administrar el
  4366.      * sistema y dar soporte con el fin de identificar si dicho dispositivo tiene
  4367.      * algun inconveniente en el logueo ya sea licencia o sublicencia
  4368.      * @author Aealan Z <lrobledo@kijho.com> 21/12/15
  4369.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  4370.      * @return Response Json con la informacion de respuesta
  4371.      */
  4372.     public function notifyDeviceInfo(Request $request) {
  4374.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  4376.             if (0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE) || 0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT)) {
  4378.                 $path = Util::getValidActiveLogByBaseName($this->realContainer, 'notifyDeviceInfo', 'notifyDeviceInfo0.txt');
  4379.                 $this->createFileJson($path, 'Notify Device Info: ' . $request->getContent() . "\r");
  4381.                 $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  4382.                 $data = json_decode($arrayEncryptResult['data'], true);
  4384.                 if (!isset($data['version']) || !isset($data['uid'])) {
  4385.                     return $this->errorWrongArgs('Wrong Arguments!', WebService::CODE_WRONG_ARGUMENTS);
  4386.                 }
  4388.                 $dataToSearch = ['deviceUid' => $data['uid']];
  4390.                 $em = $this->getDoctrine()->getManager();
  4391.                 $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findBy($dataToSearch);
  4393.                 $generalInfo = "<label>General Info: </label><br><br>";
  4394.                 $generalInfo .= "<label>Server: <strong>http://" . $this->realContainer->getParameter("licensor_base_url") . "/licensor/login</strong></label><br>";
  4395.                 $generalInfo .= "<label>Device UID: <strong>" . $data['uid'] . "</strong></label><br>";
  4397.                 if (!empty($accountLicenseData)) {
  4398.                     $generalInfo .= "<label>Last time used in: <strong>" . $accountLicenseData[0]->getAlLicenseUsername() . "</strong> license</label><br>";
  4400.                     if ($accountLicenseData[0]->getAlAccountLicense()->getDeleted()) {
  4401.                         $generalInfo .= "<label>Account <strong>" . $accountLicenseData[0]->getAlAccountLicense()->getAcName() . " </strong>incative</label><br>";
  4402.                     } else {
  4403.                         $generalInfo .= "<label>Account <strong>" . $accountLicenseData[0]->getAlAccountLicense()->getAcName() . " </strong>active</label><br>";
  4404.                     }
  4406.                     if ($accountLicenseData[0]->getAlLicenseStatus() == AccountLicense::LICENSE_STATUS_ACTIVE) {
  4407.                         $generalInfo .= "<label>License <strong>active</strong><br></label>";
  4408.                     } else {
  4409.                         $generalInfo .= "<label>License <strong>incative</strong><br></label>";
  4410.                     }
  4411.                 } else {
  4412.                     $dataToSearch = ['deviceUid' => $data['uid']];
  4413.                     $subLicenseData = $em->getRepository('App\Entity\SubLicense')->findBy($dataToSearch);
  4415.                     if (!empty($subLicenseData)) {
  4416.                         $generalInfo .= "<label>Last time used in: <strong>" . $subLicenseData[0]->getChannelName() . "</strong> sublicense</label><br>";
  4418.                         if ($subLicenseData[0]->getLicense()->getAlAccountLicense()->getDeleted()) {
  4419.                             $generalInfo .= "<label>Account <strong>" . $subLicenseData[0]->getLicense()->getAlAccountLicense()->getAcName() . " </strong>incative</label><br>";
  4420.                         } else {
  4421.                             $generalInfo .= "<label>Account <strong>" . $subLicenseData[0]->getLicense()->getAlAccountLicense()->getAcName() . " </strong>active</label><br>";
  4422.                         }
  4424.                         if ($subLicenseData[0]->getLicense()->getAlLicenseStatus() == AccountLicense::LICENSE_STATUS_ACTIVE) {
  4425.                             $generalInfo .= "<label>License <strong>" . $subLicenseData[0]->getLicense()->getAlLicenseUsername() . " </strong>active</label><br>";
  4426.                         } else {
  4427.                             $generalInfo .= "<label>License <strong>" . $subLicenseData[0]->getLicense()->getAlLicenseUsername() . " </strong>incative</label><br>";
  4428.                         }
  4429.                     }
  4430.                 }
  4432.                 try {
  4433.                     $theRespArray = Util::getLastVersionByJsonVersionFile($this->realContainer, $data['version'], true, $path);
  4434.                 } catch (\Exception $ex) {
  4435.                     $theRespArray['updateAppError'] = true;
  4436.                 }
  4438.                 try {
  4439.                     $theRespArrayTwo = Util::getLastVersionByDirAvailableVersions($this->realContainer, $data['version'], true, $path);
  4440.                 } catch (\Exception $ex) {
  4441.                     $theRespArrayTwo['updateAppError'] = true;
  4442.                 }
  4444.                 if (isset($theRespArray['updateAppError']) && $theRespArray['updateAppError'] && isset($theRespArrayTwo['updateAppError']) && $theRespArrayTwo['updateAppError']) {
  4445.                     return $this->setStatusCode(WebService::HTTP_CODE_SERVICE_UNAVAILABLE)
  4446.                                     ->respondWithError('Error finding last version', WebService::CODE_OBJECT_NOT_FOUND);
  4447.                 }
  4449.                 if (isset($theRespArray["newVersion"]) && isset($theRespArrayTwo["newVersion"])) {
  4450.                     if ($theRespArray["newVersion"] < $theRespArrayTwo["newVersion"]) {
  4451.                         $theRespArray = $theRespArrayTwo;
  4452.                     }
  4453.                 } elseif (!isset($theRespArray["newVersion"]) && isset($theRespArrayTwo["newVersion"])) {
  4454.                     $theRespArray = $theRespArrayTwo;
  4455.                 }
  4457.                 $generalInfo .= "<label>APK version: <strong>" . $data['version'] . "</strong></label><br>";
  4459.                 if (isset($theRespArray['newVersion'])) {
  4460.                     $generalInfo .= "<label>New version available: <strong>" . $theRespArray['newVersion'] . "</strong></label><br>";
  4461.                 }
  4463.                 $emailsToNotify = $this->realContainer->getParameter('level_emails_syncs_errors');
  4465.                 $respArray['subject'] = "Device info request " . $data['uid'];
  4466.                 $respArray['message'] = "";
  4468.                 foreach ($emailsToNotify as $mailTo) {
  4469.                     $this->createFileJson($path, "Mail to -> " . $mailTo . "\r");
  4471.                     $respArray['to'] = $mailTo;
  4473.                     $emailSuccess = Utilx::sendMailInfo($this->realContainer, $respArray, $path, $generalInfo);
  4474.                 }
  4476.                 if (isset($emailSuccess['success']) && $emailSuccess['success']) {
  4477.                     $responseArr['status'] = WebService::CODE_SUCCESS;
  4478.                     $responseArr['msg'] = 'Info device data send!';
  4479.                     $responseArr['bigbag'] = true;
  4480.                     $responseArr['url'] = '';
  4482.                     $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  4483.                     $xxArray = $theUrlTrSt->transform();
  4485.                     $jsonContent = json_encode($xxArray);
  4487.                     return $this->respondWithItem($jsonContent, $theUrlTrSt);
  4488.                 } else {
  4489.                     return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)
  4490.                                     ->respondWithError('Erro notifiying device info by email!', WebService::CODE_INTERNAL_ERROR);
  4491.                 }
  4492.             } else {
  4493.                 return $this->errorWrongArgs('Wrong Content.', WebService::CODE_WRONG_ARGUMENTS);
  4494.             }
  4495.         } else {
  4496.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  4497.         }
  4498.     }
  4500.     /**
  4501.      * WS para el boton de sincronizacion de arriba a abajo desde android
  4502.      * @author Aealan Z <lrobledo@kijho.com> 30/10/15
  4503.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  4504.      * @return Response Json con la informacion de respuestaa
  4505.      */
  4506.     public function syncUpDownFromAndroid(Request $request) {
  4508.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  4510.             if (0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE) || 0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT)) {
  4512.                 $path = Util::getValidActiveLogByBaseName($this->realContainer, 'syncUpDownFromAndroid', 'syncUpDownFromAndroid0.txt');
  4513.                 $this->createFileJson($path, 'Request content: ' . $request->getContent() . "\r");
  4515.                 $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  4517.                 $data = json_decode($arrayEncryptResult['data'], true);
  4519.                 if (!isset($data['nickname']) || !isset($data['uid'])) {
  4520.                     return $this->errorWrongArgs('Wrong arguments', WebService::CODE_COULD_NOT_AUTHENTICATE);
  4521.                 }
  4523.                 $licenseUserName = ['alLicenseUsername' => $data['nickname']];
  4525.                 $em = $this->getDoctrine()->getManager();
  4526.                 $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findBy($licenseUserName);
  4528.                 $countResult = count($accountLicenseData);
  4530.                 $this->createFileJson($path, 'Request content: license count ' . $countResult . "\r");
  4532.                 if ($countResult > 0) {
  4534.                     $this->createFileJson($path, 'Request content: entro el chingo! ' . "\r");
  4536.                     if ($accountLicenseData[0]->getAlAccountLicense()->getDeleted()) {
  4537.                         return $this->errorWrongArgs('Account inactive, please contact your system manager', WebService::CODE_UNAUTHORIZED);
  4538.                     }
  4540.                     if (!$accountLicenseData[0]->getAlLicenseStatus()) {
  4541.                         return $this->errorWrongArgs('License inactive, please contact your system manager', WebService::CODE_UNAUTHORIZED);
  4542.                     }
  4544.                     if ($accountLicenseData[0]->getDeviceUid() != $data['uid']) {
  4545.                         return $this->errorWrongArgs('Unauthorized device', WebService::CODE_UNAUTHORIZED);
  4546.                     }
  4548.                     $arrHead = ['Content-Type: application/json'];
  4549.                     $dataToRequest = ["nickname" => Util::encodeInfo($data['nickname']), 'waitTime' => 0];
  4551.                     $dataPost = json_encode($dataToRequest);
  4553.                     $this->createFileJson($path, 'Request content: request to -> ' . $dataPost . "\r");
  4555.                     $url = $this->realContainer->getParameter('level_scheme') . '://' . $this->realContainer->getParameter('level_host') . $this->generateUrl('level_web_service_sync_data_web');
  4557.                     $this->createFileJson($path, 'Request content: request url -> ' . $url . "\r");
  4559.                     $ch = curl_init($url);
  4560.                     curl_setopt($ch, CURLOPT_POST, true);
  4561.                     curl_setopt($ch, CURLOPT_HTTPHEADER, $arrHead);
  4562.                     curl_setopt($ch, CURLOPT_POSTFIELDS, $dataPost);
  4563.                     curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  4564.                     $response = curl_exec($ch);
  4565.                     curl_close($ch);
  4567.                     $this->createFileJson($path, 'Request Response: ' . $response . "\r");
  4569.                     $responseData = Util::decryptDataForAndroid($this->realContainer, $response);
  4571.                     $responseDecData = json_decode($responseData['data']);
  4573.                     $responseArr['status'] = WebService::CODE_SUCCESS;
  4575.                     if (!empty($responseDecData->result) && $responseDecData->result == '__OK__') {
  4576.                         if (empty($responseDecData->msg)) {
  4577.                             $responseArr['status'] = 70;
  4578.                             $responseArr['msg'] = 'Synchronization triggered..';
  4579.                         } else {
  4580.                             $responseArr['status'] = 60;
  4581.                             $responseArr['msg'] = $responseDecData->msg;
  4582.                         }
  4584.                         $this->createFileJson($path, 'Request answered msg: ' . $responseArr['msg'] . "\r");
  4586.                         $idToWebSyncConsumer = $responseDecData->syncid;
  4588.                         $this->createFileJson($path, 'Searching sync with id: ' . $idToWebSyncConsumer . "\r");
  4590.                         $syncWebRecord = $em->getRepository('App\Entity\ReadFilesDataWeb')->find($idToWebSyncConsumer);
  4592.                         if ($syncWebRecord) {
  4593.                             sleep(4);
  4595.                             $this->createFileJson($path, 'Instant Request pre if -> ' . $syncWebRecord->getIsReadedByServer() . ' | ' . $syncWebRecord->getRfwStatus() . "\r");
  4597.                             if ($syncWebRecord->getIsReadedByServer() && ReadFilesDataWeb::STATUS_NOTIFIED == $syncWebRecord->getRfwStatus()) {
  4598.                                 $em->clear();
  4600.                                 $data['rwid'] = $syncWebRecord->getId();
  4601.                                 ForcedAsynchronousCommandsUtil::consumeUpDownSyncCommand($this->realContainer, $data, true);
  4603.                                 $this->createFileJson($path, 'Instant Request Proccessed!' . "\r");
  4604.                                 $responseArr['status'] = WebService::CODE_SUCCESS;
  4605.                                 $responseArr['msg'] = 'Server processing new data, please check for the new data in a few seconds!';
  4606.                             } else {
  4607.                                 $responseArr['status'] = 80;
  4608.                                 $responseArr['msg'] = 'Server is working... Please try 20 seconds latter!';
  4609.                             }
  4610.                         } else {
  4611.                             if ($idToWebSyncConsumer == 0) {
  4612.                                 $this->createFileJson($path, 'Instant Request Push Resend.....' . "\r");
  4614.                                 $responseArr['status'] = 90;
  4615.                                 $responseArr['msg'] = 'Unanswered push by android server....';
  4616.                             } else {
  4617.                                 $this->createFileJson($path, 'Instant Request Auch -> License sync web record not found!' . "\r");
  4619.                                 return $this->setStatusCode(WebService::CODE_OBJECT_NOT_FOUND)
  4620.                                                 ->respondWithError('License sync web record not found!', WebService::CODE_OBJECT_NOT_FOUND);
  4621.                             }
  4622.                         }
  4623.                     } else {
  4624.                         if (isset($response->error->message)) {
  4625.                             $responseArr['msg'] = $response->error->message;
  4626.                         } else {
  4627.                             $responseArr['status'] = 100;
  4628.                             $responseArr['msg'] = 'Nothing to synchronize';
  4629.                         }
  4630.                     }
  4632.                     $theUrlTrSt = new RespondedNotificationPushTransformer($responseArr);
  4633.                     $xxArray = $theUrlTrSt->transform();
  4635.                     $jsonContent = json_encode($xxArray);
  4637.                     return $this->respondWithItem($jsonContent, $theUrlTrSt);
  4638.                 } else {
  4639.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  4640.                                     ->respondWithError('Invalid nickname', WebService::CODE_UNAUTHORIZED);
  4641.                 }
  4642.             } else {
  4643.                 return $this->errorWrongArgs('Bad request', WebService::CODE_UNAUTHORIZED);
  4644.             }
  4645.         } else {
  4646.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  4647.         }
  4648.     }
  4650.     /**
  4651.      * WS que permite verificar el login de level lite
  4652.      * @author Felipe Bautista <aarango@uva3.com> 10/04/2019
  4653.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  4654.      * @return Response Json con la informacion de respuesta
  4655.      */
  4656.     public function checkLoginLevel(Request $request) {
  4658.         $em = $this->getDoctrine()->getManager();
  4660.         $path = Util::getValidActiveLogByBaseName($this->realContainer, 'checkLoginLevel', 'requestFromWebYYY0.txt');
  4662.         $paramsIdLicense = $request->request->get('id_license');
  4663.         if ($paramsIdLicense == null) {
  4664.             $paramsIdLicense = $request->query->get('id_license');
  4665.         }
  4667.         $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->find($paramsIdLicense);
  4669.         if (isset($accountLicenseData)) {
  4670.             if ($accountLicenseData->getLevelLightUser() !== "" && $accountLicenseData->getLevelLightUser() !== []) {
  4671.                 $userData = $accountLicenseData->getLevelLightUser();
  4673.                 $apikey = Util::doOMTDashboardLoginToGetToken($this->realContainer, $userData, $path, $accountLicenseData->getLoginType());
  4675.                 if (!empty($apikey)) {
  4676.                     $userData['apikey'] = $apikey;
  4677.                     $responseArr['apikey'] = $apikey;
  4678.                 } else {
  4679.                     $responseArr['apikey'] = '';
  4680.                 }
  4682.                 if (isset($responseArr['apikey']) || $accountLicenseData->getHasLogedOMT() == false) {
  4684.                     // $createDefaultUserOmt = Util::makeOMTDefaultDashboardsUserInsertRequest($this->realContainer, $userData, $path);
  4686.                     /**
  4687.                      * Allows to add the apikey to the user of lite level this exported in OMT
  4688.                      */
  4689.                     if ($accountLicenseData->getHasLogedOMT() == true || $accountLicenseData->getIsLevelLight() == true) {
  4690.                         $accountLicenseData->setLevelLightUser($userData);
  4691.                         $em->persist($accountLicenseData);
  4692.                         $em->flush();
  4693.                         $responseToAjax['msg'] = 'Login successfull';
  4694.                         $responseToAjax['result'] = '__OK__';
  4695.                     }
  4697.                     $auxRepository = $em->getRepository('App\Entity\AccountLicense');
  4698.                     $connectionRecord = $auxRepository->find($paramsIdLicense);
  4700.                     $emLev = Util::emLicenseConnection($this->realContainer, $em, $connectionRecord);
  4701.                     $userLevelLite = $emLev->getRepository('App\Structure\Usuario')->findBy(['usuLogin' => $userData['username']]);
  4702.                     if (!isset($userLevelLite[0])) {
  4703.                         $responseToAjax['msg'] = (isset($responseToAjax['msg'])) ? $responseToAjax['msg'] . " and user level lite create" : "User level lite created";
  4704.                         $responseToAjax['result'] = '__OK__';
  4706.                         $levelUser = new Usuario();
  4708.                         $levelUser->setUsuNombre($userData['username']);
  4709.                         $levelUser->setUsuApellido($userData['username']);
  4710.                         $levelUser->setUsuTelefono($accountLicenseData->getAlPhoneNumber());
  4711.                         $levelUser->setUsuEmail($accountLicenseData->getAlLicenseEmail());
  4712.                         $levelUser->setUsuTipo(Usuario::USU_TYPE_MANAGER);
  4713.                         $levelUser->setUsuEstado(Usuario::STATUS_IS_ACTIVE);
  4714.                         $levelUser->setUsuLogin($userData['username']);
  4715.                         $levelUser->setUsuSalary(0.000000);
  4717.                         $actualDate = Util::getCurrentDate();
  4718.                         $levelUser->setUsuCreation($actualDate);
  4719.                         $encodeLevelWebPass = Util::encryptOwnReverseMD5($userData['realPass']);
  4720.                         $levelUser->setUsuPass($encodeLevelWebPass);
  4721.                         $levelUser->setUsuAccessCode($encodeLevelWebPass);
  4722.                         $levelUser->setUsuAcccessCode2($encodeLevelWebPass);
  4723.                         $levelUser->setUsuEmployecard($encodeLevelWebPass);
  4724.                         $levelUser->setUsuFirstLogin(1);
  4726.                         $emLev->persist($levelUser);
  4727.                         $emLev->flush();
  4728.                     } else if ($accountLicenseData->getHasLogedOMT() == false) {
  4729.                         $responseToAjax['msg'] = 'The level lite user exists on levelweb!';
  4730.                         $responseToAjax['result'] = '__OK__';
  4731.                     }
  4732.                 } else {
  4733.                     $responseToAjax['msg'] = 'Error in the login level lite!';
  4734.                     $responseToAjax['result'] = '__KO__';
  4735.                 }
  4736.             } else {
  4737.                 $responseToAjax['msg'] = 'Level lite user not found!';
  4738.                 $responseToAjax['result'] = '__KO__';
  4739.             }
  4740.         } else {
  4741.             $responseToAjax['msg'] = 'License Not Found!';
  4742.             $responseToAjax['result'] = '__KO__';
  4743.         }
  4744.         return $this->respondJsonAjax($responseToAjax);
  4745.     }
  4747.     /**
  4748.      * WS para el boton de sincronizacion all in one que realiza todas las
  4749.      * en el orden correspondiente en cascada
  4750.      * @author Aealan Zulalecius <lrobledo@kijho.com> 01/06/16
  4751.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  4752.      * @return Response Json con la informacion de respuesta
  4753.      */
  4754.     public function theUltimateSyncAllOneButton(Request $request) {
  4755.         // dump($request);die;
  4757.         // $start = microtime(true);
  4758.         // while (false) {
  4760.         // }
  4761.         // $time_elapsed_secs = microtime(true) - $start;
  4763.         //////////////
  4765.         // $start = hrtime(true);
  4766.         // sleep(5); // do something, in your case a loop
  4767.         // $end = hrtime(true);
  4768.         // $eta = $end - $start;
  4769.         // // convert nanoseconds to milliseconds
  4770.         // $eta /= 1e+6;
  4772.         if ($request->getMethod() !== WebService::REQUEST_METHOD_POST) {
  4773.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  4774.         }
  4775.             
  4776.         if (0 !== strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE) && 0 !== strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT)) {
  4777.             return $this->errorWrongArgs('Bad request', WebService::CODE_UNAUTHORIZED);
  4778.         }
  4780.         $path = Util::getValidActiveLogByBaseName($this->realContainer, 'UltimateSyncAllOneButton', 'UltimateSyncAllOneButton0.txt');
  4781.         $this->createFileJson($path, "\r" . 'Sync all showtime! ' . "\r");
  4782.         $this->createFileJson($path, 'The request -> ' . $request->getContent() . "\r");
  4784.         $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  4785.         
  4786.         $data = json_decode($arrayEncryptResult['data'], true);
  4788.         if (!isset($data['nickname']) || !isset($data['uid'])) {
  4789.             return $this->errorWrongArgs('Wrong arguments', WebService::CODE_COULD_NOT_AUTHENTICATE);
  4790.         }
  4792.         $licenseUserName = ['alLicenseUsername' => $data['nickname']];
  4794.         $em = $this->getDoctrine()->getManager();
  4795.         $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findBy($licenseUserName);
  4796.         
  4797.         $countResult = count($accountLicenseData);
  4799.         $this->createFileJson($path, 'License count -> ' . $countResult . "\r");
  4801.         if ($countResult <= 0) {
  4802.             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  4803.                             ->respondWithError('Invalid nickname', WebService::CODE_UNAUTHORIZED);
  4804.         }
  4806.         $license = $accountLicenseData[0];
  4808.         if ($license->getAlAccountLicense()->getDeleted()) {
  4809.             $this->createFileJson($path, 'Deleted license! ' . "\r");
  4810.             return $this->errorWrongArgs('Account inactive, please contact your system manager', WebService::CODE_UNAUTHORIZED);
  4811.         }
  4813.         if (!$license->getAlLicenseStatus()) {
  4814.             $this->createFileJson($path, 'Incative license! ' . "\r");
  4815.             return $this->errorWrongArgs('License inactive, please contact your system manager', WebService::CODE_UNAUTHORIZED);
  4816.         }
  4818.         if ($license->getDeviceUid() != $data['uid']) {
  4819.             $this->createFileJson($path, 'Wrong UID -> espected:  ' . $license->getDeviceUid() . ' found: ' . $data['uid'] . "\r");
  4820.             return $this->errorWrongArgs('Unauthorized device', WebService::CODE_UNAUTHORIZED);
  4821.         }
  4823.         $syncAllCallStatus = $em->getRepository('App\Entity\SyncAllCallStatus')->syncCallStatusPerLicense($license);
  4825.         if(!is_null($syncAllCallStatus) && $syncAllCallStatus->getPublishMessageStatus() == SyncAllCallStatus::SYNC_MESSAGE_ERROR && is_null($syncAllCallStatus->getDateNotified())){
  4826.             $responseArr = json_decode($syncAllCallStatus->getErrorMessage(), true);
  4827.             $syncAllCallStatus->setDateNotified(Utilx::getCurrentDate());
  4829.             $em->persist($syncAllCallStatus);
  4830.             $em->flush();
  4832.             if (!isset($responseArr['status'])) {
  4833.                 $responseArr['status'] = WebService::CODE_OBJECT_NOT_FOUND;
  4834.             }
  4836.             return $this->setStatusCode($responseArr['status'])
  4837.                                     ->respondWithError($responseArr['msg'], $responseArr['status']);
  4839.         } else if(!is_null($syncAllCallStatus) && $syncAllCallStatus->getPublishMessageStatus() == SyncAllCallStatus::SYNC_MESSAGE_FINISHED && is_null($syncAllCallStatus->getDateNotified())){
  4840.             $responseArr = json_decode($syncAllCallStatus->getResponseBySync(), true);
  4841.             $syncAllCallStatus->setDateNotified(Utilx::getCurrentDate());
  4843.             $em->persist($syncAllCallStatus);
  4844.             $em->flush();
  4846.             $responseArr['msjTwo'] = $this->resultAndNewSync($path, $license, $data, $syncAllCallStatus, $em);
  4848.             if (!isset($responseArr['status'])) {
  4849.                 $responseArr['status'] = WebService::CODE_SUCCESS;
  4850.             }
  4852.         } else if (is_null($syncAllCallStatus) || (!is_null($syncAllCallStatus) && ($syncAllCallStatus->getPublishMessageStatus() == SyncAllCallStatus::SYNC_MESSAGE_ERROR || $syncAllCallStatus->getPublishMessageStatus() == SyncAllCallStatus::SYNC_MESSAGE_FINISHED))) {
  4853.             $responseArr = $this->resultAndNewSync($path, $license, $data, $syncAllCallStatus, $em); 
  4854.         } else if(!is_null($syncAllCallStatus) && ($syncAllCallStatus->getPublishMessageStatus() == SyncAllCallStatus::SYNC_MESSAGE_PROCESSING || $syncAllCallStatus->getPublishMessageStatus() == SyncAllCallStatus::SYNC_MESSAGE_PUBLISHED)){
  4855.             $responseArr = ['msg' => 'You have a synchronization process running', 'status' => WebService::CODE_SUCCESS, 'result' => '__OK__', 'response_code' => WebService::CODE_SUCCESS];
  4856.         } else {
  4857.             if (!is_null($syncAllCallStatus)) {
  4858.                 $this->createFileJson($path, "wata fack, que estado tiiene sabiendo que abarque todas las condiciones, checar datos:
  4859.                                                 id: {$syncAllCallStatus->getId()} \n
  4860.                                                 publishMessageStatus: {$syncAllCallStatus->getPublishMessageStatus()} \n
  4861.                                                 errorMessage: {$syncAllCallStatus->getErrorMessage()} \n
  4862.                                                 responseBySync: {$syncAllCallStatus->getResponseBySync()} \n
  4863.                                             \r");
  4864.             } else {
  4865.                 $this->createFileJson($path, "wata fack, que estado tiiene sabiendo que abarque todas las condiciones, sync all call status es nulo !!!! \r");
  4866.             }
  4868.             $responseArr = ['msg' => 'Please contact with support', 'status' => WebService::HTTP_CODE_NOT_FOUND, 'result' => '__KO__'];
  4869.         }
  4871.         $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  4872.         $xxArray = $theUrlTrSt->transform();
  4874.         $jsonContent = json_encode($xxArray);
  4876.         $this->createFileJson($path, 'The theUltimateSyncAllOneButton response -> ' . $jsonContent . "\r");
  4878.         return $this->respondWithItem($jsonContent, $theUrlTrSt);
  4879.     }
  4881.     function resultAndNewSync($path, $license, $data, $syncAllCallStatus, $em) {
  4882.         $dataToProducer = ['path' => $path, 'id' => $license->getId(), 'data' => $data, 'syncFullVersion' => SyncFullCallConsumer::SYNC_FULL_WEB_SERVICE_VERSION];
  4884.         $this->realContainer->get('old_sound_rabbit_mq.sync_full_call_producer')->setContentType('application/json');
  4885.         $this->realContainer->get('old_sound_rabbit_mq.sync_full_call_producer')->setDeliveryMode(2);
  4886.         $this->realContainer->get('old_sound_rabbit_mq.sync_full_call_producer')->publish(json_encode($dataToProducer));
  4888.         $counterNewPetition = 1;
  4890.         if (is_null($syncAllCallStatus)) {
  4891.             $syncAllCallStatus = new SyncAllCallStatus();
  4892.             $syncAllCallStatus->setLicense($license->getId());
  4893.         }else{
  4894.             $counterNewPetition = $syncAllCallStatus->getCounterPetitions() + $counterNewPetition;
  4895.         }
  4896.         
  4897.         $syncAllCallStatus->setCounterPetitions($counterNewPetition);
  4898.         $syncAllCallStatus->setPublishMessageStatus(SyncAllCallStatus::SYNC_MESSAGE_PUBLISHED);
  4899.         $syncAllCallStatus->setDateChangeStatus(Utilx::getCurrentDate());
  4900.         $syncAllCallStatus->setDateNotified(null); // Reiniciamos el campo desde el principio para que en realidad notifique
  4901.         
  4902.         $em->persist($syncAllCallStatus);
  4903.         $em->flush();
  4905.         $command = "php ". $this->realContainer->getParameter('kernel.project_dir') ."/bin/console sync:call:consumer";
  4906.         shell_exec("$command > /dev/null & echo!");
  4908.         return ['msg' => 'You have a synchronization process running', 'status' => WebService::CODE_SUCCESS, 'result' => '__OK__', 'response_code' => WebService::CODE_SUCCESS];
  4909.     }
  4911.     /**
  4912.      * @author Felipe Arango <aarango@uva3.com> 28/01/2021
  4913.      * @param type $masterSyncRecord
  4914.      * @param type $responseArr
  4915.      * @param type $path
  4916.      */
  4917.     public function resetSyncAll(Request $request) {
  4919.         try {
  4920.             if ($request->getMethod() === WebService::REQUEST_METHOD_GET || $request->getMethod() === WebService::REQUEST_METHOD_POST) {
  4921.                 $path = Util::getValidActiveLogByBaseName($this->realContainer, 'resetSync', 'resetSync0.txt');
  4923.                 $em = $this->getDoctrine()->getManager();
  4924.                 
  4925.                 if ($request->getMethod() === WebService::REQUEST_METHOD_GET){
  4926.                     $this->createFileJson($path, 'get parameters => '. json_encode($request->query->all()) . "\r");
  4927.                     $nickname = $request->query->get("nickname");
  4928.                 }
  4930.                 if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  4931.                     $this->createFileJson($path, 'post parameters => '. $request->getContent() . "\r");
  4933.                     $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  4934.                     $data = json_decode($arrayEncryptResult['data'], true);
  4935.                     $nickname = $data['nickname'];
  4936.                 }
  4937.     
  4938.                 if ($nickname == null) {
  4939.                     $this->createFileJson($path, 'NicknName Undefined! ' . "\r");
  4940.                     return $this->errorWrongArgs('NicknName Undefined!', WebService::CODE_UNAUTHORIZED);
  4941.                 }
  4942.     
  4943.                 $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findOneBy(["alLicenseUsername" => $nickname]);
  4944.     
  4945.                 if (isset($accountLicenseData)) {
  4946.     
  4947.                     if ($accountLicenseData->getAlAccountLicense()->getDeleted()) {
  4948.                         $this->createFileJson($path, 'Deleted license! ' . "\r");
  4949.                         return $this->errorWrongArgs('Account inactive, please contact your system manager', WebService::CODE_UNAUTHORIZED);
  4950.                     }
  4951.     
  4952.                     if (!$accountLicenseData->getAlLicenseStatus()) {
  4953.                         $this->createFileJson($path, 'Inactive license! ' . "\r");
  4954.                         return $this->errorWrongArgs('License inactive, please contact your system manager', WebService::CODE_UNAUTHORIZED);
  4955.                     }
  4956.     
  4957.                     $resultResetSync = $em->getRepository('App\Entity\MasterSync')->resetSyncByLicense($accountLicenseData->getId(), $accountLicenseData->getHasLogedOMT());
  4958.     
  4959.                     $licenseDataBaseEntity = $em->getRepository('App\Entity\LicenseDataBase')->findOneBy(['license' => $accountLicenseData->getId()]);
  4960.     
  4961.                     $dataOptionsRoot = [
  4962.                         'dbname' => $licenseDataBaseEntity->getDbname(),
  4963.                         'user' => $licenseDataBaseEntity->getDbuser(),
  4964.                         'password' => $licenseDataBaseEntity->getDbpass(),
  4965.                         'host' => $licenseDataBaseEntity->getDbhost(),
  4966.                         'driver' => 'pdo_mysql',
  4967.                     ];
  4968.     
  4969.                     $emLev = Util::emCreateConfiguration($this->realContainer, $dataOptionsRoot);
  4970.     
  4971.                     $resultResetSync += $emLev->getRepository('App\Structure\RegistActions')->resetDataRegistAction();
  4972.                     $resultResetSync += $emLev->getRepository('App\Structure\Configuracion')->resetDataConfiguration();
  4974.                     $this->createFileJson($path, "rows affected -> $resultResetSync \r");
  4975.     
  4976.                     $responseArr['bigbag'] = true;
  4977.                     $responseArr['result'] = '__OK__';
  4978.                     $responseArr['msg'] = 'Successful synchronization reset';
  4979.                     $responseArr['status'] = WebService::CODE_SUCCESS;
  4980.     
  4981.                     $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  4982.                     $xxArray = $theUrlTrSt->transform();
  4983.     
  4984.                     $jsonContent = json_encode($xxArray);
  4985.     
  4986.                     return $this->respondWithItem($jsonContent, $theUrlTrSt);
  4987.                 } else {
  4988.                     $this->createFileJson($path, 'Invalid nickname ' . "\r");
  4990.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  4991.                                     ->respondWithError('Invalid nickname', WebService::CODE_UNAUTHORIZED);
  4992.                 }
  4993.             } else {
  4994.                 return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_GET . " method or " . WebService::REQUEST_METHOD_POST . " method");
  4995.             }
  4996.         } catch (\Throwable $th) {
  4997.             $err = ['Error message' => $th->getMessage(), 'Error Line' => $th->getLine(), 'Error File' => $th->getFile(), 'Error Trance' => $th->getTrace()];
  4998.             $this->createFileJson($path, "error detected ". json_encode($err) ." \r");
  5000.             return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)
  5001.                                     ->respondWithError($err, WebService::HTTP_CODE_INTERNAL_ERROR);
  5002.         }
  5003.     }
  5005.     /**
  5006.      * @author Aealan Z <lrobledo@kijho.com> 11/06/2016
  5007.      * @param type $masterSyncRecord
  5008.      * @param type $responseArr
  5009.      * @param type $path 
  5010.      */
  5011.     public function sendMailForUnansweredSyncPush($masterSyncRecord, $responseArr, $license, $path) {
  5012.         $body = "<p><label>Server: <strong>http://" . $this->realContainer->getParameter("licensor_base_url") . "/licensor/login</strong></label><br></p>";
  5014.         $theUnansweredPush = $masterSyncRecord[0]['msPushRecord'];
  5016.         $type = 1;
  5017.         if (!$theUnansweredPush) {
  5018.             $type = 2;
  5019.         }
  5021.         if ($type == 1) {
  5022.             $body .= "<label>Unanswered sync push detected...</label><br>";
  5023.             $body .= "<label>Unanswered push id:  <strong>" . $theUnansweredPush . "</strong></label><br>";
  5024.         } else {
  5025.             $body .= "<label>Unabled to send push...</label><br>";
  5026.         }
  5028.         $body .= "<label>Message delivered to android server <strong>" . $responseArr['msg'] . "</strong></label><br>";
  5029.         $body .= "<label>Master Sync Number: <strong>" . $masterSyncRecord[0]['id'] . "</strong></label><br>";
  5030.         $body .= "<label>License: <strong>" . $license . "</strong></label><br>";
  5032.         $emailsToNotify = $this->realContainer->getParameter('level_emails_syncs_errors');
  5034.         if ($type == 1) {
  5035.             $respArray['subject'] = "Unanswered Sync Push In " . $license->getAlLicenseUsername() . " License";
  5036.         } else {
  5037.             $respArray['subject'] = "Unabled To Send Push To " . $license->getAlLicenseUsername() . " License Requested Sync";
  5038.         }
  5039.         $this->createFileJson($path, "The subject: " . $respArray['subject'] . "\r");
  5041.         $respArray['message'] = "";
  5043.         foreach ($emailsToNotify as $mailTo) {
  5044.             $this->createFileJson($path, "Mail to -> " . $mailTo . "\r");
  5046.             $respArray['to'] = $mailTo;
  5048.             // Utilx::sendMailInfo($this->realContainer, $respArray, $path, $body);
  5049.         }
  5050.     }
  5052.     /**
  5053.      * Funcion polling que verifica si el push de sincronizacion de arriba a
  5054.      * abajo fue enviado
  5055.      * @author Aealan Z <lrobledo@kijho.com> 11/06/2016
  5056.      * @param type $masterSyncRecord registro maestro de la sincronizacion
  5057.      * @return boolean indicando que el push de de la sincronizacion fue enviado
  5058.      */
  5059.     public function checkForWebPushSend($masterSyncRecord, $path = null) {
  5061.         $responseToPolling = [];
  5063.         $auxCounter = 0;
  5064.         $keepInWhile = true;
  5066.         $masterSyncId = $masterSyncRecord['id'];
  5068.         if (!is_null($path)) {
  5069.             $this->createFileJson($path, 'Checking push send....' . "\r");
  5070.         }
  5072.         $em = $this->getDoctrine()->getManager();
  5074.         do {
  5075.             sleep(3);
  5076.             ++$auxCounter;
  5077.             $masterSyncRecord = $em->getRepository('App\Entity\ReadFilesDataWeb')->getTheMasterSyncArrayRecordById($masterSyncId, true);
  5079.             if (!is_null($path) && !empty($masterSyncRecord)) {
  5080.                 $this->createFileJson($path, "Checking push in'" . $masterSyncId . "' master sync record...  \r");
  5081.                 $this->createFileJson($path, ".. and the push...? " . json_encode($masterSyncRecord[0]['msPushRecord']) . "\r");
  5082.             }
  5084.             if (!empty($masterSyncRecord) && is_null($masterSyncRecord[0]['msPushRecord']) && $auxCounter < 7) {
  5085.                 sleep(1);
  5087.                 $keepInWhile = true;
  5089.                 $responseToPolling['msg'] = 'Awaiting for push send....';
  5090.                 $responseToPolling['response_code'] = WebService::SYNC_RESPONSE_PROCESSED;
  5091.                 $responseToPolling['wasAnswered'] = true;
  5092.                 $responseToPolling['masterRecord'] = $masterSyncRecord[0];
  5093.             } else {
  5094.                 if ($masterSyncRecord[0]['msPushRecord']) {
  5095.                     $keepInWhile = false;
  5096.                     $responseToPolling['msg'] = 'Push send... going forward whith the synchronization!';
  5097.                     $responseToPolling['response_code'] = WebService::SYNC_RESPONSE_PROCESSED;
  5098.                     $responseToPolling['wasAnswered'] = true;
  5099.                     $responseToPolling['masterRecord'] = $masterSyncRecord[0];
  5100.                 } elseif ($auxCounter >= 14) {
  5101.                     $keepInWhile = false;
  5102.                     if (!$masterSyncRecord[0]['msPushRecord']) {
  5103.                         $responseToPolling['msg'] = 'Waiting maximum time has been reached for push send.. Please try again later!';
  5104.                         $responseToPolling['response_code'] = WebService::MAXIMUM_WAIT_TIME_REACHED;
  5105.                         $responseToPolling['wasAnswered'] = false;
  5106.                         $responseToPolling['masterRecord'] = $masterSyncRecord[0];
  5107.                     }
  5108.                 } elseif ($masterSyncRecord[0]['loginType'] == AccountLicense::LOGGED_BY_LEVEL_LITE && $masterSyncRecord[0]['hasLogedOMT']) {
  5109.                     $keepInWhile = false;
  5111.                     if ($masterSyncRecord[0]['msPushRecord']) {
  5112.                         $pushArray = $em->getRepository('App\Entity\PushSent')->getThePushSentArrayRecordById($masterSyncRecord[0]['msPushRecord']);
  5114.                         if (!empty($pushArray) && $pushArray[0]['omtCurlStatus'] == PushSent::STATUS_CURL_FINISHED) {
  5115.                             $responseToPolling['msg'] = 'Sync no needed..';
  5116.                             $responseToPolling['response_code'] = WebService::SYNC_DONE_SUCCESSFULLY;
  5117.                             $responseToPolling['wasAnswered'] = true;
  5118.                             $responseToPolling['masterRecord'] = $masterSyncRecord[0];
  5119.                         }
  5120.                     }
  5121.                 }
  5122.             }
  5124.             $em->clear();
  5125.         } while ($keepInWhile && $auxCounter < 14);
  5127.         return $responseToPolling;
  5128.     }
  5130.     /**
  5131.      * Funcion polling que verifica si el push de sincronizacion de arriba a
  5132.      * abajo fue enviado
  5133.      * @author Aealan Z <lrobledo@kijho.com> 11/06/2016
  5134.      * @param type $masterSyncRecord registro maestro de la sincronizacion
  5135.      * @return boolean indicando que el push de de la sincronizacion fue enviado
  5136.      */
  5137.     public function checkForWebPushSendOMT($masterSyncRecord, $path = null) {
  5139.         $responseToPolling = [];
  5141.         $auxCounter = 0;
  5142.         $keepInWhile = true;
  5144.         $masterSyncId = $masterSyncRecord->getId();
  5146.         if (!is_null($path)) {
  5147.             $this->createFileJson($path, 'Checking push send....' . "\r");
  5148.         }
  5150.         $em = $this->getDoctrine()->getManager();
  5152.         do {
  5153.             sleep(3);
  5154.             ++$auxCounter;
  5155.             $masterSyncRecord = $em->getRepository('App\Entity\MasterSync')->find($masterSyncId);
  5157.             if (!is_null($path) && $masterSyncRecord) {
  5158.                 $this->createFileJson($path, "Checking push in'" . $masterSyncId . "' master sync record...  \r");
  5159.                 $this->createFileJson($path, ".. and the push...? " . json_encode($masterSyncRecord->getMsPushRecord()) . "\r");
  5160.             }
  5162.             if ($masterSyncRecord && (is_null($masterSyncRecord->getMsPushRecord()) || is_null($masterSyncRecord->getMsPushRecord()->getOmtCurlStatus()))) {
  5163.                 sleep(1);
  5165.                 $keepInWhile = true;
  5167.                 $responseToPolling['msg'] = 'Awaiting response from the curl!!!!!!!!!!';
  5168.                 $responseToPolling['response_code'] = WebService::SYNC_RESPONSE_PROCESSED;
  5169.                 $responseToPolling['wasAnswered'] = true;
  5170.                 $responseToPolling['masterRecord'] = $masterSyncRecord;
  5171.             } else {
  5172.                 if ($masterSyncRecord->getMsPushRecord()->getOmtCurlStatus() == PushSent::STATUS_CURL_PENDING) {
  5173.                     $keepInWhile = false;
  5174.                     $responseToPolling['msg'] = 'Push send... going forward whith the synchronization!';
  5175.                     $responseToPolling['response_code'] = WebService::SYNC_RESPONSE_PROCESSED;
  5176.                     $responseToPolling['wasAnswered'] = true;
  5177.                     $responseToPolling['masterRecord'] = $masterSyncRecord;
  5178.                 } elseif ($auxCounter >= 14) {
  5179.                     $keepInWhile = false;
  5180.                     if ($masterSyncRecord->getMsPushRecord()->getOmtCurlStatus() == PushSent::STATUS_CURL_PENDING || $masterSyncRecord->getMsPushRecord()->getOmtCurlStatus() == PushSent::STATUS_CURL_RESPONDED) {
  5181.                         $responseToPolling['msg'] = 'Waiting maximum time has been reached for push send.. Please try again later!';
  5182.                         $responseToPolling['response_code'] = WebService::MAXIMUM_WAIT_TIME_REACHED;
  5183.                         $responseToPolling['wasAnswered'] = false;
  5184.                         $responseToPolling['masterRecord'] = $masterSyncRecord;
  5185.                     }
  5186.                 } elseif ($masterSyncRecord->getMsLicense()->getLoginType() == AccountLicense::LOGGED_BY_LEVEL_LITE && $masterSyncRecord->getMsLicense()->getHasLogedOMT()) {
  5187.                     $keepInWhile = false;
  5188.                     if ($masterSyncRecord->getMsPushRecord()->getOmtCurlStatus() == PushSent::STATUS_CURL_FINISHED) {
  5189.                         $responseToPolling['msg'] = 'Sync no needed..';
  5190.                         $responseToPolling['response_code'] = WebService::SYNC_DONE_SUCCESSFULLY;
  5191.                         $responseToPolling['wasAnswered'] = true;
  5192.                         $responseToPolling['masterRecord'] = $masterSyncRecord;
  5193.                     }
  5194.                 }
  5195.             }
  5197.             $em->clear();
  5198.         } while ($keepInWhile && $auxCounter < 14);
  5200.         return $responseToPolling;
  5201.     }
  5203.     /**
  5204.      * Funcion polling para verificar si el push de la sincronizacion de arriba
  5205.      * a abajo fue respondido
  5206.      * @author Aealan Z <lrobledo@kijho.com> 11/06/2016
  5207.      * @param type $unrespondedPush registro del push de sincronizacion de arriba a abajo enviado
  5208.      * @return boolean que indica si fue respondido o no el push
  5209.      */
  5210.     public function checkForWebPushResponse($unrespondedPush, $path) {
  5212.         $responseToPolling = [];
  5214.         $auxCounter = 0;
  5215.         $keepInWhile = true;
  5217.         $this->createFileJson($path, 'Checking push response....' . "\r");
  5218.         $this->createFileJson($path, 'Checking push -> ' . $unrespondedPush[0]['id'] . "\r");
  5220.         $em = $this->getDoctrine()->getManager();
  5222.         do {
  5223.             sleep(3);
  5224.             ++$auxCounter;
  5225.             $pushArray = $em->getRepository('App\Entity\PushSent')->getThePushSentArrayRecordById($unrespondedPush[0]['id']);
  5226.             // $unrespondedPush = $em->getRepository('App\Entity\PushSent')->find($unrespondedPush->getId());
  5228.             if ($pushArray[0]['pushStatus'] == PushSent::STATUS_PUSH_READED) {
  5229.                 $keepInWhile = false;
  5230.                 $responseToPolling['msg'] = 'Push answered.. going forward whith the synchronization!';
  5231.                 $responseToPolling['response_code'] = WebService::SYNC_RESPONSE_PROCESSED;
  5232.                 $responseToPolling['wasAnswered'] = true;
  5233.             } elseif ($auxCounter >= 14) {
  5234.                 $keepInWhile = false;
  5235.                 if ($pushArray[0]['pushStatus'] == PushSent::STATUS_PUSH_PENDING) {
  5236.                     $responseToPolling['msg'] = 'Waiting maximum time has been reached for push answer.. Please try again later!';
  5237.                     $responseToPolling['response_code'] = WebService::MAXIMUM_WAIT_TIME_REACHED;
  5238.                     $responseToPolling['wasAnswered'] = false;
  5239.                 }
  5240.             } elseif ($pushArray[0]['loginType'] == AccountLicense::LOGGED_BY_LEVEL_LITE && $pushArray[0]['hasLogedOMT']) {
  5241.                 $unrespondedPushEntity = $em->getRepository('App\Entity\PushSent')->find($unrespondedPush[0]['id']);
  5243.                 $unrespondedPushEntity->setPushStatus(PushSent::STATUS_PUSH_READED);
  5244.                 $unrespondedPushEntity->setRespondDate($unrespondedPushEntity->getRespondDate());
  5246.                 $em->persist($unrespondedPushEntity);
  5247.                 $em->flush();
  5249.                 $responseToPolling['msg'] = 'Automatic closure for unprocedent push!';
  5250.                 $responseToPolling['response_code'] = WebService::SYNC_RESPONSE_PROCESSED;
  5251.                 $responseToPolling['wasAnswered'] = true;
  5253.                 $keepInWhile = false;
  5254.             } else {
  5255.                 $em->clear();
  5256.             }
  5257.         } while ($keepInWhile && $auxCounter < 14);
  5259.         return $responseToPolling;
  5260.     }
  5262.     /**
  5263.      * Funcion polling para determinar si fue respondida la sincronizacion de arriba
  5264.      * a abajo por el servidor android
  5265.      * @author Aealan Z <lrobledo@kijho.com> 11/06/2016
  5266.      * @param type $syncWebRecord registro de la sincronizacion web
  5267.      * @return boolean que indica si fue respondida o no la sincronizacion web
  5268.      */
  5269.     public function checkForWebResponse($syncWebRecord, $path) {
  5271.         $responseToPolling = [];
  5273.         $auxCounter = 0;
  5274.         $keepInWhile = true;
  5276.         $this->createFileJson($path, 'Checking sync web response....' . "\r");
  5278.         $em = $this->getDoctrine()->getManager();
  5280.         do {
  5281.             sleep(3);
  5282.             ++$auxCounter;
  5283.             $syncWebRecord = $em->getRepository('App\Entity\ReadFilesDataWeb')->getTheWebSyncArrayRecordById($syncWebRecord);
  5285.             if ($syncWebRecord[0]['rfwStatus'] == ReadFilesDataWeb::STATUS_RESPONSE_READED) {
  5286.                 $keepInWhile = false;
  5287.                 $responseToPolling['msg'] = 'Web sync answered.. going forward whith the down up synchronization!';
  5288.                 $responseToPolling['response_code'] = WebService::SYNC_RESPONSE_PROCESSED;
  5289.                 $responseToPolling['wasAnswered'] = true;
  5290.             } elseif ($auxCounter >= 14) {
  5291.                 $keepInWhile = false;
  5292.                 if ($syncWebRecord[0]['rfwStatus'] < ReadFilesDataWeb::STATUS_RESPONSE_READED) {
  5293.                     $responseToPolling['msg'] = 'Waiting maximum time has been reached for web sync answer.. Please try again later!';
  5294.                     $responseToPolling['response_code'] = WebService::MAXIMUM_WAIT_TIME_REACHED;
  5295.                     $responseToPolling['wasAnswered'] = false;
  5296.                 }
  5297.             } else {
  5298.                 $em->clear();
  5299.             }
  5300.         } while ($keepInWhile);
  5302.         return $responseToPolling;
  5303.     }
  5305.     /**
  5306.      * Funcion polling para verificar si termino con exito la sincronizacion de arriba a abajo
  5307.      * @author Aealan Z <lrobledo@kijho.com> 11/06/2016
  5308.      * @param type $masterSyncRecord registro maestro de la sincronizacion en proceso
  5309.      * @return boolean indicando si la sincronizacion de arriba a abajo termino con exito
  5310.      */
  5311.     public function checkForWebSyncClose($masterSyncRecord, $path) {
  5313.         $responseToPolling = [];
  5315.         $auxCounter = 0;
  5316.         $keepInWhile = true;
  5318.         $this->createFileJson($path, 'Checking sync web finish....' . "\r");
  5320.         if (!$masterSyncRecord['id']) {
  5321.             $responseToPolling['msg'] = 'Waiting maximum time has been reached for web sync answer.. Please try again later!';
  5322.             $responseToPolling['response_code'] = WebService::MAXIMUM_WAIT_TIME_REACHED;
  5323.             $responseToPolling['wasAnswered'] = false;
  5325.             return $responseToPolling;
  5326.         }
  5328.         $em = $this->getDoctrine()->getManager();
  5330.         do {
  5331.             sleep(3);
  5332.             ++$auxCounter;
  5333.             $masterSyncRecord = $em->getRepository('App\Entity\ReadFilesDataWeb')->getTheMasterSyncArrayRecordById($masterSyncRecord['id'], true);
  5335.             if ($masterSyncRecord[0]['msStatus'] == MasterSync::MASTER_STATUS_CLOSED) {
  5336.                 $keepInWhile = false;
  5337.                 $responseToPolling['msg'] = 'Web sync finished.. going forward whith the down up synchronization!';
  5338.                 $responseToPolling['response_code'] = WebService::SYNC_RESPONSE_PROCESSED;
  5339.                 $responseToPolling['wasAnswered'] = true;
  5340.             } elseif ($auxCounter >= 14) {
  5341.                 $keepInWhile = false;
  5342.                 if ($masterSyncRecord[0]['msStatus'] <= MasterSync::MASTER_STATUS_CLOSED) {
  5343.                     $responseToPolling['msg'] = 'Waiting maximum time has been reached for web sync finish.. Please try again later!';
  5344.                     $responseToPolling['response_code'] = WebService::MAXIMUM_WAIT_TIME_REACHED;
  5345.                     $responseToPolling['wasAnswered'] = false;
  5346.                 }
  5347.             } else {
  5348.                 $em->clear();
  5349.             }
  5350.         } while ($keepInWhile);
  5352.         return $responseToPolling;
  5353.     }
  5355.     /**
  5356.      * Funcion polling para verificar la respuesta de una sincronizacion de abajo
  5357.      * a arriba, este funcion verifica en un tiempo maximo de 56 segundos
  5358.      * @author Aealan Z <lrobledo@kijho.com> 11/06/2016
  5359.      * @param type $id id de lalicencia a la cual se verificara la respuesta
  5360.      * @param type $paramLastId id de la ultima sincronizacion de abajo a arriba respondido
  5361.      * @return boolean indica si se respondio o no la solicitud en el tiempo establecido
  5362.      */
  5363.     public function checkForDownUpPolling($id, $paramLastId, $path) {
  5365.         $checkResponse = [];
  5367.         $auxCounter = 0;
  5368.         $keepInWhile = true;
  5370.         $this->createFileJson($path, 'Checking sync response for ' . $id . " license \r");
  5372.         $em = $this->getDoctrine()->getManager();
  5374.         do {
  5375.             sleep(4);
  5376.             ++$auxCounter;
  5377.             $lastReadDataForLicense = $em->getRepository('App\Entity\ReadFilesData')->checkForNewSyncPetitionByLicense($id, $paramLastId, true);
  5379.             if (count($lastReadDataForLicense) > 0) {
  5380.                 $this->createFileJson($path, 'Count For Polling Status: -> ' . $paramLastId . ' -> ' . $lastReadDataForLicense[0]['id'] . ' => ' . $lastReadDataForLicense[0]['rfStatus'] . "\r");
  5381.             } else {
  5382.                 $this->createFileJson($path, 'Count For Polling: -> ' . $paramLastId . ' => ' . count($lastReadDataForLicense) . "\r");
  5383.             }
  5385.             $askingSyncPushRecordArray = $em->getRepository('App\Entity\PushSent')->findLastAskingSyncPushToLicense($id, true);
  5386.             $askingSyncPushRecord = $askingSyncPushRecordArray[0];
  5387.             $this->createFileJson($path, 'Push Record Found In Polling: -> ' . $askingSyncPushRecord['id'] . "\r");
  5389.             if (isset($askingSyncPushRecord['newPushSendedStage']) && $askingSyncPushRecord['newPushSendedStage'] == PushSent::SENDED_STAGE_OMT_SOCKET_PUSH) {
  5390.                 $keepInWhile = false;
  5391.                 $this->createFileJson($path, "push omt type detected!! \r");
  5393.                 $checkResponse['newPushSendedStage'] = PushSent::SENDED_STAGE_OMT_SOCKET_PUSH;
  5394.                 $checkResponse['wasAnswered'] = true;
  5395.                 $checkResponse['msg'] = 'Android server sync processed.. Please check for the new data!';
  5396.                 $checkResponse['response_code'] = WebService::SYNC_DONE_SUCCESSFULLY;
  5397.             } elseif (!empty($lastReadDataForLicense) && $lastReadDataForLicense[0]['rfStatus'] > ReadFilesData::STATUS_UPLOADED) {
  5398.                 $keepInWhile = false;
  5399.                 $checkResponse['status'] = SyncAllWebsocketVersionCommand::ANDROID_SYNC_SUCCESS;
  5400.                 $checkResponse['msg'] = 'Android server sync processed.. Please check for the new data!';
  5401.                 $checkResponse['response_code'] = WebService::SYNC_DONE_SUCCESSFULLY;
  5402.                 $checkResponse['wasAnswered'] = true;
  5403.             } elseif (!empty($askingSyncPushRecord) && $askingSyncPushRecord['askedResponse'] === false) {
  5404.                 $keepInWhile = false;
  5405.                 $checkResponse['status'] = SyncAllWebsocketVersionCommand::ANDROID_HAVE_NOTHING_TO_SYNC;
  5406.                 $checkResponse['msg'] = 'Android server have nothing to synchronize... finishing synchronization!';
  5407.                 $checkResponse['response_code'] = WebService::NOTHING_TO_WEB_SYNCHRONIZE;
  5408.                 $checkResponse['wasAnswered'] = true;
  5409.             } elseif ($auxCounter > 7) {
  5410.                 $keepInWhile = false;
  5411.                 if (count($lastReadDataForLicense) > 0) {
  5412.                     $checkResponse['status'] = SyncAllWebsocketVersionCommand::ANDROID_SYNC_SUCCESS;
  5413.                     $checkResponse['msg'] = 'Android server sync processed.. Please check for the new data!';
  5414.                     $checkResponse['response_code'] = WebService::SYNC_DONE_SUCCESSFULLY;
  5415.                     $checkResponse['wasAnswered'] = true;
  5416.                 } else {
  5417.                     $checkResponse['status'] = SyncAllWebsocketVersionCommand::ANDROID_WAITING_MAXIMUM_TIME;
  5418.                     $checkResponse['msg'] = 'Waiting maximum time has been reached for Android new data.. Please try again later!';
  5419.                     $checkResponse['response_code'] = WebService::MAXIMUM_WAIT_TIME_REACHED;
  5420.                     $checkResponse['wasAnswered'] = false;
  5421.                 }
  5422.             } elseif ($askingSyncPushRecord['loginType'] == AccountLicense::LOGGED_BY_LEVEL_LITE && $askingSyncPushRecord['hasLogedOMT']) {
  5423.                 $askingSyncPushRecord = $em->getRepository('App\Entity\PushSent')->find($askingSyncPushRecord['id']);
  5424.                 
  5425.                 $askingSyncPushRecord->setPushStatus(PushSent::STATUS_PUSH_READED);
  5426.                 $askingSyncPushRecord->setRespondDate($askingSyncPushRecord->getRespondDate());
  5427.                 $askingSyncPushRecord->setAskedResponse(false);
  5429.                 $em->persist($askingSyncPushRecord);
  5430.                 $em->flush();
  5432.                 $checkResponse['status'] = SyncAllWebsocketVersionCommand::SYNC_DONE;
  5433.                 $checkResponse['msg'] = 'Sync done.. Please check for the new data!';
  5434.                 $checkResponse['response_code'] = WebService::SYNC_RESPONSE_PROCESSED;
  5435.                 $checkResponse['wasAnswered'] = true;
  5437.                 $keepInWhile = false;
  5438.             } else {
  5439.                 $em->clear();
  5440.             }
  5441.         } while ($keepInWhile);
  5443.         return $checkResponse;
  5444.     }
  5446.     public function checkForDownUp(AccountLicense $license, bool $pushAskedResponse, $path) {
  5447.         $this->createFileJson($path, "Checking sync response for {$license->getId()} license \r");
  5448.         $em = $this->getDoctrine()->getManager();
  5450.         $lastReadDataForLicense = $em->getRepository('App\Entity\ReadFilesData')->findLastSyncPetitionIdByLicense($license->getId());
  5451.         $lastReadDataForLicense = $em->getRepository('App\Entity\ReadFilesData')->checkForNewSyncPetitionByLicense($license->getId(), $lastReadDataForLicense, true);
  5453.         $checkResponse = [];
  5455.         if (!empty($lastReadDataForLicense) && $lastReadDataForLicense[0]['rfStatus'] > ReadFilesData::STATUS_UPLOADED) {
  5456.             $this->createFileJson($path, "Android server sync processed.. Please check for the new data! \r");
  5457.             $checkResponse['status'] = SyncAllWebsocketVersionCommand::ANDROID_SYNC_SUCCESS;
  5458.         }else if(!$pushAskedResponse){
  5459.             $this->createFileJson($path, "Android server have nothing to synchronize... finishing synchronization! \r");
  5460.             $checkResponse['status'] = SyncAllWebsocketVersionCommand::ANDROID_HAVE_NOTHING_TO_SYNC;
  5461.         }else{
  5462.             $this->createFileJson($path, "clear \r");
  5463.             $em->clear();
  5464.         }
  5466.         $this->createFileJson($path, "check response => ". json_encode($checkResponse) ." \r");
  5467.         return $checkResponse;
  5468.     }
  5470.     /**
  5471.      * WS generico experimental para la codificacion y decodificacion del encriptado
  5472.      * utilizado entre licensor y android
  5473.      * @author Aealan Z <lrobledo@kijho.com> 18/06/15
  5474.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  5475.      * @return Response Json con la informacion de respuesta
  5476.      */
  5477.     public function cosito(Request $request) {
  5478.         if ($request->getMethod() === WebService::REQUEST_METHOD_GET) {
  5479.             $path = $this->realContainer->getParameter('level_directory_data_android') . 'TestiDecodePath.txt';
  5480.             $jsn = $this->realContainer->getParameter('level_directory_data_android') . 'TresChangos.txt';
  5481.             $arrData = Util::getAllDecryptedJsonContent($this->realContainer, $jsn, true, $path, true, false);
  5483.             $r = new Response($arrData);
  5484.             $r->headers->set('Content-Type', 'application/json');
  5485.             return $r;
  5486.         } else {
  5487.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_GET . " method");
  5488.         }
  5489.     }
  5491.     /**
  5492.      * WS generico para que el cliente andorid responda todos los push enviados a los clientes
  5493.      * @author Aealan Z <lrobledo@kijho.com> 18/06/15
  5494.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  5495.      * @return Response Json con la informacion de respuesta
  5496.      */
  5497.     public function cositoDos(Request $request) {
  5498.         if ($request->getMethod() === WebService::REQUEST_METHOD_GET) {
  5500.             $jsn = file_get_contents($this->realContainer->getParameter('level_directory_data_android') . 'UnChangoDos.txt');
  5502.             $responseToAjax['content'] = trim($jsn, " \t\n\r\0\x0B");
  5503.             return $this->respondJsonAjax($responseToAjax);
  5504.         } else {
  5505.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  5506.         }
  5507.     }
  5509.     /**
  5510.      * WS generico para que el cliente andorid responda todos los push enviados a los clientes
  5511.      * @author Aealan Z <lrobledo@kijho.com> 18/06/15
  5512.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  5513.      * @return Response Json con la informacion de respuesta
  5514.      */
  5515.     public function cositoTres(Request $request) {
  5516.         if ($request->getMethod() === WebService::REQUEST_METHOD_GET) {
  5518. //            $jsn = file_get_contents($this->realContainer->getParameter('level_directory_data_android') . 'UnChangoTres.txt');
  5520.             $cipher = "rijndael-128";
  5521.             $mode = "cbc";
  5522.             $secret_key = "D4:6E:AC:3F:F0:BE";
  5523. //iv length should be 16 bytes
  5524.             $iv = "fedcba9876543210";
  5526.             $key_len = strlen($secret_key);
  5527.             if ($key_len < 16) {
  5528.                 $addS = 16 - $key_len;
  5529.                 for ($i = 0; $i < $addS; ++$i) {
  5530.                     $secret_key .= " ";
  5531.                 }
  5532.             } else {
  5533.                 $secret_key = substr($secret_key, 0, 16);
  5534.             }
  5536.             $td = mcrypt_module_open($cipher, "", $mode, $iv);
  5537.             mcrypt_generic_init($td, $secret_key, $iv);
  5539.             var_dump($this->realContainer->getParameter('level_directory_data_android') . 'UnChangoTres.txt');
  5540.             die();
  5541.             $getText = file_get_contents($this->realContainer->getParameter('level_directory_data_android') . 'UnChangoTres.txt');
  5542.             $textArray = explode('\r', $getText);
  5543.             $textCount = count($textArray);
  5545.             for ($i = 0; $i < $textCount; ++$i) {
  5546.                 $cyper_text = mcrypt_generic($td, $textArray[$i]);
  5547.                 mcrypt_generic_deinit($td);
  5548.                 mcrypt_module_close($td);
  5549.                 $textEncrypt = bin2hex($cyper_text);
  5550.                 $setText = base64_encode($textEncrypt);
  5551.                 $fp = fopen($this->realContainer->getParameter('level_directory_data_android') . 'UnChangoTresResponse.txt', "a+");
  5552.                 fwrite($fp, $setText);
  5553.                 fclose($fp);
  5554.             }
  5556. //            $path = $this->realContainer->getParameter('level_directory_data_android') . 'UnChangoTresResponse.txt';
  5557. //            $pathXD = $this->realContainer->getParameter('level_directory_data_android') . 'UnChangoTresTest.txt';
  5558. //            Util::putAllEncryptedJsonContent($this->realContainer, trim($jsn, " \t\n\r\0\x0B"), $path, true, $pathXD);
  5560.             $responseToAjax['content'] = 'Si encripto...?';
  5561.             return $this->respondJsonAjax($responseToAjax);
  5562.         } else {
  5563.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  5564.         }
  5565.     }
  5567.     /**
  5568.      * Esta funcion permite notificar por correo, un error persistente dentro
  5569.      * de los registros de sincronizacion de determinada licencia
  5570.      * @author Aealan Z <lrobledo@kijho.com> 18/12/15
  5571.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  5572.      * @return Response Json con la informacion de respuesta
  5573.      */
  5574.     public function notifySyncRecurrentError(Request $request) {
  5576.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  5578.             $data = [];
  5579.             $dataForTrack = [];
  5581.             $parameters = $request->request->all();
  5583.             $path = Util::getValidActiveLogByBaseName($this->realContainer, 'notifyRecurrentSyncError', 'notifyRecurrentSyncError0.txt');
  5585.             $this->createFileJson($path, "The Request -> " . json_encode($parameters) . "\r");
  5587.             $arrayEncryptResult = Util::decryptDataForUploadsFiles($this->realContainer, $parameters['nickname']);
  5588.             $data['nickname'] = $arrayEncryptResult['data'];
  5589.             $dataForTrack['nickname'] = $parameters['nickname'];
  5591.             $arrayEncryptResult = Util::decryptDataForUploadsFiles($this->realContainer, $parameters['uid']);
  5592.             $data['uid'] = $arrayEncryptResult['data'];
  5593.             $dataForTrack['uid'] = $parameters['uid'];
  5595.             $em = $this->getDoctrine()->getManager();
  5597.             $search = ['alLicenseUsername' => $data['nickname']];
  5598.             $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findBy($search);
  5600.             if (empty($accountLicenseData)) {
  5601.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  5602.                                 ->respondWithError('Invalid nickname', WebService::CODE_UNAUTHORIZED);
  5603.             } elseif ($accountLicenseData[0]->getDeviceUid() != $data['uid']) {
  5604.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  5605.                                 ->respondWithError('Unknown device', WebService::CODE_UNAUTHORIZED);
  5606.             }
  5608.             $respArray = [];
  5609.             $respArray['result'] = '__OK__';
  5610.             $respArray['msg'] = '';
  5612.             if (isset($parameters['idsync'])) {
  5613.                 $arrayEncryptResult = Util::decryptDataForUploadsFiles($this->realContainer, $parameters['idsync']);
  5614.                 $data['idsync'] = $arrayEncryptResult['data'];
  5615.                 $dataForTrack['idsync'] = $arrayEncryptResult['data'];
  5617.                 $errorsToEmail = $em->getRepository('App\Entity\SyncReportedError')->find($data['idsync']);
  5619.                 if (!$errorsToEmail) {
  5620.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  5621.                                     ->respondWithError('Error record not found!', WebService::CODE_UNAUTHORIZED);
  5622.                 }
  5623.             } else {
  5624.                 $responseArrayWithUrl = Util::createLicenseDirectory($this->realContainer, $accountLicenseData[0], $data['nickname']);
  5626.                 $theAccountDirector = $responseArrayWithUrl['directory'];
  5628.                 $uploadFileResponse = Utilx::uploadFileTo($request, $theAccountDirector, $path);
  5630.                 if (!isset($uploadFileResponse['result']) || !isset($uploadFileResponse['msg'])) {
  5631.                     $this->createFileJson($path, 'Unknown error uploading file ' . "\r");
  5632.                     return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)
  5633.                                     ->respondWithError('Unknown error uploading file', WebService::CODE_INTERNAL_ERROR);
  5634.                 }
  5636.                 if (isset($uploadFileResponse['result']) && isset($uploadFileResponse['msg']) && $uploadFileResponse['result'] == '__KO__') {
  5637.                     $this->createFileJson($path, $uploadFileResponse['msg'] . "\r");
  5638.                     return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)
  5639.                                     ->respondWithError($uploadFileResponse['msg'], WebService::CODE_INTERNAL_ERROR);
  5640.                 }
  5642.                 $errorsToEmail = new SyncReportedError();
  5644.                 $errorsToEmail->setStatus(SyncReportedError::STATUS_CREATED);
  5645.                 $errorsToEmail->setLicense($accountLicenseData[0]);
  5646.                 $actualDate = Util::getCurrentDate();
  5647.                 $errorsToEmail->setDateErrorCreated($actualDate);
  5648.                 $errorsToEmail->setErrorFile($uploadFileResponse['fileName']);
  5650.                 $currentUrl = $request->getUri();
  5652. //                if (strpos($currentUrl, 'app_dev.php') !== false) {
  5653.                 $errorsToEmail->setApplicationMode(false);
  5654. //                } else {
  5655. //                    $errorsToEmail->setApplicationMode(true);
  5656. //                }
  5658.                 $em->persist($errorsToEmail);
  5659.                 $em->flush();
  5661.                 $this->createFileJson($path, "File uploaded -> " . $uploadFileResponse['fileName'] . "\r");
  5662.             }
  5664.             $this->createFileJson($path, json_encode($dataForTrack) . "\r");
  5666.             $emailsToNotify = $this->realContainer->getParameter('level_emails_syncs_errors');
  5668.             $responseArrayWithUrl = Util::createLicenseDirectory($this->realContainer, $accountLicenseData[0], $data['nickname']);
  5670.             $urlToErrorFile = $responseArrayWithUrl['directory'] . '/' . $errorsToEmail->getErrorFile();
  5672.             $this->createFileJson($path, "Ya casi! -> " . $urlToErrorFile . "\r");
  5674.             if (isset($parameters['isIgnored'])) {
  5675.                 $theSubject = $data['nickname'] . ' ignored records sync error ';
  5676.             } else {
  5677.                 $theSubject = $data['nickname'] . ' recurrent sync error ';
  5678.             }
  5680.             $respArray['subject'] = $theSubject;
  5681.             $respArray['message'] = "";
  5683.             $body = "<html><body><div><p><label><strong>" . $data['nickname'] . "</strong>   Uuppss... -_-!</label></p><br></div></body></html>";
  5685.             foreach ($emailsToNotify as $mailTo) {
  5686.                 $this->createFileJson($path, "Mail to -> " . $mailTo . "\r");
  5688.                 $emailSuccess = true;
  5690.                 $respArray['to'] = $mailTo;
  5692.                 Utilx::sendMailInfo($this->realContainer, $respArray, $path, $body, $urlToErrorFile);
  5693.             }
  5695.             $this->createFileJson($path, "Si llego? -> " . $urlToErrorFile . "\r");
  5697.             $statusArryMsg = [];
  5698.             $statusArryMsg['status'] = WebService::CODE_SUCCESS;
  5700.             if ($emailSuccess) {
  5701.                 $errorsToEmail->setStatus(SyncReportedError::STATUS_NOTIFIED);
  5702.                 $actualDate = Util::getCurrentDate();
  5703.                 $errorsToEmail->setDateErrorNotified($actualDate);
  5705.                 $em->persist($errorsToEmail);
  5706.                 $em->flush();
  5708.                 $statusArryMsg['msg'] = 'Recurrent sync errors notified!';
  5709.             } else {
  5710.                 return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)
  5711.                                 ->respondWithError('Erro notifiying recurrent errors by email!', WebService::CODE_INTERNAL_ERROR);
  5712.             }
  5714.             $theUrlTrSt = new UploadSyncJsonNotifyTransformer($this->realContainer, $statusArryMsg);
  5715.             $jsonTransform = $theUrlTrSt->transform();
  5717.             $jsonContent = json_encode($jsonTransform);
  5719.             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  5720.         } else {
  5721.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  5722.         }
  5723.     }
  5725.     /**
  5726.      * Funcion para actualizar el registro de un push marcandolo como leido
  5727.      * @author Aealan Z <lrobledo@kijho.com> 11/06/2016
  5728.      * @param type $pushEntity registro de push a actualizar
  5729.      * @return boolean booleano que indica si se actualizo el registro con exito
  5730.      */
  5731.     public function updateRegistPushSend($pushEntity) {
  5732.         $em = $this->getDoctrine()->getManager();
  5734.         $pushEntity->setPushStatus(PushSent::STATUS_PUSH_READED);
  5735.         $actualDate = Util::getCurrentDate();
  5736.         $pushEntity->setRespondDate($actualDate);
  5738.         $em->persist($pushEntity);
  5739.         try {
  5740.             $em->flush();
  5741.             return true;
  5742.         } catch (\Exception $ex) {
  5743.             return false;
  5744.         }
  5745.     }
  5747.     /**
  5748.      * Funcion para crear un nuevo registro de sincronizacion de abajo a arriba
  5749.      * @author Aealan Z <lrobledo@kijho.com> 11/06/2016
  5750.      * @param type $license licencia a la cual se le creara el nuevo registro
  5751.      * de sincronizacion
  5752.      * @return boolean|ReadFilesData retorna el nuevo registro de sincronizacion
  5753.      * si este fue creado correctamente, de lo contrario retorna un booleano (false)
  5754.      */
  5755.     public function setRegistNewFile($license) {
  5756.         $em = $this->getDoctrine()->getManager();
  5758.         $masterSync = Utilx::setRegistNewMasterSyncRecordFile($em, $license, MasterSync::MASTER_SYNC_TYPE_DOWUP);
  5760.         $entity = new ReadFilesData();
  5761.         $entity->setRfLicenseId($license);
  5762.         $entity->setRfStatus(ReadFilesData::STATUS_STANDBY);
  5763.         $actualDate = Util::getCurrentDate();
  5764.         $entity->setRfDateSincAsk($actualDate);
  5765.         $entity->setIsReadedByServer(false);
  5767.         $appMode = $this->realContainer->getParameter('kernel.environment');
  5769.         if ($appMode == 'dev') {
  5770.             $entity->setApplicationMode(false);
  5771.         } else {
  5772.             $entity->setApplicationMode(true);
  5773.         }
  5775.         $em->persist($entity);
  5776.         try {
  5777.             $em->flush();
  5779.             $masterSync->setMsSyncRecord($entity);
  5781.             $em->persist($masterSync);
  5783.             $em->flush();
  5784.             return $entity;
  5785.         } catch (\Exception $ex) {
  5786.             return false;
  5787.         }
  5788.     }
  5790.     /**
  5791.      * Funcion en donde se crea el registro de una notificacion de error
  5792.      * por email junto con el error adjunto, en este funcion se notifican
  5793.      * tanto licencias como sublicencias
  5794.      * @author Aealan Z <lrobledo@kijho.com> 11/06/2016
  5795.      * @param type $license registro de la licencia a la que se notificara el error
  5796.      * @param type $mailedTo email al que se el enviara el correo del error
  5797.      * @param type $msgError mensaje de error a notificar
  5798.      * @param type $deviceUid UID del dispositivo que reporta el error
  5799.      * @param type $errorCode codigo que identifica a cada error distinto en el sistema
  5800.      * @param type $subLicense registro de sublicencia a la que se le notificara el error
  5801.      * @return boolean|ErrorAndroidEmailSent registro de la notificacion del error por email
  5802.      * si se creo exitosamente, de lo contrario retorna un booleano (false)
  5803.      */
  5804.     public function setRegistErrorEmail($license, $mailedTo, $msgError, $deviceUid, $errorCode, $subLicense = null) {
  5805.         $em = $this->getDoctrine()->getManager();
  5807.         $entity = new ErrorAndroidEmailSent();
  5809.         if ($license) {
  5810.             $entity->setLiceseError($license);
  5811.         } else {
  5812.             $entity->setSubLicenseError($subLicense);
  5813.         }
  5815.         $entity->setEmailRecordStatus(ErrorAndroidEmailSent::STATUS_SERVER_NOTIFIED);
  5816.         $actualDate = Util::getCurrentDate();
  5817.         $entity->setDateErrorReported($actualDate);
  5818.         $entity->setErrorMsg($msgError);
  5819.         $entity->setMailedTo($mailedTo);
  5820.         $entity->setUidErrorDevice($deviceUid);
  5821.         $entity->setErrorCode($errorCode);
  5822.         $entity->setDateErrorLastReport($actualDate);
  5823.         $entity->setErrorCounter(1);
  5825.         $em->persist($entity);
  5826.         try {
  5827.             $em->flush();
  5828.             return $entity;
  5829.         } catch (\Exception $ex) {
  5830.             return false;
  5831.         }
  5832.     }
  5834.     /**
  5835.      * Funcion en donde se crea el registro en el historico de errores de Android,
  5836.      * en este funcion se registran tanto licencias como sublicencias.
  5837.      * Basada en la función setRegistErrorEmail
  5838.      * @author Jhonan V <jsmith@openmytab.com> 29/10/2021
  5839.      * @param type $license registro de la licencia a la que se va a notificara el error
  5840.      * @param type $mailedTo email al que se el enviara el correo del error
  5841.      * @param type $msgError mensaje de error a notificar
  5842.      * @param type $deviceUid UID del dispositivo que reporta el error
  5843.      * @param type $errorCode codigo que identifica a cada error distinto en el sistema
  5844.      * @param type $subLicense registro de sublicencia a la que se le notificara el error
  5845.      * @return boolean|AndroidErrorsHistory registro de la notificacion del error por email
  5846.      * si se creo exitosamente, de lo contrario retorna un booleano (false)
  5847.      */
  5848.     public function setRegistAndroidError($error, $license, $mailedTo, $msgError, $deviceUid, $subLicense = null) {
  5849.         $em = $this->getDoctrine()->getManager();
  5851.         $entity = new AndroidErrorsHistory();
  5853.         if ($license) {
  5854.             $entity->setLiceseError($license);
  5855.         } else {
  5856.             $entity->setSubLicenseError($subLicense);
  5857.         }
  5859.         $entity->setErrorCode($error);
  5860.         $entity->setEmailRecordStatus(ErrorAndroidEmailSent::STATUS_SERVER_NOTIFIED);
  5861.         $actualDate = Util::getCurrentDate();
  5862.         $entity->setDateErrorReported($actualDate);
  5863.         $entity->setErrorMsg($msgError);
  5864.         $entity->setMailedTo($mailedTo);
  5865.         $entity->setUidErrorDevice($deviceUid);
  5866.                 
  5867.         $em->persist($entity);
  5868.         try {
  5869.             $em->flush();
  5870.             return $entity;
  5871.         } catch (\Exception $ex) {
  5872.             return false;
  5873.         }
  5874.     }
  5876.     /**
  5877.      * Funcion en donde se actualiza el registro de notificacion de error enviado
  5878.      * por email indicando que ya fue enviado dicho correo
  5879.      * @author Aealan Z <lrobledo@kijho.com> 11/06/2016
  5880.      * @param type $errorAndroidEmailRecord registro de notificacion de error
  5881.      * por email
  5882.      * @return boolean booleano que indica si el registro
  5883.      * fue actualizado correctamente
  5884.      */
  5885.     public function updateRegistErrorEmail($errorAndroidEmailRecord) {
  5886.         $em = $this->getDoctrine()->getManager();
  5888.         $errorAndroidEmailRecord->setEmailRecordStatus(ErrorAndroidEmailSent::STATUS_EMAIL_SENT);
  5889.         $actualDate = Util::getCurrentDate();
  5890.         $errorAndroidEmailRecord->setDateErrorEmailSent($actualDate);
  5892.         $em->persist($errorAndroidEmailRecord);
  5893.         try {
  5894.             $em->flush();
  5895.             return $errorAndroidEmailRecord;
  5896.         } catch (\Exception $ex) {
  5897.             return false;
  5898.         }
  5899.     }
  5901.     /**
  5902.      * Funcion en donde se crea el registro de notificacion de log por email
  5903.      * junto con el log adjunto, esta funcion se notifica tanto licencias
  5904.      * como sublicencias
  5905.      * @author Aealan Z <lrobledo@kijho.com> 11/06/2016
  5906.      * @param type $license registro de la licencia a la que se solicito el log
  5907.      * @param type $mailedTo email al que se el enviara el correo con el log
  5908.      * @param type $msgError log del servidor a ser notificado por email
  5909.      * @param type $deviceUid UID del dispositivo al que se le solicita el log
  5910.      * @param type $errorCode codigo unico del log solicitado
  5911.      * @param type $subLicense registro de sublicencia
  5912.      * a la que se le solicito el log
  5913.      * @return boolean|LogAndroidEmailSent registro
  5914.      * de nitificacion de log por correo si este se genero exitosamente,
  5915.      * un booleano (false) de lo contrario
  5916.      */
  5917.     public function setRegistLogEmail($license, $mailedTo, $msgError, $deviceUid, $errorCode, $subLicense = null) {
  5918.         $em = $this->getDoctrine()->getManager();
  5920.         $entity = new LogAndroidEmailSent();
  5922.         if ($license) {
  5923.             $entity->setLiceseLog($license);
  5924.         } else {
  5925.             $entity->setSubLicenseLog($subLicense);
  5926.         }
  5928.         $entity->setEmailRecordStatus(LogAndroidEmailSent::STATUS_SERVER_NOTIFIED);
  5929.         $actualDate = Util::getCurrentDate();
  5930.         $entity->setDateLogAsked($actualDate);
  5931.         $entity->setLogMsg($msgError);
  5932.         $entity->setMailedTo($mailedTo);
  5933.         $entity->setUidLogDevice($deviceUid);
  5934.         $entity->setLogCode($errorCode);
  5936.         $em->persist($entity);
  5937.         try {
  5938.             $em->flush();
  5939.             return $entity;
  5940.         } catch (\Exception $ex) {
  5941.             return false;
  5942.         }
  5943.     }
  5945.     /**
  5946.      * Funcion en donde se actualiza el registro de error notificado por email
  5947.      * , en este funcion se actualiza el registro indicando que se envio
  5948.      * exitosamente el correo con el error
  5949.      * @author Aealan Z <lrobledo@kijho.com> 11/06/2016
  5950.      * @param type $errorAndroidEmailRecord registro del error
  5951.      * notificado por email
  5952.      * @return boolean booleano que indica si se actualizo
  5953.      * el registro correctamente
  5954.      */
  5955.     public function updateRegistLogEmail($errorAndroidEmailRecord) {
  5956.         $em = $this->getDoctrine()->getManager();
  5958.         $errorAndroidEmailRecord->setEmailRecordStatus(LogAndroidEmailSent::STATUS_EMAIL_SENT);
  5959.         $actualDate = Util::getCurrentDate();
  5960.         $errorAndroidEmailRecord->setDateLogEmailSent($actualDate);
  5962.         $em->persist($errorAndroidEmailRecord);
  5963.         try {
  5964.             $em->flush();
  5965.             return $errorAndroidEmailRecord;
  5966.         } catch (\Exception $ex) {
  5967.             return false;
  5968.         }
  5969.     }
  5971.     /**
  5972.      * @author Aealan Z <lrobledo@kijho.com> 29/07/2016
  5973.      * @param type $readFileData
  5974.      * @param type $fileName
  5975.      * @return boolean
  5976.      */
  5977.     public function updateRegistUploadFile($readFileData, $fileName, $fileInS3URI = '') {
  5978.         $em = $this->getDoctrine()->getManager();
  5980.         $masterSyncRecords = $em->getRepository('App\Entity\MasterSync')->findBy(['msSyncRecord' => $readFileData->getId()]);
  5981.         $masterSyncRecords[0]->setMsStatus(MasterSync::MASTER_STATUS_PROCESSED);
  5983.         $readFileData->setRfStatus(ReadFilesData::STATUS_UPLOADED);
  5984.         $readFileData->setRfNameFile($fileName);
  5985.         $actualDate = Util::getCurrentDate();
  5986.         $readFileData->setRfDateUpload($actualDate);
  5987.         $readFileData->setIsReadedByServer(false);
  5989.         if ($fileInS3URI != '') {
  5990.             $readFileData->setFileInS3URI($fileInS3URI);
  5991.         }
  5993.         $em->persist($masterSyncRecords[0]);
  5994.         $em->persist($readFileData);
  5995.         try {
  5996.             $em->flush();
  5997.             return true;
  5998.         } catch (\Exception $ex) {
  5999.             return false;
  6000.         }
  6001.     }
  6003.     /**
  6004.      * Funcion para limpiar el estatus de error en una sincronizacion para
  6005.      * poder reencolarla de nuevo
  6006.      * @author Aealan Z <lrobledo@kijho.com> 11/06/2016
  6007.      * @param type $readFileDataWeb registro de la sincronizacion
  6008.      * web a reencolar
  6009.      * @return boolean booleano que indica si se actualizo
  6010.      * correctamente el registro
  6011.      */
  6012.     public function cleanErrorStatusToRetryWebSync($readFileDataWeb) {
  6013.         $em = $this->getDoctrine()->getManager();
  6015.         $masterSyncRecords = $em->getRepository('App\Entity\MasterSync')->findBy(['msSyncWebRecord' => $readFileDataWeb->getId()]);
  6016.         $masterSyncRecords[0]->setMsHasPersistentError(false);
  6018.         $readFileDataWeb->setHasPersistentError(false);
  6020.         $em->persist($masterSyncRecords[0]);
  6021.         $em->persist($readFileDataWeb);
  6022.         try {
  6023.             $em->flush();
  6024.             return true;
  6025.         } catch (\Exception $ex) {
  6026.             return false;
  6027.         }
  6028.     }
  6030.     /**
  6031.      * Funcion para actualizar el registro de sincronizacion de abajo a arriba
  6032.      * marcandolo como entregado por licensor
  6033.      * @author Aealan Z <lrobledo@kijho.com> 11/06/2016
  6034.      * @param type $readFileData registro de la sincronizacion de abajo
  6035.      * a arriba
  6036.      * @return boolean booleano indicando si se actualizo el registro
  6037.      * correctamente
  6038.      */
  6039.     public function updateRegistDeliveredFile($readFileData) {
  6040.         $em = $this->getDoctrine()->getManager();
  6042.         $masterSyncRecords = $em->getRepository('App\Entity\MasterSync')->findBy(['msSyncRecord' => $readFileData->getId()]);
  6043.         $masterSyncRecords[0]->setMsStatus(MasterSync::MASTER_STATUS_RESPONDED);
  6045.         $readFileData->setRfStatus(ReadFilesData::STATUS_DELIVERED);
  6046.         $actualDate = Util::getCurrentDate();
  6047.         $readFileData->setRfDateDelivered($actualDate);
  6049.         $em->persist($masterSyncRecords[0]);
  6050.         $em->persist($readFileData);
  6051.         try {
  6052.             $em->flush();
  6053.             return true;
  6054.         } catch (\Exception $ex) {
  6055.             return false;
  6056.         }
  6057.     }
  6059.     /**
  6060.      * WS para desbloquear sincronizaciones no terminadas por errores
  6061.      * @author Aealan Z <lrobledo@kijho.com> 11/11/15
  6062.      * @param \Symfony\Component\HttpFoundation\Request $request datos
  6063.      * de la solicitud
  6064.      * @return Response Json con la informacion de respuesta
  6065.      */
  6066.     public function clearBlockedSyncsByLicense(Request $request) {
  6068.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  6070.             if (0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE) || 0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT)) {
  6072.                 $path = Util::getValidActiveLogByBaseName($this->realContainer, 'unblockSyncs', 'unblockSyncs0.txt');
  6073.                 $this->createFileJson($path, 'Clear blocked syncs: ' . $request->getContent() . "\r");
  6075.                 $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  6076.                 $data = json_decode($arrayEncryptResult['data'], true);
  6078.                 if (!isset($data['nickname']) || !isset($data['uid'])) {
  6079.                     return $this->errorWrongArgs('Wrong Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  6080.                 }
  6082.                 $licenseUserName = ['alLicenseUsername' => $data['nickname']];
  6084.                 $em = $this->getDoctrine()->getManager();
  6085.                 $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findBy($licenseUserName);
  6087.                 $countResult = count($accountLicenseData);
  6088.                 if ($countResult > 0) {
  6090.                     if ($accountLicenseData[0]->getDeviceUid() != $data['uid']) {
  6091.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6092.                                         ->respondWithError('Unknown device', WebService::HTTP_CODE_UNAUTHORIZED);
  6093.                     }
  6095.                     $masterSyncRecords = $em->getRepository('App\Entity\MasterSync')->findMastersSyncsInProcessToBlockNewSyncs($accountLicenseData[0]->getId());
  6097.                     if (!empty($masterSyncRecords)) {
  6098.                         foreach ($masterSyncRecords as $masterSync) {
  6099.                             if ($masterSync->getMsType() == MasterSync::MASTER_SYNC_TYPE_DOWUP) {
  6100.                                 $masterSync->setMsStatus(MasterSync::MASTER_STATUS_RESPONDED);
  6101.                                 $downUpSyncRecord = $masterSync->getMsSyncRecord();
  6102.                                 $downUpSyncRecord->setRfStatus(ReadFilesData::STATUS_DELIVERED);
  6103.                             } else {
  6104.                                 $masterSync->setMsStatus(MasterSync::MASTER_STATUS_CLOSED);
  6105.                                 $downUpSyncRecord = $masterSync->getMsSyncWebRecord();
  6106.                                 $downUpSyncRecord->setRfwStatus(ReadFilesDataWeb::STATUS_RESPONSE_READED);
  6107.                             }
  6109.                             $em->persist($downUpSyncRecord);
  6110.                             $em->persist($masterSync);
  6111.                         }
  6113.                         $em->flush();
  6114.                     }
  6116.                     $responseArr['status'] = WebService::CODE_SUCCESS;
  6117.                     $responseArr['msg'] = 'All blocking syncs are closed!';
  6118.                     $responseArr['bigbag'] = false;
  6120.                     $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  6121.                     $xxArray = $theUrlTrSt->transform();
  6123.                     $jsonContent = json_encode($xxArray);
  6125.                     return $this->respondWithItem($jsonContent, $theUrlTrSt);
  6126.                 } else {
  6127.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6128.                                     ->respondWithError('Invalid nickname', WebService::CODE_COULD_NOT_AUTHENTICATE);
  6129.                 }
  6130.             } else {
  6131.                 return $this->errorWrongArgs('Wrong Content!', WebService::CODE_WRONG_ARGUMENTS);
  6132.             }
  6133.         } else {
  6134.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  6135.         }
  6136.     }
  6138.     /**
  6139.      * Funcion para obtener el ultimo error encontrado generico
  6140.      * a la hora de decodificar un json
  6141.      * @author Aealan Z <lrobledo@kijho.com> 11/06/2016
  6142.      * @return string
  6143.      */
  6144.     public function findErrorJsonDecode() {
  6145.         $r = '- No error';
  6146.         switch (json_last_error()) {
  6147.             case JSON_ERROR_NONE:
  6148.                 return $r;
  6149.             case JSON_ERROR_DEPTH:
  6150.                 return ' - Maximum stack depth exceeded';
  6151.             case JSON_ERROR_STATE_MISMATCH:
  6152.                 return ' - Underflow or the modes mismatch';
  6153.             case JSON_ERROR_CTRL_CHAR:
  6154.                 return ' - Unexpected control character found';
  6155.             case JSON_ERROR_SYNTAX:
  6156.                 return ' - Syntax error, malformed JSON';
  6157.             case JSON_ERROR_UTF8:
  6158.                 return ' - Malformed UTF-8 characters, possibly incorrectly encoded';
  6159.             default:
  6160.                 return ' - Unknown error';
  6161.         }
  6162.         return $r;
  6163.     }
  6165.     /**
  6166.      * WS para obtener un listado con todas las sublicencias registradas para
  6167.      * una licencia de tipo call center para que el servidor android les asocie
  6168.      * un dispositivo y las sincronice en licensor
  6169.      * @author Aealan Z <lrobledo@kijho.com> 08/10/15
  6170.      * @param \Symfony\Component\HttpFoundation\Request $request datos
  6171.      * de la solicitud
  6172.      * @return Response Json con la informacion de respuesta
  6173.      */
  6174.     public function getSublicenseByLicense(Request $request) {
  6176.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  6178.             if (0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE) || 0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT)) {
  6180.                 $path = Util::getValidActiveLogByBaseName($this->realContainer, 'demoLogin', 'demoLogin0.txt');
  6181.                 $this->createFileJson($path, 'Login Mobile: ' . $request->getContent() . "\r");
  6183.                 $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  6184.                 $data = json_decode($arrayEncryptResult['data'], true);
  6186.                 if (!isset($data['nickname']) || !isset($data['uid'])) {
  6187.                     return $this->errorWrongArgs('Wrong Arguments!', WebService::CODE_WRONG_ARGUMENTS);
  6188.                 }
  6190.                 $licenseUserName = ['alLicenseUsername' => $data['nickname']];
  6192.                 $em = $this->getDoctrine()->getManager();
  6193.                 $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findByAlLicenseUsername($licenseUserName);
  6195.                 $countResult = count($accountLicenseData);
  6196.                 if ($countResult > 0) {
  6198.                     if (!$accountLicenseData[0]->getIsCallCenter()) {
  6199.                         return $this->errorWrongArgs('Invalid license type!', WebService::CODE_WRONG_ARGUMENTS);
  6200.                     }
  6202.                     if ($accountLicenseData[0]->getDeviceUid() == '' || null == $accountLicenseData[0]->getDeviceUid()) {
  6203.                         $accountLicenseByUID = $em->getRepository('App\Entity\AccountLicense')->findBy(array('deviceUid' => $data['uid']));
  6205.                         if (!empty($accountLicenseByUID)) {
  6206.                             if ($accountLicenseData[0]->getAlLicenseUsername() != $accountLicenseByUID[0]->getAlLicenseUsername()) {
  6207.                                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6208.                                                 ->respondWithError('Device already registed with another license!', WebService::CODE_ACCOUNT_SUSPENDED);
  6209.                             }
  6210.                         }
  6212.                         $accountLicenseData[0]->setDeviceUid($data['uid']);
  6213.                     } else {
  6214.                         if ($accountLicenseData[0]->getDeviceUid() != $data['uid']) {
  6215.                             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6216.                                             ->respondWithError('Unknown device', WebService::CODE_ACCOUNT_SUSPENDED);
  6217.                         }
  6218.                     }
  6220.                     $arraySubLicense = [];
  6221.                     $sublicensesByLicense = $em->getRepository('App\Entity\SubLicense')->findBy(['license' => $accountLicenseData[0]->getId()]);
  6223.                     if (empty($sublicensesByLicense)) {
  6224.                         return $this->errorWrongArgs('No sub-licenses registerede for this license!', WebService::CODE_WRONG_ARGUMENTS);
  6225.                     } else {
  6226.                         foreach ($sublicensesByLicense as $subL) {
  6227.                             $arraySubLicense[] = $subL->getChannelName();
  6228.                         }
  6229.                     }
  6231.                     $em->persist($accountLicenseData[0]);
  6232.                     $em->flush();
  6234.                     $responseArr['status'] = WebService::CODE_SUCCESS;
  6235.                     $responseArr['list'] = json_encode($arraySubLicense);
  6237.                     $theUrlTrSt = new SublicensesListTransformer($this->realContainer, $responseArr);
  6238.                     $xxArray = $theUrlTrSt->transform();
  6240.                     $jsonContent = json_encode($xxArray);
  6242.                     return $this->respondWithItem($jsonContent, $theUrlTrSt);
  6243.                 } else {
  6244.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6245.                                     ->respondWithError('Invalid channel', WebService::CODE_COULD_NOT_AUTHENTICATE);
  6246.                 }
  6247.             } else {
  6248.                 return $this->errorWrongArgs('Wrong Content!', WebService::CODE_WRONG_ARGUMENTS);
  6249.             }
  6250.         } else {
  6251.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  6252.         }
  6253.     }
  6255.     /**
  6256.      * WS para registrar la pushy key del dispositivo de una sublicencia
  6257.      * @author Aealan Z <lrobledo@kijho.com> 03/11/15
  6258.      * @param \Symfony\Component\HttpFoundation\Request $request datos
  6259.      * de la solicitud
  6260.      * @return Response Json con la informacion de respuesta
  6261.      */
  6262.     public function registerPushyKeyToSublicense(Request $request) {
  6264.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  6266.             if (0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE) || 0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT)) {
  6268.                 $path = Util::getValidActiveLogByBaseName($this->realContainer, 'subLRegisterPushy', 'subLRegisterPushy0.txt');
  6269.                 $this->createFileJson($path, 'Request Sub Pushy: ' . $request->getContent() . "\r");
  6271.                 try {
  6272.                     $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  6273.                     $data = json_decode($arrayEncryptResult['data'], true);
  6275.                     $this->createFileJson($path, 'Decrypted: ' . $request->getContent() . "\r");
  6277.                     if (!isset($data['channelname']) || !isset($data['uid']) || !isset($data['pushy'])) {
  6278.                         return $this->errorWrongArgs('Wrong Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  6279.                     }
  6281.                     $em = $this->getDoctrine()->getManager();
  6282.                     $accountLicenseData = $em->getRepository('App\Entity\SubLicense')
  6283.                             ->findBy(['channelName' => $data['channelname']]);
  6284.                     $countResult = count($accountLicenseData);
  6286.                     $this->createFileJson($path, 'Lic Sub Count: ' . $countResult . "\r");
  6288.                     if ($countResult > 0) {
  6290.                         if ($accountLicenseData[0]->getDeviceUid() == '' || null == $accountLicenseData[0]->getDeviceUid()) {
  6291.                             $this->createFileJson($path, 'Into IF 1: ' . "\r");
  6292.                             $accountLicenseByUID = $em->getRepository('App\Entity\SubLicense')->findBy(['deviceUid' => $data['uid']]);
  6294.                             if (!empty($accountLicenseByUID)) {
  6295.                                 $this->createFileJson($path, 'IF 2: cha ' . $accountLicenseData[0]->getChannelName() . ' chaByUID ' . $accountLicenseByUID[0]->getChannelName() . "\r");
  6296.                                 if ($accountLicenseData[0]->getChannelName() != $accountLicenseByUID[0]->getChannelName()) {
  6297.                                     $this->createFileJson($path, 'Error IF 2: ' . "\r");
  6298.                                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6299.                                                     ->respondWithError('Device already registed with another license!', WebService::HTTP_CODE_UNAUTHORIZED);
  6300.                                 }
  6301.                             }
  6303.                             $accountLicenseData[0]->setDeviceUid($data['uid']);
  6304.                         } else {
  6305.                             $this->createFileJson($path, 'IF 3: UID ' . $accountLicenseData[0]->getDeviceUid() . ' requeUID ' . $data['uid'] . "\r");
  6306.                             if ($accountLicenseData[0]->getDeviceUid() != $data['uid']) {
  6307.                                 $this->createFileJson($path, 'Error IF 3: ' . "\r");
  6308.                                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6309.                                                 ->respondWithError('Unknown device', WebService::HTTP_CODE_UNAUTHORIZED);
  6310.                             }
  6311.                         }
  6313.                         if ($accountLicenseData[0]->getPushyKey() == '' || null == $accountLicenseData[0]->getPushyKey()) {
  6314.                             $accountLicenseByPushy = $em->getRepository('App\Entity\SubLicense')->findBy(['pushyKey' => $data['pushy']]);
  6316.                             if (!empty($accountLicenseByPushy)) {
  6317.                                 $this->createFileJson($path, 'IF 4: cha ' . $accountLicenseData[0]->getChannelName() . ' chaPushy ' . $accountLicenseByPushy[0]->getChannelName() . "\r");
  6318.                                 if ($accountLicenseData[0]->getChannelName() != $accountLicenseByPushy[0]->getChannelName()) {
  6319.                                     $this->createFileJson($path, 'Error IF 4: ' . "\r");
  6320.                                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6321.                                                     ->respondWithError('Push key registed with another license!', WebService::HTTP_CODE_UNAUTHORIZED);
  6322.                                 }
  6323.                             }
  6324.                             $accountLicenseData[0]->setPushyKey($data['pushy']);
  6325.                         } else {
  6326.                             $this->createFileJson($path, 'IF 5: Pushy ' . $accountLicenseData[0]->getPushyKey() . ' requePushy ' . $data['pushy'] . "\r");
  6327.                             if ($accountLicenseData[0]->getPushyKey() != $data['pushy']) {
  6328.                                 $this->createFileJson($path, 'Error IF 5: ' . "\r");
  6329.                                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6330.                                                 ->respondWithError('Unknown device', WebService::HTTP_CODE_UNAUTHORIZED);
  6331.                             }
  6332.                         }
  6334.                         $em->persist($accountLicenseData[0]);
  6335.                         $em->flush();
  6337.                         Util::updateAllPushKey([
  6338.                             "nickname"              => $accountLicenseData[0]->getAlLicenseUsername(),
  6339.                             "pushyKey"              => $data['pushy'],
  6340.                             "awsPushEndPoint"       => $accountLicenseData[0]->getAwsPushEndPoint(),
  6341.                             "awsTopicARN"           => $accountLicenseData[0]->getAwsTopicARN(),
  6342.                             "awsSubscriptionARN"    => $accountLicenseData[0]->getAwsSubscriptionARN(),
  6343.                             "awsDeviceToken"        => $accountLicenseData[0]->getAwsDeviceToken(),
  6344.                         ], $this->realContainer);
  6346.                         $em = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData[0]->getLicense());
  6348.                         $remoteStation = $em->getRepository('App\Structure\RemoteStation')->findBy(['parse' => $data['channelname']]);
  6350.                         if (empty($remoteStation)) {
  6351.                             $this->createFileJson($path, 'Error IF 6: ' . "\r");
  6352.                             return $this->setStatusCode(WebService::HTTP_CODE_FORBIDDEN)
  6353.                                             ->respondWithError('Sublicense device record not found!', WebService::CODE_OBJECT_NOT_FOUND);
  6354.                         } else {
  6355.                             $this->createFileJson($path, ':D' . "\r");
  6356.                             $remoteStation[0]->setPushy($data['pushy']);
  6358.                             $registActions = new RegistActions();
  6359.                             $registActions->setReacTableName('remote_stations');
  6360.                             $registActions->setReacTableId($remoteStation[0]->getId());
  6361.                             $registActions->setReacTableAction('U');
  6362.                             $registActions->setReacRegistFk(0);
  6363.                             $registActions->setReacAndroidId($remoteStation[0]->getAndroidSync());
  6365.                             $actualDate = Util::getCurrentDate();
  6367.                             $registActions->setReacDateTime($actualDate);
  6368.                             $registActions->setReacEstatus(RegistActions::STATUS_NOTREADED);
  6370.                             $em->persist($remoteStation[0]);
  6371.                             $em->persist($registActions);
  6373.                             $em->flush();
  6374.                         }
  6376.                         $responseArr['status'] = WebService::CODE_SUCCESS;
  6377.                         $responseArr['msg'] = 'Valid license channel and pushy key registered!';
  6378.                         $responseArr['bigbag'] = false;
  6380.                         $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  6381.                         $xxArray = $theUrlTrSt->transform();
  6383.                         $jsonContent = json_encode($xxArray);
  6385.                         return $this->respondWithItem($jsonContent, $theUrlTrSt);
  6386.                     } else {
  6387.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6388.                                         ->respondWithError('Invalid channel', WebService::CODE_COULD_NOT_AUTHENTICATE);
  6389.                     }
  6390.                 } catch (\Throwable $th) {
  6391.                     $err = ['Error message' => $th->getMessage(), 'Error line' => $th->getLine(), 'Error file' => $th->getFile(), 'Error trance' => $th->getTrace()];
  6392.                     $this->createFileJson($path, 'Alert Error: ' . json_encode($err) . "\r");
  6394.                     return $this->errorWrongArgs('Wrong Content!', WebService::CODE_WRONG_ARGUMENTS);
  6395.                 }
  6396.             } else {
  6397.                 return $this->errorWrongArgs('Wrong Content!', WebService::CODE_WRONG_ARGUMENTS);
  6398.             }
  6399.         } else {
  6400.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  6401.         }
  6402.     }
  6404.     /**
  6405.      * WS para registrar la pushy key de un dispositivo de una licencia
  6406.      * @author Aealan Z <lrobledo@kijho.com> 05/11/15
  6407.      * @param \Symfony\Component\HttpFoundation\Request $request datos
  6408.      * de la solicitud
  6409.      * @return Response Json con la informacion de respuesta
  6410.      */
  6411.     public function registerPushyKeyToLicense(Request $request) {
  6413.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  6415.             if (0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE) || 0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT)) {
  6417.                 $path = Util::getValidActiveLogByBaseName($this->realContainer, 'pushyRegist', 'pushyRegist0.txt');
  6418.                 $this->createFileJson($path, "\r" . 'Register Pushy Key: ' . $request->getContent() . "\r");
  6420.                 try {
  6421.                     $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  6422.                     $data = json_decode($arrayEncryptResult['data'], true);
  6424.                     if (!isset($data['nickname']) || !isset($data['uid']) || !isset($data['pushy'])) {
  6425.                         return $this->errorWrongArgs('Wrong Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  6426.                     }
  6428.                     $this->createFileJson($path, 'Decrypted: ' . $arrayEncryptResult['data'] . "\r");
  6430.                     if ($data['nickname'] == '' || $data['uid'] == '' || $data['pushy'] == '') {
  6431.                         return $this->errorWrongArgs('Empty Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  6432.                     }
  6434.                     $licenseUserName = ['alLicenseUsername' => $data['nickname']];
  6436.                     $em = $this->getDoctrine()->getManager();
  6437.                     $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findBy($licenseUserName);
  6438.                     $countResult = count($accountLicenseData);
  6439.                     
  6440.                     if ($countResult > 0) {
  6441.                         $accountLicenseByPushy = $em->getRepository('App\Entity\AccountLicense')->findBy(['pushyKey' => $data['pushy']]);
  6442.                         // $accountLicenseByPushy = $em->getRepository('App\Entity\AccountLicense')->getLicenseByPushy($data['pushy'], $data['nickname']);
  6444.                         // function internaSaveInRegistAction($container, $em, $license){
  6445.                         //     $emLev = Util::emLicenseConnection($container, $em, $license);
  6447.                         //     $registAction = $emLev->getRepository('App\Structure\RegistActions')->findOneBy(['reacTableName' => 'licensor1', 'reacTableAction' => RegistActions::ACTION_UPDATE, 'reacStatus' => RegistActions::STATUS_NOTREADED]);
  6449.                         //     if(is_null($registAction)){
  6450.                         //         $registAction = new RegistActions();
  6451.                         //         $registAction->setReacTableName('licensor1');
  6452.                         //         $registAction->setReacTableId($license->getId());
  6453.                         //         $registAction->setReacTableAction(RegistActions::ACTION_UPDATE);
  6454.                         //         $registAction->setReacAndroidId($license->getId());
  6456.                         //         $actualDate = Util::getCurrentDate();
  6457.                         //         $registAction->setReacDateTime($actualDate);
  6459.                         //         $emLev->persist($registAction);
  6460.                         //         $emLev->flush();
  6461.                         //     }
  6462.                         // }
  6464.                         if ($accountLicenseData[0]->getPushyKey() == '' || null == $accountLicenseData[0]->getPushyKey()) {
  6465.                             if (!empty($accountLicenseByPushy)) {
  6466.                                 if ($accountLicenseData[0]->getAlLicenseUsername() != $accountLicenseByPushy[0]->getAlLicenseUsername()) {
  6467.                                     $this->createFileJson($path, 'Error: push key registed with -> ' . $accountLicenseByPushy[0]->getAlLicenseUsername() . ' license!' . "\r");
  6468.                                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6469.                                                     ->respondWithError('Push key registed with '.$accountLicenseByPushy[0]->getAlLicenseUsername().' license!', WebService::HTTP_CODE_UNAUTHORIZED);
  6470.                                 }
  6471.                             }
  6473.                             $accountLicenseData[0]->setPushyKey($data['pushy']);
  6475.                             // $this->createFileJson($path, 'New regist action before insert new pushy key '. "\r");
  6476.                             // internaSaveInRegistAction($this->realContainer, $em, $accountLicenseData[0]);
  6477.                         } else {
  6478.                             if ($accountLicenseData[0]->getPushyKey() != $data['pushy']) {
  6479.                                 if (empty($accountLicenseByPushy)) {
  6480.                                     $accountLicenseData[0]->setPushyKey($data['pushy']);
  6481.                                     
  6482.                                     // $this->createFileJson($path, 'New regist action before insert new pushy key '. "\r");
  6483.                                     // internaSaveInRegistAction($this->realContainer, $em, $accountLicenseData[0]);
  6484.                                 } else {
  6485.                                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6486.                                                     ->respondWithError('Unknown device', WebService::HTTP_CODE_UNAUTHORIZED);
  6487.                                 }
  6488.                             }
  6489.                         }
  6491.                         $em->persist($accountLicenseData[0]);
  6492.                         $em->flush();
  6494.                         Util::updateAllPushKey([
  6495.                             "nickname"              => $accountLicenseData[0]->getAlLicenseUsername(),
  6496.                             "pushyKey"              => $data['pushy'],
  6497.                             "awsPushEndPoint"       => $accountLicenseData[0]->getAwsPushEndPoint(),
  6498.                             "awsTopicARN"           => $accountLicenseData[0]->getAwsTopicARN(),
  6499.                             "awsSubscriptionARN"    => $accountLicenseData[0]->getAwsSubscriptionARN(),
  6500.                             "awsDeviceToken"        => $accountLicenseData[0]->getAwsDeviceToken(),
  6501.                         ], $this->realContainer);
  6503.                         $responseArr['status'] = WebService::CODE_SUCCESS;
  6504.                         $responseArr['msg'] = 'Valid license and push key registered!';
  6505.                         $responseArr['bigbag'] = false;
  6507.                         $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  6508.                         $xxArray = $theUrlTrSt->transform();
  6510.                         $jsonContent = json_encode($xxArray);
  6512.                         $this->createFileJson($path, 'Response to Android: ' . $jsonContent . "\r");
  6514.                         return $this->respondWithItem($jsonContent, $theUrlTrSt);
  6515.                     } else {
  6516.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6517.                                         ->respondWithError('Invalid channel', WebService::CODE_COULD_NOT_AUTHENTICATE);
  6518.                     }
  6519.                 } catch (\Throwable $th) {
  6520.                     $err = ['Error message' => $th->getMessage(), 'Error line' => $th->getLine(), 'Error file' => $th->getFile(), 'Error trance' => $th->getTrace()];
  6521.                     $this->createFileJson($path, 'Alert Error: ' . json_encode($err) . "\r");
  6523.                     return $this->errorWrongArgs('Service error, please contact support.', WebService::CODE_WRONG_ARGUMENTS);
  6524.                 }
  6525.             } else {
  6526.                 return $this->errorWrongArgs('Wrong content format, please contact support.', WebService::CODE_WRONG_ARGUMENTS);
  6527.             }
  6528.         } else {
  6529.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  6530.         }
  6531.     }
  6533.     /**
  6534.      * WS para registrar la pushy key de un dispositivo de una licencia
  6535.      * @author Aealan Z <lrobledo@kijho.com> 05/11/15
  6536.      * @param \Symfony\Component\HttpFoundation\Request $request datos
  6537.      * de la solicitud
  6538.      * @return Response Json con la informacion de respuesta
  6539.      */
  6540.     public function createAndSendPusherVerificationPush(Request $request) {
  6542.         // if ($request->getMethod() !== WebService::REQUEST_METHOD_POST) {
  6543.         //     return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  6544.         // }
  6546.         // if (0 !== strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE) && 0 !== strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE)) {
  6547.         //     return $this->errorWrongArgs('Wrong Content!', WebService::CODE_WRONG_ARGUMENTS);
  6548.         // }
  6549.             
  6550.         $response       = false;
  6551.         $statusCode     = 200;
  6552.         $msg = "Valid license and pusher validation push send!";
  6554.         $path = Util::getValidActiveLogByBaseName($this->realContainer, 'createAndSendPusherVerificationPush', 'createAndSendPusherVerificationPush0.txt');
  6555.         $this->createFileJson($path, "\r" . 'Register Pusher Key: ' . $request->getContent() . "\r");
  6557.         $channelName    = $request->get('channel_name');
  6558.         $socketId       = $request->get('socket_id');
  6560.         try {
  6561.             $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  6562.             $data = json_decode($arrayEncryptResult['data'], true);
  6564.             if (!isset($data['nickname']) || !isset($data['uid']) || !isset($socketId) || !isset($channelName)) {
  6565.                 return $this->errorWrongArgs('Wrong Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  6566.             }
  6568.             $this->createFileJson($path, 'Decrypted: ' . $arrayEncryptResult['data'] . "\r");
  6570.             if ($data['nickname'] == '' || $data['uid'] == '' || $socketId == '' || $channelName == '') {
  6571.                 return $this->errorWrongArgs('Empty Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  6572.             }
  6574.             $licenseUserName = ['alLicenseUsername' => $data['nickname']];
  6576.             $em = $this->getDoctrine()->getManager();
  6577.             $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findBy($licenseUserName);
  6579.             $countResult = count($accountLicenseData);
  6580.             if ($countResult <= 0) {
  6581.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6582.                     ->respondWithError('Invalid nickname', WebService::CODE_COULD_NOT_AUTHENTICATE);
  6583.             }
  6585.             if ($accountLicenseData[0]->getDeviceUid() != $data['uid']) {
  6586.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6587.                     ->respondWithError('Wrong device UID', WebService::CODE_COULD_NOT_AUTHENTICATE);
  6588.             }
  6590.             // function internalSaveInRegistAction($container, $em, $license) {
  6591.             //     $emLev = Util::emLicenseConnection($container, $em, $license);
  6593.             //     $registAction = $emLev->getRepository('App\Structure\RegistActions')->findOneBy(['reacTableName' => 'licensor1', 'reacTableAction' => RegistActions::ACTION_UPDATE, 'reacStatus' => RegistActions::STATUS_NOTREADED]);
  6595.             //     if(is_null($registAction)){
  6596.             //         $registAction = new RegistActions();
  6597.             //         $registAction->setReacTableName('licensor1');
  6598.             //         $registAction->setReacTableId($license->getId());
  6599.             //         $registAction->setReacTableAction(RegistActions::ACTION_UPDATE);
  6600.             //         $registAction->setReacAndroidId($license->getId());
  6602.             //         $actualDate = Util::getCurrentDate();
  6603.             //         $registAction->setReacDateTime($actualDate);
  6605.             //         $emLev->persist($registAction);
  6606.             //         $emLev->flush();
  6607.             //     }
  6608.             // }
  6610.             if($channelName === 'presence-'.$data['nickname']){
  6611.                 if(strpos($channelName, 'presence-') !== false) {
  6612.                     $user = array(
  6613.                         "user_id" => $data['uid'],
  6614.                         "user_info" => [
  6615.                             "name" => $data['nickname']
  6616.                         ]
  6617.                     );
  6619.                     $ownAPIsKeys = $em->getRepository('App\Entity\ThirdPartyAPIRecords')->getOwnPushServicesByLicense($accountLicenseData[0]->getId(), ThirdPartyAPIRecords::API_PUSHER);
  6621.                     if (!empty($ownAPIsKeys)) {
  6622.                         $pusher = new PusherManager($ownAPIsKeys[ThirdPartyAPIRecords::API_PUSHER]);
  6623.                     } else {
  6624.                         $pusher = new PusherManager();
  6625.                     }
  6627.                     $response = $pusher->authorizeChannel($channelName, $socketId, $user);
  6629.                     if(!empty($response)){
  6631.                         $newPusherTokenCallResult = NewUtil::generateNewPusherVerificationToken($this->realContainer, $em, $accountLicenseData[0], $path);
  6633.                         if (is_string($newPusherTokenCallResult)) {
  6634.                             $this->createFileJson($path, 'Error creating new pusher token -> ' . $newPusherTokenCallResult . "\r");
  6635.                         } else {
  6636.                             $msg = 'New pusher token created!';
  6637.                             $statusCode     = 200;
  6638.                             $this->createFileJson($path, 'New pusher token created!'. "\r");
  6639.                         }
  6641.                         $pushWithSameKey = true;
  6642.                         $thePushKey = false;
  6643.         
  6644.                         while (!empty($pushWithSameKey)) {
  6645.                             $thePushKey = Util::randomPushKey();
  6646.                             $pushWithSameKey = $em->getRepository('App\Entity\PushSent')->searchPushSendRecords($thePushKey);
  6647.                         }
  6648.         
  6649.                         $pushEntity = new PushSent();
  6650.         
  6651.                         $pushVerificationCode = Util::createRegistPushSend($em, $pushEntity, PushSent::PUSH_TYPE_COMFIRM_PUSHER_LICENSE_CHANNEL, $thePushKey, $accountLicenseData[0], true, false, $path);
  6652.         
  6653.                         $response = json_decode($response, true);
  6654.                         $token["actions"] = 'ping';
  6655.                         $token["nickname"] = $accountLicenseData[0]->getAlLicenseUsername();
  6656.                         $token["pusherToken"] = $accountLicenseData[0]->getPusherOwnVerificationToken();
  6657.         
  6658.                         if ($pushVerificationCode && $pushVerificationCode != '') {
  6659.                             $this->createFileJson($path, 'Push send record created!' . "\r");
  6660.                             $token["code"] = $pushVerificationCode;
  6661.                         }
  6662.                         // $response['verify'] = $token;
  6663.                         ForcedAsynchronousCommandsUtil::sendPusherPushNotification($this->realContainer,  'presence-'.$accountLicenseData[0]->getAlLicenseUsername(), $token, 0, $path, true);
  6664.                         $em->persist($accountLicenseData[0]);
  6665.                         $em->flush();
  6666.                     }else {
  6667.                         $msg = "Not authorized channel!";
  6668.                         $statusCode     = 403;
  6669.                         throw new Exception('Not authorized channel! 1');
  6670.                     }
  6671.                 } else {
  6672.                     $msg = "Not authorized channel!";
  6673.                     $statusCode     = 403;
  6674.                     throw new Exception('Not authorized channel! 2');
  6675.                 }
  6676.             }else {
  6677.                 $msg = "Not authorized channel!";
  6678.                 $statusCode     = 403;
  6679.                 throw new Exception('Not authorized channel! 3');
  6680.             }
  6682.             // return $this->respondWithItem($jsonContent, $theUrlTrSt);
  6684.             return new JsonResponse($response, $statusCode);
  6685.         } catch (\Throwable $th) {
  6686.             $err = ['Error message' => $th->getMessage(), 'Error line' => $th->getLine(), 'Error file' => $th->getFile(), 'Error trance' => $th->getTrace()];
  6687.             $this->createFileJson($path, 'Alert Error: ' . json_encode($err) . "\r");
  6689.             return $this->errorWrongArgs('Wrong Content!', WebService::CODE_WRONG_ARGUMENTS);
  6690.         }
  6691.     }
  6693.     /**
  6694.      * WS para registrar el device token de una licencia para los push de AWS
  6695.      * @author Aealan Z <lrobledo@openmytab.com> 21/10/22
  6696.      * @param \Symfony\Component\HttpFoundation\Request $request datos
  6697.      * de la solicitud
  6698.      * @return Response Json con la informacion de respuesta
  6699.      */
  6700.     public function registerAWSDeviceTokenToPushService(Request $request) {
  6702.         if ($request->getMethod() !== WebService::REQUEST_METHOD_POST) {
  6703.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  6704.         }
  6706.         if (0 !== strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE) && 0 !== strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT)) {
  6707.             return $this->errorWrongArgs('Wrong Content!', WebService::CODE_WRONG_ARGUMENTS);
  6708.         }
  6710.         $path = Util::getValidActiveLogByBaseName($this->realContainer, 'registerAWSDeviceTokenToPushService', 'registerAWSDeviceTokenToPushService0.txt');
  6711.         $this->createFileJson($path, "\r" . 'Register AWS Device Token: ' . $request->getContent() . "\r");
  6713.         $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  6714.         $data = json_decode($arrayEncryptResult['data'], true);
  6716.         if (!isset($data['nickname']) || !isset($data['uid']) || !isset($data['deviceToken'])) {
  6717.             return $this->errorWrongArgs('Wrong Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  6718.         }
  6720.         $this->createFileJson($path, 'Decrypted: ' . $arrayEncryptResult['data'] . "\r");
  6722.         if ($data['nickname'] == '' || $data['uid'] == '' || $data['deviceToken'] == '') {
  6723.             return $this->errorWrongArgs('Empty Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  6724.         }
  6726.         $licenseUserName = ['alLicenseUsername' => $data['nickname']];
  6728.         $em = $this->getDoctrine()->getManager();
  6729.         $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findBy($licenseUserName);
  6731.         $countResult = count($accountLicenseData);
  6733.         if ($countResult <= 0) {
  6734.             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6735.                             ->respondWithError('Invalid nickname', WebService::CODE_COULD_NOT_AUTHENTICATE);
  6736.         }
  6738.         $accountLicenseByPushy = $em->getRepository('App\Entity\AccountLicense')->findBy(['awsDeviceToken' => $data['deviceToken']]);
  6740.         if ($accountLicenseData[0]->getPushyKey() == '' || null == $accountLicenseData[0]->getPushyKey()) {
  6741.             if (!empty($accountLicenseByPushy)) {
  6742.                 if ($accountLicenseData[0]->getAlLicenseUsername() != $accountLicenseByPushy[0]->getAlLicenseUsername()) {
  6743.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6744.                                     ->respondWithError('DeviceToken registed with another license!', WebService::HTTP_CODE_UNAUTHORIZED);
  6745.                 }
  6746.             }
  6748.             $accountLicenseData[0]->setAwsDeviceToken($data['deviceToken']);
  6749.         } else {
  6750.             if ($accountLicenseData[0]->getAwsDeviceToken() != $data['deviceToken']) {
  6751.                 if (empty($accountLicenseByPushy)) {
  6752.                     $accountLicenseData[0]->setAwsDeviceToken($data['deviceToken']);
  6753.                 } else {
  6754.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6755.                                     ->respondWithError('Unknown device', WebService::HTTP_CODE_UNAUTHORIZED);
  6756.                 }
  6757.             }
  6758.         }
  6760.         if (!$accountLicenseData[0]->getAwsTopicARN()) {
  6761.             $creationTopicARNResult = NewUtil::registerAlternateNewDeviceToAWSSNSPushService($this->realContainer, $em, $accountLicenseData[0], $data['deviceToken'], $path);
  6762.             $this->createFileJson($path, 'Creation of TopicARN result: ' . json_encode($creationTopicARNResult) . "\r");
  6763.         }
  6765.         $arrayResult = NewUtil::registerAlternateCreateAppEndpointForDeviceSNSPushService($this->realContainer, $em, $accountLicenseData[0], $data['deviceToken'], $path);
  6767.         if (is_array($arrayResult) && isset($arrayResult['licenseEntity'])) {
  6768.             $accountLicenseData[0] = $arrayResult['licenseEntity'];
  6769.         }
  6771.         if (is_array($arrayResult) && isset($arrayResult['EndpointArn'])) {
  6772.             $responseArr['endpointArn'] = $arrayResult['EndpointArn'];
  6773.         } else {
  6774.             $responseArr['endpointArn'] = $arrayResult;
  6775.         }
  6777.         $arraySecondResult = NewUtil::registerAlternateSubscriptionToTopicForDeviceSNSPushService($this->realContainer, $em, $accountLicenseData[0], $path);
  6779.         if (is_array($arraySecondResult) && isset($arraySecondResult['SubscriptionArn'])) {
  6780.             $responseArr['subscriptionArn'] = $arraySecondResult['SubscriptionArn'];
  6781.         } else {
  6782.             $responseArr['subscriptionArn'] = $arraySecondResult;
  6783.         }
  6785.         $responseArr['status'] = WebService::CODE_SUCCESS;
  6786.         $responseArr['msg'] = "Valid license and AWS token registered with it's endpoint and topic subscription!";
  6787.         $responseArr['topicArn'] = $accountLicenseData[0]->getAwsTopicARN();
  6788.         $responseArr['bigbag'] = true;
  6789.                 
  6790.         Util::updateAllPushKey([
  6791.             "nickname"              => $accountLicenseData[0]->getAlLicenseUsername(),
  6792.             "awsPushEndPoint"       => $accountLicenseData[0]->getAwsPushEndPoint(),
  6793.             "awsTopicARN"           => $accountLicenseData[0]->getAwsTopicARN(),
  6794.             "awsSubscriptionARN"    => $accountLicenseData[0]->getAwsSubscriptionARN(),
  6795.             "awsDeviceToken"        => $accountLicenseData[0]->getAwsDeviceToken(),
  6796.         ], $this->realContainer);
  6798.         $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  6799.         $xxArray = $theUrlTrSt->transform();
  6801.         $jsonContent = json_encode($xxArray);
  6803.         return $this->respondWithItem($jsonContent, $theUrlTrSt);
  6804.     }
  6806.     /**
  6807.      * WS para registrar la pushy key de un dispositivo de una licencia
  6808.      * @author Aealan Z <lrobledo@kijho.com> 05/11/15
  6809.      * @param \Symfony\Component\HttpFoundation\Request $request datos
  6810.      * de la solicitud
  6811.      * @return Response Json con la informacion de respuesta
  6812.      */
  6813.     public function registerCodeInstallToLicense(Request $request) {
  6815.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  6817.             if (0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE) || 0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT)) {
  6819.                 $path = Util::getValidActiveLogByBaseName($this->realContainer, 'codeInstallRegist', 'codeInstallRegist0.txt');
  6820.                 $this->createFileJson($path, "\r" . 'Register Code Install: ' . $request->getContent() . "\r");
  6822.                 $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  6823.                 $data = json_decode($arrayEncryptResult['data'], true);
  6825.                 if (!isset($data['nickname']) || !isset($data['uid']) || !isset($data['codeInstall'])) {
  6826.                     return $this->errorWrongArgs('Wrong Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  6827.                 }
  6829.                 $this->createFileJson($path, 'Decrypted: ' . $arrayEncryptResult['data'] . "\r");
  6831.                 if ($data['nickname'] == '' || $data['uid'] == '' || $data['codeInstall'] == '') {
  6832.                     return $this->errorWrongArgs('Empty Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  6833.                 }
  6835.                 $licenseUserName = ['alLicenseUsername' => $data['nickname']];
  6837.                 $em = $this->getDoctrine()->getManager();
  6838.                 $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findBy($licenseUserName);
  6840.                 $countResult = count($accountLicenseData);
  6841.                 if ($countResult > 0) {
  6842.                     if ($accountLicenseData[0]->getAlAccountLicense()->getDeleted()) {
  6843.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6844.                                         ->respondWithError('Account is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  6845.                     }
  6847.                     if ($accountLicenseData[0]->getAlLicenseStatus() != AccountLicense::LICENSE_STATUS_ACTIVE) {
  6848.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6849.                                         ->respondWithError('License is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  6850.                     }
  6852.                     $accountLicenseData[0]->setApkInstallCode($data['codeInstall']);
  6854.                     $em->persist($accountLicenseData[0]);
  6855.                     $em->flush();
  6857.                     $responseArr['status'] = WebService::CODE_SUCCESS;
  6858.                     $responseArr['msg'] = 'Code install registered!';
  6859.                     $responseArr['bigbag'] = false;
  6861.                     $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  6862.                     $xxArray = $theUrlTrSt->transform();
  6864.                     $jsonContent = json_encode($xxArray);
  6866.                     return $this->respondWithItem($jsonContent, $theUrlTrSt);
  6867.                 } else {
  6868.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6869.                                     ->respondWithError('Invalid channel', WebService::CODE_COULD_NOT_AUTHENTICATE);
  6870.                 }
  6871.             } else {
  6872.                 return $this->errorWrongArgs('Wrong Content!', WebService::CODE_WRONG_ARGUMENTS);
  6873.             }
  6874.         } else {
  6875.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  6876.         }
  6877.     }
  6879.     /**
  6880.      * WS para registrar la pushy key de un dispositivo de una licencia
  6881.      * @author Aealan Z <lrobledo@kijho.com> 05/11/15
  6882.      * @param \Symfony\Component\HttpFoundation\Request $request datos
  6883.      * de la solicitud
  6884.      * @return Response Json con la informacion de respuesta
  6885.      */
  6886.     public function notifyFattyAndroidDatabase(Request $request) {
  6888.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  6890.             if (0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE) || 0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT)) {
  6892.                 $path = Util::getValidActiveLogByBaseName($this->realContainer, 'notifyFattyAndroidDatabase', 'notifyFattyAndroidDatabase0.txt');
  6893.                 $this->createFileJson($path, "\r" . 'Notify Fatty Android Database: ' . $request->getContent() . "\r");
  6895.                 $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  6896.                 $data = json_decode($arrayEncryptResult['data'], true);
  6898.                 if (!isset($data['nickname']) || !isset($data['uid'])) {
  6899.                     return $this->errorWrongArgs('Wrong Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  6900.                 }
  6902.                 $this->createFileJson($path, 'Decrypted: ' . $arrayEncryptResult['data'] . "\r");
  6904.                 if ($data['nickname'] == '' || $data['uid'] == '') {
  6905.                     return $this->errorWrongArgs('Empty Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  6906.                 }
  6908.                 $licenseUserName = ['alLicenseUsername' => $data['nickname']];
  6910.                 $em = $this->getDoctrine()->getManager();
  6911.                 $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findBy($licenseUserName);
  6913.                 $countResult = count($accountLicenseData);
  6914.                 if ($countResult > 0) {
  6915.                     if ($accountLicenseData[0]->getAlAccountLicense()->getDeleted()) {
  6916.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6917.                                         ->respondWithError('Account is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  6918.                     }
  6920.                     if ($accountLicenseData[0]->getAlLicenseStatus() != AccountLicense::LICENSE_STATUS_ACTIVE) {
  6921.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6922.                                         ->respondWithError('License is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  6923.                     }
  6925.                     if (isset($data['days']) && ((int) $data['days']) > 0) {
  6926.                         $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData[0]);
  6928.                         $configurationLicenseRecord = $emLev->getRepository('App\Structure\Configuracion')->find(1);
  6930.                         $configurationLicenseRecord->setConfAllowAutoCleanseDB(1);
  6931.                         $configurationLicenseRecord->setConfDataSinceLastDays((int) $data['days']);
  6933.                         $emLev->persist($configurationLicenseRecord);
  6934.                         $emLev->flush();
  6936.                         $this->createFileJson($path, "Auto cleanse configured with '" . $data['days'] . "' ... \r");
  6937.                     }
  6939.                     $this->createFileJson($path, 'Ready for new cleanse request to be done!' . "\r");
  6941.                     $msg = [
  6942.                         'license' => $accountLicenseData[0]->getId()
  6943.                     ];
  6945.                     $this->get('cleanse_for_fatty_android_database_producer')->setContentType('application/json');
  6946.                     $this->get('cleanse_for_fatty_android_database_producer')->setDeliveryMode(2);
  6947.                     $this->get('cleanse_for_fatty_android_database_producer')->publish(json_encode($msg));
  6949.                     $this->createFileJson($path, 'Rabbit produces message sended!' . "\r");
  6951.                     $data['rabbit_consumer'] = 'old_sound_rabbit_mq.operate_fatty_android_database_task_consumer';
  6952.                     $data['rabbit_queue'] = 'operate_fatty_android_database';
  6953.                     sleep(3);
  6954.                     ForcedAsynchronousCommandsUtil::callTheBizarreGenericConsumerCommand($this->realContainer, $data, true);
  6956.                     $this->createFileJson($path, 'Rabbit async consumer request sended!' . "\r");
  6958.                     $responseArr['status'] = WebService::CODE_SUCCESS;
  6959.                     $responseArr['msg'] = "Cleanse database proccess started for '<strong>$accountLicenseData[0]</strong>' license!";
  6960.                     $responseArr['bigbag'] = false;
  6962.                     $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  6963.                     $xxArray = $theUrlTrSt->transform();
  6965.                     $jsonContent = json_encode($xxArray);
  6967.                     return $this->respondWithItem($jsonContent, $theUrlTrSt);
  6968.                 } else {
  6969.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  6970.                                     ->respondWithError('Invalid nickname.', WebService::CODE_COULD_NOT_AUTHENTICATE);
  6971.                 }
  6972.             } else {
  6973.                 return $this->errorWrongArgs('Wrong Content!', WebService::CODE_WRONG_ARGUMENTS);
  6974.             }
  6975.         } else {
  6976.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  6977.         }
  6978.     }
  6980.     /**
  6981.      * WS para registrar la pushy key de un dispositivo de una licencia
  6982.      * @author Aealan Z <lrobledo@kijho.com> 05/11/15
  6983.      * @param \Symfony\Component\HttpFoundation\Request $request datos
  6984.      * de la solicitud
  6985.      * @return Response Json con la informacion de respuesta
  6986.      */
  6987.     public function experimentalAuthWS(Request $request) {
  6989.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  6991.             if (0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE) || 0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT)) {
  6993.                 $path = Util::getValidActiveLogByBaseName($this->realContainer, 'experimentalAuthWS', 'experimentalAuthWS0.txt');
  6994.                 $this->createFileJson($path, "\r" . 'Experimental ecurity WS: ' . $request->getContent() . "\r");
  6996.                 $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  6997.                 $data = json_decode($arrayEncryptResult['data'], true);
  6999.                 if (!isset($data['nickname']) || !isset($data['uid']) || !isset($data['authCode'])) {
  7000.                     return $this->errorWrongArgs('Wrong Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  7001.                 }
  7003.                 $this->createFileJson($path, 'Decrypted: ' . $arrayEncryptResult['data'] . "\r");
  7005.                 if ($data['nickname'] == '' || $data['uid'] == '' || $data['authCode'] == '') {
  7006.                     return $this->errorWrongArgs('Empty Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  7007.                 }
  7009.                 $licenseUserName = ['alLicenseUsername' => $data['nickname']];
  7011.                 $em = $this->getDoctrine()->getManager();
  7012.                 $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findBy($licenseUserName);
  7014.                 $countResult = count($accountLicenseData);
  7015.                 if ($countResult > 0) {
  7016.                     if ($accountLicenseData[0]->getAlAccountLicense()->getDeleted()) {
  7017.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  7018.                                         ->respondWithError('Account is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  7019.                     }
  7021.                     if ($accountLicenseData[0]->getAlLicenseStatus() != AccountLicense::LICENSE_STATUS_ACTIVE) {
  7022.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  7023.                                         ->respondWithError('License is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  7024.                     }
  7026. //                    if (isset($data['authCode'])) {
  7027. //                        $google2fa = new Google2FA();
  7028. //                        $secret = $accountLicenseData[0]->getAuthSeed();
  7029. //                        $wasValid = $google2fa->verifyKey($secret, $data['authCode'], 10);
  7030. //
  7031. //                        if (!$wasValid) {
  7032. //                            return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  7033. //                                            ->respondWithError('Invalid authorization', WebService::CODE_INVALID_SECURITY_HASH);
  7034. //                        } else {
  7035. //                            $responseArr['msg'] = 'Code verified and pass!';
  7036. //                            $this->createFileJson($path, 'Experimental ecurity WS: Good code ;) ' . "\r");
  7037. //                        }
  7038. //                    } else {
  7039. //                        $responseArr['msg'] = 'Code without code verification...';
  7040. //                    }
  7042.                     $authResult = $this->validateAuth($accountLicenseData[0], $data);
  7044.                     if (is_string($authResult)) {
  7045.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  7046.                                         ->respondWithError($authResult, WebService::CODE_INVALID_SECURITY_HASH);
  7047.                     }
  7049.                     $responseArr['status'] = WebService::CODE_SUCCESS;
  7050.                     $responseArr['msg'] = 'Code verified and pass!';
  7051.                     $responseArr['bigbag'] = false;
  7053.                     $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  7054.                     $xxArray = $theUrlTrSt->transform();
  7056.                     $jsonContent = json_encode($xxArray);
  7058.                     return $this->respondWithItem($jsonContent, $theUrlTrSt);
  7059.                 } else {
  7060.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  7061.                                     ->respondWithError('Invalid nickname', WebService::CODE_COULD_NOT_AUTHENTICATE);
  7062.                 }
  7063.             } else {
  7064.                 return $this->errorWrongArgs('Wrong content', WebService::CODE_WRONG_ARGUMENTS);
  7065.             }
  7066.         } else {
  7067.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  7068.         }
  7069.     }
  7071.     /**
  7072.      * Esta funcion permite al cliente adroid notificar que termino de
  7073.      * subir el archivo de sincronizacion
  7074.      * @author Aealan Z <lrobledo@kijho.com> 30/04/15
  7075.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  7076.      * @return Response Json con la informacion de respuesta
  7077.      */
  7078.     public function uploadSyncServiceUrlAlternate(Request $request) {
  7080.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  7082.             $arrayRequestEncripted = [];
  7083.             $arrayRequestEncripted['nickname'] = $request->request->get('nickname');
  7084.             $arrayRequestEncripted['uid'] = $request->request->get('uid');
  7086.             $path = Util::getValidActiveLogByBaseName($this->realContainer, 'syncDownUpWSTest', 'syncDownUpWSTest0.txt');
  7087.             $this->createFileJson($path, "\r" . 'The request ' . json_encode($arrayRequestEncripted) . "\r");
  7089.             $parameters = $request->request->all();
  7091. //            $this->createFileJson($path, 'All parameters in request -> ' . json_encode($parameters) . "\r");
  7093.             $text = 'Hola Changoo!!';
  7095.             $file = fopen($path, "a+");
  7096.             fwrite($file, $text);
  7097.             fclose($file);
  7099.             dump($path);
  7100.             dump($text);
  7101.             die;
  7103.             $data = [];
  7104.             $arrayEncryptResult = Util::decryptDataForUploadsFiles($this->realContainer, $request->request->get('nickname'));
  7105.             $data['nickname'] = $arrayEncryptResult['data'];
  7107.             $arrayEncryptResult = Util::decryptDataForUploadsFiles($this->realContainer, $request->request->get('uid'));
  7108.             $data['uid'] = $arrayEncryptResult['data'];
  7110.             $this->createFileJson($path, 'Decripted ' . json_encode($data) . "\r");
  7112.             $theTrueNameFile = $request->files->get('file')->getClientOriginalName();
  7113.             $this->createFileJson($path, 'The Client IP -> ' . $request->getClientIp() . "\r");
  7114.             $this->createFileJson($path, 'The File -> ' . $theTrueNameFile . "\r");
  7116.             $licenseUserName = ['alLicenseUsername' => $data['nickname']];
  7118.             $em = $this->getDoctrine()->getManager();
  7119.             $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findByAlLicenseUsername($licenseUserName);
  7121.             $forcedValidationPassed = false;
  7123.             if (empty($accountLicenseData) && (null == $data['nickname'] ||
  7124.                     empty($data['nickname']) || $data['nickname'] == 'null') &&
  7125.                     (int) $this->realContainer->getParameter('device_recognition_by_ip_enabled') &&
  7126.                     !empty($theTrueNameFile) && $theTrueNameFile != '') {
  7127.                 $this->createFileJson($path, 'Forcing server android autentication... ' . "\r");
  7128.                 $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findBy(['androidIP' => $request->getClientIp()]);
  7130.                 if (empty($accountLicenseData) || (int) $accountLicenseData[0]->getTimesCheckedIP() < (int) $this->realContainer->getParameter('ip_recognition_times_to_valid_check')) {
  7131.                     $accountLicenseData = [];
  7132.                 } else {
  7133.                     $forcedValidationPassed = true;
  7134.                     $this->createFileJson($path, 'Forced autentication succeeded! ' . "\r");
  7135.                 }
  7136.             }
  7138.             $countResult = count($accountLicenseData);
  7140.             $statusArryMsg['status'] = WebService::CODE_OK_ACCEPTED;
  7142.             $this->createFileJson($path, 'Number of license found -> ' . $countResult . "\r");
  7144.             if ($countResult > 0) {
  7145.                 if ($accountLicenseData[0]->getAlAccountLicense()->getDeleted()) {
  7146.                     $this->createFileJson($path, 'Salio 1! ' . "\r");
  7147.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  7148.                                     ->respondWithError('Account is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  7149.                 }
  7151.                 if (!$forcedValidationPassed && $accountLicenseData[0]->getDeviceUid() != $data['uid']) {
  7152.                     $this->createFileJson($path, 'Salio 2! ' . "\r");
  7153.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  7154.                                     ->respondWithError('Unknown device', WebService::CODE_ACCOUNT_SUSPENDED);
  7155.                 }
  7157.                 if ($accountLicenseData[0]->getAlLicenseStatus() == AccountLicense::LICENSE_STATUS_ACTIVE) {
  7159.                     $this->createFileJson($path, 'License active! ' . "\r");
  7161. //                    $masterBlockingByDBUpdate = $em->getRepository('App\Entity\MasterSync')->findBy(['msLicense' => $accountLicenseData[0]->getId(), 'msType' => MasterSync::MASTER_SYNC_TYPE_DB_UPDATE, 'msStatus' => MasterSync::MASTER_STATUS_INITIALIZATED]);
  7162. //
  7163. //                    if (!empty($masterBlockingByDBUpdate)) {
  7164. //                        $this->createFileJson($path, 'Se Fue DB blocked!' . "\r");
  7165. //                        return $this->setStatusCode(WebService::CODE_OBJECT_NOT_FOUND)
  7166. //                                        ->respondWithError('Synchronization blocked by DB update, please wait...', WebService::NOTHING_TO_WEB_SYNCHRONIZE);
  7167. //                    }
  7169.                     $readFilesDataEntity = $em->getRepository('App\Entity\ReadFilesData')->findBy(['rfStatus' => ReadFilesData::STATUS_UPLOADED, 'rfLicenseId' => $accountLicenseData[0]->getId(), 'hasPersistentError' => false]);
  7171.                     if (!empty($readFilesDataEntity)) {
  7172.                         $this->createFileJson($path, 'There is another sync petition in process, please wait until is finished' . "\r");
  7173.                         $statusArryMsg['msg'] = 'There is another sync petition in process, please wait until is finished';
  7175.                         $theUrlTrSt = new UploadSyncJsonNotifyTransformer($this->realContainer, $statusArryMsg);
  7176.                         $jsonTransform = $theUrlTrSt->transform();
  7177.                         $jsonContent = json_encode($jsonTransform);
  7179.                         return $this->respondWithItem($jsonContent, $theUrlTrSt);
  7180.                     }
  7182.                     $readFilesDataEntity = $em->getRepository('App\Entity\ReadFilesData')->findBy(['rfStatus' => ReadFilesData::STATUS_UPLOADED, 'rfLicenseId' => $accountLicenseData[0]->getId(), 'hasPersistentError' => true]);
  7184.                     if (!empty($readFilesDataEntity)) {
  7185.                         $this->createFileJson($path, 'There is another sync petition for this license with a problem in the sever, please contact your system supplier for more information' . "\r");
  7186.                         $statusArryMsg['msg'] = 'There is another sync petition for this license with a problem in the sever, please contact your system supplier for more information';
  7188.                         $theUrlTrSt = new UploadSyncJsonNotifyTransformer($this->realContainer, $statusArryMsg);
  7189.                         $jsonTransform = $theUrlTrSt->transform();
  7190.                         $jsonContent = json_encode($jsonTransform);
  7192.                         return $this->respondWithItem($jsonContent, $theUrlTrSt);
  7193.                     }
  7195.                     $isDirectoryReady = Util::createLicenseDirectory($this->realContainer, $accountLicenseData[0], $accountLicenseData[0]->getAlLicenseUsername());
  7196.                     $theAccountLicenseDirector = $isDirectoryReady['directory'];
  7198.                     if (!isset($isDirectoryReady['result']) || $isDirectoryReady['result'] == '__KO__') {
  7199.                         $msnError = 'An error occurred while creating your directory in server ';
  7200.                         return $this->setStatusCode(WebService::CODE_INTERNAL_ERROR)
  7201.                                         ->respondWithError($msnError, WebService::CODE_INTERNAL_ERROR);
  7202.                     }
  7204.                     $this->createFileJson($path, 'The license dir ' . $theAccountLicenseDirector . "\r");
  7205.                     $uploadFileResponse = Utilx::uploadFileTo($request, $theAccountLicenseDirector, $path);
  7207.                     dump($uploadFileResponse);
  7208.                     die;
  7209.                     ///////////////////
  7210.                     ///////////////////
  7212.                     if (!isset($uploadFileResponse['result']) || !isset($uploadFileResponse['msg'])) {
  7213.                         $this->createFileJson($path, 'Unknown error uploading file ' . "\r");
  7214.                         return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)
  7215.                                         ->respondWithError('Unknown error uploading file', WebService::CODE_INTERNAL_ERROR);
  7216.                     }
  7218.                     if (isset($uploadFileResponse['result']) && isset($uploadFileResponse['msg']) && $uploadFileResponse['result'] == '__KO__') {
  7219.                         $this->createFileJson($path, $uploadFileResponse['msg'] . "\r");
  7220.                         return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)
  7221.                                         ->respondWithError($uploadFileResponse['msg'], WebService::CODE_INTERNAL_ERROR);
  7222.                     }
  7224.                     $readFilesDataEntityByLicense = $em->getRepository('App\Entity\ReadFilesData')->findBy(['rfLicenseId' => $accountLicenseData[0]->getId(), 'rfStatus' => ReadFilesData::STATUS_STANDBY], ['rfDateSincAsk' => 'DESC']);
  7226.                     $this->createFileJson($path, 'The ReadFilesData count 1 -> ' . count($readFilesDataEntityByLicense) . "\r");
  7228.                     if (empty($readFilesDataEntityByLicense)) {
  7229.                         $readFilesDataEntityByLicense[0] = $this->setRegistNewFile($accountLicenseData[0]);
  7230.                     }
  7232.                     $registerStatus = $this->updateRegistUploadFile($readFilesDataEntityByLicense[0], $uploadFileResponse['fileName']);
  7234.                     if ($registerStatus) {
  7235.                         $statusArryMsg['msg'] = 'File has been uploaded and the record updated';
  7236.                         $this->createFileJson($path, 'File has been uploaded and the record updated' . "\r");
  7237.                     } else {
  7238.                         $this->createFileJson($path, 'Salio 9! ' . "\r");
  7239.                         return $this->setStatusCode(WebService::HTTP_CODE_NOT_FOUND)
  7240.                                         ->respondWithError('Error updating syncronization control record', WebService::CODE_OBJECT_NOT_FOUND);
  7241.                     }
  7243.                     $licenseDataBaseEntity = $em->getRepository('App\Entity\LicenseDataBase')->findBy(['license' => $accountLicenseData[0]->getId()]);
  7245.                     if (!empty($licenseDataBaseEntity)) {
  7247.                         $pushSendRepository = $em->getRepository('App\Entity\PushSent');
  7248.                         $pushSendRepository->respondOldPushesForLicense(PushSent::PUSH_TYPE_SYNC_DOWNUP, $accountLicenseData[0]->getId());
  7250.                         $usernameByNickname = $licenseDataBaseEntity[0]->getLicense();
  7251.                         $theAccountPath = $this->realContainer->getParameter('level_directory_data_android') . $usernameByNickname->getAlAccountLicense()->getAcName() . '/' . $usernameByNickname->getAlLicenseUsername();
  7252.                         $theAccountPath = str_replace(' ', '_', $theAccountPath);
  7254.                         $dataOptionsRoot = [
  7255.                             'dbname' => $licenseDataBaseEntity[0]->getDbname(),
  7256.                             'user' => $licenseDataBaseEntity[0]->getDbuser(),
  7257.                             'password' => $licenseDataBaseEntity[0]->getDbpass(),
  7258.                             'host' => $licenseDataBaseEntity[0]->getDbhost(),
  7259.                             'driver' => 'pdo_mysql',
  7260.                         ];
  7262.                         $msg = [
  7263.                             'id' => $readFilesDataEntityByLicense[0]->getId(),
  7264.                             'dataOptionsRoot' => $dataOptionsRoot,
  7265.                             'path' => $theAccountPath,
  7266.                             'fileName' => $readFilesDataEntityByLicense[0]->getRfNameFile(),
  7267.                             'AccountLicense' => $usernameByNickname->getAlAccountLicense()->getAcName(),
  7268.                             'pushchanel' => $usernameByNickname->getAlLicenseUsername()
  7269.                         ];
  7271.                         $readFilesDataEntityByLicense[0]->setIsReadedByServer(true);
  7272.                         $em->persist($readFilesDataEntityByLicense[0]);
  7273.                         $em->flush();
  7275. //                        $this->get('incoming_android_sync_producer')->setContentType('application/json');
  7276. //                        $this->get('incoming_android_sync_producer')->setDeliveryMode(2);
  7277. //                        $this->get('incoming_android_sync_producer')->publish(json_encode($msg));
  7279.                         if (!$request->request->get('hold')) {
  7280.                             $statusArryMsg['msg'] = 'File has been uploaded and the sync process triggered';
  7281.                             $this->createFileJson($path, 'File has been uploaded and the sync process triggered' . "\r");
  7283.                             $data['readFilesDataId'] = $readFilesDataEntityByLicense[0]->getId();
  7284. //                            ForcedAsynchronousCommandsUtil::consumeDownUpSyncCommand($this->realContainer, $data, true);
  7285.                         } else {
  7286.                             $statusArryMsg['msg'] = 'File has been uploaded and the sync process is ready to start';
  7287.                             $this->createFileJson($path, 'File has been uploaded and the sync process is ready to start' . "\r");
  7288.                         }
  7289.                     }
  7291.                     $this->createFileJson($path, 'Track 7! ' . "\r");
  7293.                     $theUrlTrSt = new UploadSyncJsonNotifyTransformer($this->realContainer, $statusArryMsg);
  7295.                     $jsonTransform = $theUrlTrSt->transform();
  7297.                     $jsonContent = json_encode($jsonTransform);
  7299.                     $this->createFileJson($path, 'Track 8! ' . "\r");
  7301.                     $this->createFileJson($path, 'UploadSyncJsonNotifyTransformer json to respond' . $jsonContent . "\r");
  7303.                     return $this->respondWithItem($jsonContent, $theUrlTrSt);
  7304.                 } else {
  7305.                     $this->createFileJson($path, 'Salio 3! ' . "\r");
  7306.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  7307.                                     ->respondWithError('Inactive License', WebService::CODE_ACCOUNT_SUSPENDED);
  7308.                 }
  7309.             } else {
  7310.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  7311.                                 ->respondWithError('Invalid nickname', WebService::CODE_COULD_NOT_AUTHENTICATE);
  7312.             }
  7313.         } else {
  7314.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  7315.         }
  7316.     }
  7317.     public function licensorLicenseLastSync(Request $request){
  7318.         if ($request->getMethod() != WebService::REQUEST_METHOD_GET) {
  7320.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_GET . " method");
  7321.         }
  7322.         $response=$request->query->get("nicknamelicense");
  7324.         if ($response == '') {
  7325.             return $this->errorWrongArgs('Empty Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  7326.         }
  7329.         $em = $this->getDoctrine()->getManager();
  7330.         $lastSync = $em->getRepository('App\Entity\MasterSync')->lastSyncForLicenseNickName($response);
  7331.         if (!empty($lastSync)){
  7332.             $date=$lastSync[0]["msDateSyncAsk"];
  7333.             $stringDate = $date->format('Y-m-d H:i:s');
  7334.             $lastSync[0]["msDateSyncAsk"]=$stringDate;
  7335.             $lastSync = $lastSync[0];
  7337.         }
  7338.         
  7339.         $responseArr['status'] = WebService::CODE_SUCCESS;
  7340.         $responseArr['msg'] = $lastSync;
  7341.         $responseArr['bigbag'] = true;
  7343.         $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  7344.         $xxArray = $theUrlTrSt->transform();
  7345.         $jsonContent = json_encode($xxArray);
  7347.         return $this->respondWithItem($jsonContent, $theUrlTrSt);
  7349.         } 
  7350.     /**
  7351.      * WS para registrar la pushy key de un dispositivo de una licencia
  7352.      * @author Aealan Z <lrobledo@kijho.com> 05/11/15
  7353.      * @param \Symfony\Component\HttpFoundation\Request $request datos
  7354.      * de la solicitud
  7355.      * @return Response Json con la informacion de respuesta
  7356.      */
  7357.     public function getSQLLiteQueryToCleanBadAndroidSyncDataRecords(Request $request) {
  7359.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  7361.             if (0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE) || 0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT)) {
  7363.                 $path = Util::getValidActiveLogByBaseName($this->realContainer, 'getSQLLiteQueryToCleanBadAndroidSyncDataRecords', 'getSQLLiteQueryToCleanBadAndroidSyncDataRecords0.txt');
  7364.                 $this->createFileJson($path, "\r" . 'Incoming parameters: ' . $request->getContent() . "\r");
  7366.                 $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  7367.                 $data = json_decode($arrayEncryptResult['data'], true);
  7369.                 if (!isset($data['nickname']) || !isset($data['data'])) {
  7370.                     return $this->errorWrongArgs('Wrong Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  7371.                 }
  7373.                 $this->createFileJson($path, 'Decrypted: ' . $arrayEncryptResult['data'] . "\r");
  7375.                 if ($data['nickname'] == '' || $data['data'] == '') {
  7376.                     return $this->errorWrongArgs('Empty Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  7377.                 }
  7379.                 $licenseUserName = ['alLicenseUsername' => $data['nickname']];
  7381.                 $em = $this->getDoctrine()->getManager();
  7382.                 $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findBy($licenseUserName);
  7384.                 $countResult = count($accountLicenseData);
  7385.                 if ($countResult > 0) {
  7387.                     $basicJsonResponseToProcess = $data['data'];
  7388.                     $auxJsonDecodeArray = json_decode($basicJsonResponseToProcess, true);
  7389.                     $auxSQLString = "SELECT +'+ || syn_id || +'+ || +,+ FROM sync_data WHERE syn_record_id IN (";
  7391.                     foreach ($auxJsonDecodeArray['data'] as $tableIndex) {
  7392.                         foreach ($tableIndex as $tableData) {
  7393.                             if ($tableData) {
  7394.                                 $auxSQLString .= "'$tableData',";
  7395.                             } 
  7396.                         }
  7397.                     }
  7399.                     $auxSQLString .= ");";
  7401.                     $auxSQLString = str_replace(",)",")", $auxSQLString);
  7403.                     $auxSQLString = str_replace("+",'"', $auxSQLString);
  7405.                     $responseArr['status'] = WebService::CODE_SUCCESS;
  7406.                     $responseArr['msg'] = 'SQLLite Query Obtained!';
  7407.                     $responseArr['sqlliteQuery'] = $auxSQLString;
  7408.                     $responseArr['bigbag'] = true;
  7410.                     $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  7411.                     $xxArray = $theUrlTrSt->transform();
  7413.                     $jsonContent = json_encode($xxArray);
  7415.                     return $this->respondWithItem($jsonContent, $theUrlTrSt);
  7416.                 } else {
  7417.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  7418.                                     ->respondWithError('Invalid channel', WebService::CODE_COULD_NOT_AUTHENTICATE);
  7419.                 }
  7420.             } else {
  7421.                 return $this->errorWrongArgs('Wrong Content!', WebService::CODE_WRONG_ARGUMENTS);
  7422.             }
  7423.         } else {
  7424.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  7425.         }
  7426.     }
  7428.     /**
  7429.      * WS para registrar la pushy key de un dispositivo de una licencia
  7430.      * @author Aealan Z <lrobledo@kijho.com> 05/11/15
  7431.      * @param \Symfony\Component\HttpFoundation\Request $request datos
  7432.      * de la solicitud
  7433.      * @return Response Json con la informacion de respuesta
  7434.      */
  7435.     public function setBadSyncDataRecordsInRegistActionForCleanse(Request $request) {
  7437.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  7439.             if (0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE) || 0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT)) {
  7441.                 $path = Util::getValidActiveLogByBaseName($this->realContainer, 'setBadSyncDataRecordsInRegistActionForCleanse', 'setBadSyncDataRecordsInRegistActionForCleanse0.txt');
  7442.                 $this->createFileJson($path, "\r" . 'Incoming parameters: ' . $request->getContent() . "\r");
  7444.                 $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  7445.                 $data = json_decode($arrayEncryptResult['data'], true);
  7447.                 if (!isset($data['nickname']) || !isset($data['data'])) {
  7448.                     return $this->errorWrongArgs('Wrong Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  7449.                 }
  7451.                 $this->createFileJson($path, 'Decrypted: ' . $arrayEncryptResult['data'] . "\r");
  7453.                 if ($data['nickname'] == '' || $data['data'] == '') {
  7454.                     return $this->errorWrongArgs('Empty Arguments.', WebService::CODE_WRONG_ARGUMENTS);
  7455.                 }
  7457.                 $licenseUserName = ['alLicenseUsername' => $data['nickname']];
  7459.                 $em = $this->getDoctrine()->getManager();
  7460.                 $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findBy($licenseUserName);
  7462.                 $countResult = count($accountLicenseData);
  7463.                 if ($countResult > 0) {
  7465.                     $auxStringAndroidSyncDataIds = $data['data'];
  7467.                     $auxArrayToRegistActionRecord = explode(',', $auxStringAndroidSyncDataIds);
  7469.                     $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData[0]);
  7471.                     $insertCounter = 0;
  7472.                     foreach ($auxArrayToRegistActionRecord as $recordToRegistAction) {
  7473.                         if ($recordToRegistAction != '') {
  7474.                             Util::saveUpdateRecordInRegistActionsByDataArray($emLev, 'sync_data', ['level' => $recordToRegistAction, 'android' => $recordToRegistAction], 'D');
  7475.                             ++$insertCounter;
  7476.                         }
  7477.                     }
  7479.                     $responseArr['status'] = WebService::CODE_SUCCESS;
  7480.                     $responseArr['msg'] = "$insertCounter records where inserted into regist action! ready to sync?";
  7481.                     $responseArr['bigbag'] = false;
  7483.                     $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  7484.                     $xxArray = $theUrlTrSt->transform();
  7486.                     $jsonContent = json_encode($xxArray);
  7488.                     return $this->respondWithItem($jsonContent, $theUrlTrSt);
  7489.                 } else {
  7490.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  7491.                                     ->respondWithError('Invalid channel', WebService::CODE_COULD_NOT_AUTHENTICATE);
  7492.                 }
  7493.             } else {
  7494.                 return $this->errorWrongArgs('Wrong Content!', WebService::CODE_WRONG_ARGUMENTS);
  7495.             }
  7496.         } else {
  7497.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  7498.         }
  7499.     }
  7501.     /**
  7502.      * Crea la semilla de notificación para el contexto CONTEXT_NOTIFICATION_ANDROID_LAST_SYNC.
  7503.      * 
  7504.      * Recibe la entidad de AccountLicense, invoca a la función  getDateOfLastSync la cual trae la fecha de la ultima sincronización,
  7505.      * luego se valida si la fecha retornada sea menor a la fecha actual menos una constate de días, si esto se cumple se procede a
  7506.      * crear o actualizar  la semilla, si este ultimo caso lleva mas de una semana de ser notificada.
  7507.      * 
  7508.      * @author Jhonan Vargas <jsmith@openmytab.com> 19/01/2022
  7509.      * @access private
  7510.      * @param type AccountLicense $license
  7511.     */
  7512.     public function notifyLastSyncByLicense($em, $license){
  7513.         
  7514.         $dateLastSync = $em->getRepository('App\Entity\MasterSync')->getDateOfLastSync($license->getId());
  7515.         
  7516.         if($dateLastSync){
  7517.             $currentDate = Utilx::getCurrentDate();
  7518.             $days = $this->realContainer->getParameter('max_days_without_android_sync');
  7519.             $dateMinusDays = clone $currentDate;
  7520.             $dateMinusDays->modify("-$days days");    
  7522.             if($dateMinusDays >= $dateLastSync){
  7523.                 $seed = $em->getRepository("App\Entity\NotificationInLicensorBell")->findOneBy(["context" => NotificationInLicensorBell::CONTEXT_NOTIFICATION_ANDROID_LAST_SYNC, "license" => $license]);
  7524.                 $title = 'Android device not synced in ' . $license->getAlLicenseUsername() . ' license';
  7525.                 $message = "The Android device has not been synced for $days days or more.";
  7527.                 if(!is_null($seed)){
  7528.                     $dateMinusOneWeek = clone $currentDate;
  7529.                     $dateMinusOneWeek->modify('-1 week');
  7530.                     
  7531.                     if($seed->getPickedtByValidatingCronDate()){
  7532.                         
  7533.                         if ($dateMinusOneWeek >= $seed->getPickedtByValidatingCronDate()) {
  7534.                             $seed->setDateCreated($currentDate);
  7535.                             $seed->setPickedtByValidatingCronDate(null);
  7536.                             $seed->setNotificationMsg($message);
  7537.                             
  7538.                             $em->persist($seed);
  7539.                             $em->flush();
  7540.                         }
  7541.                     }
  7542.                 } else {
  7543.                     $seed = new NotificationInLicensorBell();
  7544.                     $seed->setNotificationTitle($title);
  7545.                     $seed->setNotificationLabel(NotificationInLicensorBell::NOTIFICATION_TYPE_WARNING);
  7546.                     $seed->setNotificationMsg($message);
  7547.                     $seed->setDateCreated($currentDate);
  7548.                     $seed->setContext(NotificationInLicensorBell::CONTEXT_NOTIFICATION_ANDROID_LAST_SYNC);
  7549.                     $seed->setLicense($license);
  7550.                     $seed->setTypeRoleToNotify(NotificationInLicensorBell::ROLE_ADMINISTRATOR);
  7551.                     $seed->setNotificationAlt('Android has not synced');
  7552.                     $seed->setNotificationHTMLTitle($title);
  7554.                     $em->persist($seed);
  7555.                     $em->flush();
  7556.                 }
  7557.             }
  7558.         }
  7559.     }
  7561.     // public function 
  7562. }